Smart DB connection with pooler support and SQLite fallback

backend/app/db/session.py

@@ -1,85 +1,255 @@
 """
-Database Session
+Database Session - FINAL BOSS EDITION
 
-Database engine creation and session management.
-Uses Supabase transaction pooler (port 6543) for HF Spaces compatibility.
+Handles Supabase connection with multiple fallback strategies:
+1. Supabase Pooler hostname (pooler.supabase.com) - for HF Spaces (IPv4)
+2. Direct connection with port 6543 (transaction pooler)
+3. Direct connection with port 5432
+4. SQLite fallback - absolute last resort
+
+Key insight: HF Spaces blocks IPv6. Supabase direct hostname returns IPv6.
+Solution: Use pooler.supabase.com which supports IPv4.
 """
 
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker, Session
-from typing import Generator
+from typing import Generator, Tuple, Optional
 import os
+import re
+import socket
 
 from app.core.config import settings
 from app.db.base import Base
 
 
+# Force IPv4 for DNS resolution (workaround for HF Spaces IPv6 blocking)
+_original_getaddrinfo = socket.getaddrinfo
+
+def _ipv4_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
+    """Force IPv4 resolution by setting family to AF_INET"""
+    return _original_getaddrinfo(host, port, socket.AF_INET, type, proto, flags)
+
+
 # ===========================================
-# DATABASE CONNECTION - SUPABASE
-# Use port 6543 (transaction pooler) - works on HF Spaces
+# DATABASE CONNECTION STRATEGIES
 # ===========================================
 
-def _get_pooler_url(direct_url: str) -> str:
+def _extract_supabase_info(url: str) -> Optional[dict]:
     """
-    Convert direct Supabase URL (port 5432) to transaction pooler URL (port 6543).
-    
-    Direct: postgresql://postgres:password@db.PROJECT.supabase.co:5432/postgres
-    Pooler: postgresql://postgres:password@db.PROJECT.supabase.co:6543/postgres
+    Extract Supabase connection info from DATABASE_URL.
     """
-    if ':5432/' in direct_url:
-        return direct_url.replace(':5432/', ':6543/')
-    return direct_url
+    # Match: postgresql://user:password@db.PROJECT.supabase.co:PORT/database
+    match = re.match(
+        r'postgresql://([^:]+):([^@]+)@db\.([^.]+)\.supabase\.co:(\d+)/(.+)',
+        url
+    )
+    
+    if match:
+        return {
+            'user': match.group(1),
+            'password': match.group(2),
+            'project_ref': match.group(3),
+            'port': match.group(4),
+            'database': match.group(5),
+        }
+    return None
 
 
-def _create_engine_with_supabase():
+def _build_connection_urls(db_url: str) -> list:
     """
-    Create database engine with Supabase connection.
-    Uses transaction pooler (port 6543) which works on HF Spaces.
+    Build list of connection URLs to try, in order of preference.
+    
+    Priority order:
+    1. SUPABASE_POOLER_URL if set (user-provided pooler URL)
+    2. Session pooler (port 5432 on pooler.supabase.com) - IPv4 friendly
+    3. Transaction pooler (port 6543 on pooler.supabase.com) - serverless optimized
+    4. Direct port 6543 - transaction mode on direct host
+    5. Direct port 5432 - original connection
     """
-    db_url = settings.DATABASE_URL
+    urls = []
     
-    # If already SQLite, use it directly
+    # Check if it's already SQLite
     if db_url.startswith("sqlite"):
-        print("🔗 Using SQLite database")
-        return create_engine(
-            db_url,
-            connect_args={"check_same_thread": False},
-            echo=False,
-        ), True
+        return [("sqlite", db_url)]
     
-    # Convert to pooler URL (port 6543)
-    pooler_url = _get_pooler_url(db_url)
+    # PRIORITY 0: Check for user-provided pooler URL
+    pooler_url = os.environ.get("SUPABASE_POOLER_URL")
+    if pooler_url:
+        print(f"   📍 Found SUPABASE_POOLER_URL environment variable")
+        urls.append(("env-pooler", pooler_url))
     
-    print(f"🔗 Connecting to Supabase (transaction pooler port 6543)...")
+    # Extract Supabase info
+    info = _extract_supabase_info(db_url)
     
+    if info:
+        project = info['project_ref']
+        password = info['password']
+        database = info['database']
+        
+        # Common AWS regions for Supabase
+        regions = [
+            'ap-south-1',      # India (likely region based on project)
+            'us-east-1',       # US East (most common)
+            'ap-southeast-1',  # Singapore
+            'eu-west-1',       # Europe
+            'us-west-1',       # US West
+            'eu-central-1',    # Frankfurt
+        ]
+        
+        # Strategy 1: Session Mode Pooler (port 5432) - IPv4 compatible
+        # Format: postgres://postgres.PROJECT:PASSWORD@aws-0-REGION.pooler.supabase.com:5432/postgres
+        for region in regions:
+            session_url = f"postgresql://postgres.{project}:{password}@aws-0-{region}.pooler.supabase.com:5432/{database}"
+            urls.append((f"session-{region}", session_url))
+        
+        # Strategy 2: Transaction Mode Pooler (port 6543) - serverless optimized
+        for region in regions:
+            txn_url = f"postgresql://postgres.{project}:{password}@aws-0-{region}.pooler.supabase.com:6543/{database}"
+            urls.append((f"txn-{region}", txn_url))
+        
+        # Strategy 3: Direct connection with port 6543 (transaction mode on direct host)
+        direct_6543 = db_url.replace(':5432/', ':6543/')
+        urls.append(("direct-6543", direct_6543))
+        
+        # Strategy 4: Direct connection with port 5432 (original)
+        urls.append(("direct-5432", db_url))
+    else:
+        # Not a standard Supabase URL, try as-is
+        urls.append(("custom", db_url))
+    
+    return urls
+
+
+def _test_connection(url: str, name: str, timeout: int = 10, force_ipv4: bool = False) -> Optional[object]:
+    """
+    Test a database connection and return engine if successful.
+    """
     try:
-        pg_engine = create_engine(
-            pooler_url,
+        # Optionally force IPv4 resolution
+        if force_ipv4:
+            socket.getaddrinfo = _ipv4_getaddrinfo
+        
+        engine = create_engine(
+            url,
             pool_pre_ping=True,
-            pool_size=5,
-            max_overflow=10,
-            pool_timeout=30,
+            pool_size=3,
+            max_overflow=5,
+            pool_timeout=timeout,
             connect_args={
-                "connect_timeout": 15,
+                "connect_timeout": timeout,
             },
             echo=False,
         )
         
         # Test the connection
-        with pg_engine.connect() as conn:
+        with engine.connect() as conn:
             result = conn.execute(text("SELECT 1"))
-            print(f"✅ Supabase connected successfully!")
+            result.fetchone()
         
-        return pg_engine, False
+        return engine
         
     except Exception as e:
-        print(f"❌ Supabase connection failed: {str(e)[:100]}")
-        print("⚠️  Check DATABASE_URL environment variable")
-        raise RuntimeError(f"Cannot connect to Supabase: {e}")
+        error_msg = str(e)[:80]
+        print(f"   ❌ {name}: {error_msg}")
+        return None
+    finally:
+        # Restore original getaddrinfo
+        if force_ipv4:
+            socket.getaddrinfo = _original_getaddrinfo
+
+
+def _create_sqlite_fallback():
+    """
+    Create SQLite database as absolute last resort.
+    """
+    sqlite_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "data", "fallback.db")
+    os.makedirs(os.path.dirname(sqlite_path), exist_ok=True)
+    
+    sqlite_url = f"sqlite:///{sqlite_path}"
+    
+    engine = create_engine(
+        sqlite_url,
+        connect_args={"check_same_thread": False},
+        echo=False,
+    )
+    
+    return engine, True
 
 
-# Create engine
-engine, is_sqlite = _create_engine_with_supabase()
+def _create_engine_smart():
+    """
+    Create database engine using smart connection strategy.
+    Tries multiple connection methods until one works.
+    """
+    db_url = settings.DATABASE_URL
+    
+    print("🔗 Connecting to database...")
+    print(f"📦 Environment: {os.environ.get('ENVIRONMENT', 'development')}")
+    
+    # If already SQLite, use it directly
+    if db_url.startswith("sqlite"):
+        print("📁 Using SQLite database (configured)")
+        return create_engine(
+            db_url,
+            connect_args={"check_same_thread": False},
+            echo=False,
+        ), True
+    
+    # Get all connection URLs to try
+    connection_urls = _build_connection_urls(db_url)
+    
+    print(f"🎯 Trying {len(connection_urls)} connection strategies...")
+    
+    # Try each connection strategy
+    for name, url in connection_urls:
+        print(f"   🔄 Trying {name}...")
+        
+        # Force IPv4 for direct connections (HF Spaces blocks IPv6)
+        force_ipv4 = "direct-" in name or name == "custom"
+        engine = _test_connection(url, name, force_ipv4=force_ipv4)
+        
+        if engine:
+            print(f"✅ Connected via {name}!")
+            
+            # Verify we can query
+            try:
+                with engine.connect() as conn:
+                    result = conn.execute(text("SELECT COUNT(*) FROM users"))
+                    count = result.fetchone()[0]
+                    print(f"   📊 Users in database: {count}")
+            except Exception:
+                print(f"   📊 Database connected (tables may not exist yet)")
+            
+            return engine, False
+    
+    # All strategies failed - use SQLite fallback
+    print("")
+    print("=" * 60)
+    print("⚠️  ALL DATABASE CONNECTIONS FAILED!")
+    print("=" * 60)
+    print("")
+    print("Could not connect to Supabase. This usually happens on HF Spaces")
+    print("because the direct database hostname only supports IPv6.")
+    print("")
+    print("🔧 TO FIX: Set SUPABASE_POOLER_URL in HF Spaces Secrets:")
+    print("   1. Go to Supabase Dashboard → Your Project → Connect")
+    print("   2. Select 'Transaction pooler' tab")
+    print("   3. Copy the connection string")
+    print("   4. Add as HF Spaces Secret: SUPABASE_POOLER_URL")
+    print("")
+    print("🔄 Using SQLite fallback to keep app running...")
+    print("   ⚠️  Data will NOT sync to Supabase!")
+    print("")
+    
+    return _create_sqlite_fallback()
+
+
+# ===========================================
+# INITIALIZE DATABASE
+# ===========================================
+
+# Create engine using smart connection strategy
+engine, is_sqlite = _create_engine_smart()
 
 # Create session factory
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@@ -91,11 +261,6 @@ def get_db() -> Generator[Session, None, None]:
     
     Yields a database session and ensures it's closed after use.
     Use with FastAPI's Depends().
-    
-    Example:
-        @app.get("/items")
-        def get_items(db: Session = Depends(get_db)):
-            return db.query(Item).all()
     """
     db = SessionLocal()
     try:
@@ -104,30 +269,46 @@ def get_db() -> Generator[Session, None, None]:
         db.close()
 
 
-def init_db() -> None:
+def init_db():
     """
     Initialize database tables.
     
-    Creates all tables defined in models if they don't exist.
+    Creates all tables defined in the models.
     Should be called on application startup.
     """
-    # Import all models to ensure they're registered with Base
-    from app.users.models import User, UserSession
-    from app.interviews.models import InterviewSession, InterviewQuestion, InterviewResponse
+    from app.users.models import User
+    from app.interviews.models import Interview
     from app.interviews.plan_models import InterviewPlan
-    from app.interviews.live_models import LiveInterviewSession
-    from app.evaluations.models import Evaluation
+    from app.interviews.live_models import LiveInterview
+    from app.evaluations.models import InterviewEvaluation
+    from app.ats.models import ATSConfiguration, CandidateProfile
+    from app.admin.models import AdminSettings
+    from app.roadmap.models import RoadmapProgress
+    from app.personalities.models import InterviewerPersonality
+    
+    db_type = "SQLite" if is_sqlite else "PostgreSQL (Supabase)"
+    print(f"🗄️  Initializing {db_type} tables...")
     
-    # Create tables
     Base.metadata.create_all(bind=engine)
-    print("✅ Database tables initialized")
+    print(f"✅ Database tables ready!")
 
 
-def get_engine():
-    """Get the database engine."""
-    return engine
+def close_db():
+    """
+    Close database connections.
+    
+    Should be called on application shutdown.
+    """
+    engine.dispose()
+    print("🔌 Database connections closed")
 
 
-def is_using_sqlite() -> bool:
-    """Check if using SQLite (vs PostgreSQL)."""
-    return is_sqlite
+# Export for use in other modules
+__all__ = [
+    'engine',
+    'SessionLocal', 
+    'get_db',
+    'init_db',
+    'close_db',
+    'is_sqlite'
+]