added

app/auth/routes.py

@@ -5,10 +5,6 @@ from datetime import datetime, timedelta
 from typing import Optional
 import bcrypt
 import logging
-import asyncio
-import httpx
-from gotrue.errors import AuthRetryableError
-from gotrue.types import AuthResponse as GoTrueAuthResponse
 
 from app.config.settings import settings
 from app.db.models import (
@@ -30,14 +26,12 @@ logger = logging.getLogger(__name__)
 
 # Initialize Supabase client
 def get_supabase_client() -> Client:
-    """Get Supabase client instance with proper timeout configuration."""
+    """Get Supabase client instance."""
     if not settings.SUPABASE_URL or not settings.SUPABASE_SERVICE_KEY:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Supabase configuration is missing"
         )
-    
-    # Create client - we'll handle timeouts in the retry logic
     return create_client(settings.SUPABASE_URL, settings.SUPABASE_SERVICE_KEY)
 
 
@@ -52,38 +46,6 @@ def verify_password(password: str, hashed_password: str) -> bool:
     return bcrypt.checkpw(password.encode('utf-8'), hashed_password.encode('utf-8'))
 
 
-async def retry_auth_operation(operation, max_retries: int = 3, delay: float = 1.0) -> GoTrueAuthResponse:
-    """Retry authentication operations with exponential backoff."""
-    last_exception = None
-    
-    for attempt in range(max_retries):
-        try:
-            result = operation()
-            return result
-        except (AuthRetryableError, httpx.TimeoutException, httpx.ReadTimeout) as e:
-            last_exception = e
-            if attempt == max_retries - 1:
-                logger.error(f"Auth operation failed after {max_retries} attempts: {e}")
-                raise HTTPException(
-                    status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                    detail=f"Authentication service is currently unavailable. Please try again in a few minutes. (Attempt {max_retries}/{max_retries})"
-                )
-            
-            wait_time = delay * (2 ** attempt)
-            logger.warning(f"Auth operation timeout, retrying in {wait_time}s (attempt {attempt + 1}/{max_retries}): {e}")
-            await asyncio.sleep(wait_time)
-        except Exception as e:
-            # For non-retryable errors, fail immediately
-            logger.error(f"Non-retryable auth error: {e}")
-            raise
-    
-    # This should never be reached, but just in case
-    raise HTTPException(
-        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-        detail=f"Authentication service failed after {max_retries} attempts"
-    )
-
-
 async def create_user_session(
     user_id: str, 
     access_token: str, 
@@ -139,55 +101,32 @@ async def register(request: Request, user_data: RegisterRequest):
                 detail="User with this email already exists"
             )
         
-        # Create user using Supabase Auth with retry logic
+        # Create user using Supabase Auth
         logger.info(f"Creating auth user in Supabase for email={user_data.email}")
-        
-        def create_auth_user():
-            return supabase.auth.sign_up({
-                "email": user_data.email,
-                "password": user_data.password,
-                "options": {
-                    "data": {
-                        "username": user_data.username,
-                        "full_name": user_data.full_name
-                    }
+        auth_response = supabase.auth.sign_up({
+            "email": user_data.email,
+            "password": user_data.password,
+            "options": {
+                "data": {
+                    "username": user_data.username,
+                    "full_name": user_data.full_name
                 }
-            })
-        
-        try:
-            auth_response = await retry_auth_operation(
-                create_auth_user, 
-                max_retries=settings.AUTH_RETRY_ATTEMPTS, 
-                delay=settings.AUTH_RETRY_DELAY
-            )
-        except HTTPException as e:
-            logger.error(f"Supabase auth sign_up failed for email={user_data.email} after retries: {e.detail}")
-            raise HTTPException(
-                status_code=e.status_code,
-                detail=f"User registration is temporarily unavailable. {e.detail}"
-            )
+            }
+        })
         
         logger.debug(f"Supabase auth sign_up response for email={user_data.email}: user_present={bool(getattr(auth_response, 'user', None))}")
-        if not hasattr(auth_response, 'user') or not auth_response.user:
+        if not auth_response.user:
             logger.error(f"Supabase auth failed to create user for email={user_data.email}")
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail="Failed to create user"
             )
         
-        user_id = getattr(auth_response.user, 'id', None)
-        if not user_id:
-            logger.error(f"Auth response missing user ID for email={user_data.email}")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Authentication response is invalid"
-            )
-        
-        logger.info(f"Supabase auth created user id={user_id} for email={user_data.email}")
+        logger.info(f"Supabase auth created user id={auth_response.user.id} for email={user_data.email}")
         
         # Create user record in our custom table with error handling for duplicates
         user_record = {
-            "id": user_id,
+            "id": auth_response.user.id,
             "email": user_data.email,
             "username": user_data.username,
             "full_name": user_data.full_name,
@@ -212,15 +151,15 @@ async def register(request: Request, user_data: RegisterRequest):
             logger.warning(f"DB insert error for user id={user_record['id']}: {db_error}")
             # Check if this is a duplicate key error (user already exists)
             if "duplicate key" in str(db_error) or "23505" in str(db_error):
-                logger.info(f"Duplicate key detected when inserting user id={user_id}, attempting to fetch existing record")
+                logger.info(f"Duplicate key detected when inserting user id={user_record['id']}, attempting to fetch existing record")
                 # User already exists in our table, fetch existing user
-                existing_user_response = supabase.table("users").select("*").eq("id", user_id).execute()
-                logger.debug(f"Existing user fetch result for id={user_id}: {existing_user_response.data}")
+                existing_user_response = supabase.table("users").select("*").eq("id", auth_response.user.id).execute()
+                logger.debug(f"Existing user fetch result for id={auth_response.user.id}: {existing_user_response.data}")
                 if existing_user_response.data:
                     user = User(**existing_user_response.data[0])
                     logger.info(f"Fetched existing user record for id={user.id}")
                 else:
-                    logger.error(f"Duplicate key error but failed to fetch existing user id={user_id}")
+                    logger.error(f"Duplicate key error but failed to fetch existing user id={auth_response.user.id}")
                     raise HTTPException(
                         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                         detail="User creation failed"
@@ -271,41 +210,20 @@ async def login(request: Request, credentials: LoginRequest):
     supabase = get_supabase_client()
     
     try:
-        # Authenticate with Supabase using retry logic
-        def auth_signin():
-            return supabase.auth.sign_in_with_password({
-                "email": credentials.email,
-                "password": credentials.password
-            })
-        
-        try:
-            auth_response = await retry_auth_operation(
-                auth_signin, 
-                max_retries=settings.AUTH_RETRY_ATTEMPTS, 
-                delay=settings.AUTH_RETRY_DELAY
-            )
-        except HTTPException as e:
-            logger.error(f"Supabase auth sign_in failed for email={credentials.email} after retries: {e.detail}")
-            raise HTTPException(
-                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-                detail="Authentication service is temporarily unavailable. Please try again in a few minutes."
-            )
+        # Authenticate with Supabase
+        auth_response = supabase.auth.sign_in_with_password({
+            "email": credentials.email,
+            "password": credentials.password
+        })
         
-        if not hasattr(auth_response, 'user') or not auth_response.user:
+        if not auth_response.user:
             raise HTTPException(
                 status_code=status.HTTP_401_UNAUTHORIZED,
                 detail="Invalid email or password"
             )
         
         # Get user from our custom table
-        user_id = getattr(auth_response.user, 'id', None)
-        if not user_id:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Authentication response is invalid"
-            )
-        
-        user_response = supabase.table("users").select("*").eq("id", user_id).execute()
+        user_response = supabase.table("users").select("*").eq("id", auth_response.user.id).execute()
         if not user_response.data:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -457,32 +375,3 @@ async def get_user_sessions(current_user: User = Depends(auth_middleware.get_cur
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to fetch sessions"
         )
-
-
-@router.get("/health")
-async def auth_health_check():
-    """Check authentication service health."""
-    try:
-        supabase = get_supabase_client()
-        # Simple health check by attempting to access the users table
-        start_time = datetime.utcnow()
-        supabase.table("users").select("id").limit(1).execute()
-        end_time = datetime.utcnow()
-        response_time = (end_time - start_time).total_seconds()
-        
-        return {
-            "status": "healthy",
-            "service": "authentication",
-            "response_time_seconds": response_time,
-            "timestamp": datetime.utcnow().isoformat(),
-            "supabase_connection": "ok"
-        }
-    except Exception as e:
-        logger.error(f"Auth health check failed: {e}")
-        return {
-            "status": "unhealthy",
-            "service": "authentication",
-            "error": str(e),
-            "timestamp": datetime.utcnow().isoformat(),
-            "supabase_connection": "failed"
-        }

app/config/settings.py

@@ -30,11 +30,6 @@ class Settings:
     SUPABASE_URL: Optional[str] = os.getenv("SUPABASE_URL")
     SUPABASE_SERVICE_KEY: Optional[str] = os.getenv("SUPABASE_SERVICE_KEY")
     SUPABASE_ANON_KEY: Optional[str] = os.getenv("SUPABASE_ANON_KEY")
-    
-    # Timeout Configuration
-    AUTH_TIMEOUT_SECONDS: int = int(os.getenv("AUTH_TIMEOUT_SECONDS", "30"))
-    AUTH_RETRY_ATTEMPTS: int = int(os.getenv("AUTH_RETRY_ATTEMPTS", "3"))
-    AUTH_RETRY_DELAY: float = float(os.getenv("AUTH_RETRY_DELAY", "2.0"))
 
     # Database
     DATABASE_URL: Optional[str] = os.getenv("DATABASE_URL")

test_auth_timeout.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify authentication timeout handling.
-"""
-
-import asyncio
-import httpx
-import sys
-import os
-
-# Add the app directory to the path so we can import our modules
-sys.path.insert(0, '/home/muneeb/Projects/SanadCheck/sanad-llm')
-
-from app.config.settings import settings
-
-async def test_auth_endpoints():
-    """Test authentication endpoints with proper timeout handling."""
-    
-    base_url = f"http://{settings.HOST}:{settings.PORT}"
-    timeout = httpx.Timeout(30.0, connect=10.0)
-    
-    async with httpx.AsyncClient(timeout=timeout) as client:
-        print(f"Testing authentication endpoints at {base_url}")
-        
-        # Test health endpoint
-        print("\n1. Testing auth health endpoint...")
-        try:
-            response = await client.get(f"{base_url}/auth/health")
-            print(f"Health check status: {response.status_code}")
-            if response.status_code == 200:
-                health_data = response.json()
-                print(f"Health status: {health_data.get('status')}")
-                print(f"Response time: {health_data.get('response_time_seconds')}s")
-            else:
-                print(f"Health check failed: {response.text}")
-        except Exception as e:
-            print(f"Health check error: {e}")
-        
-        # Test registration with timeout-prone data
-        print("\n2. Testing registration endpoint...")
-        test_email = "test_timeout_user@example.com"
-        test_data = {
-            "email": test_email,
-            "password": "SecurePassword123!",
-            "username": "timeout_test_user",
-            "full_name": "Timeout Test User"
-        }
-        
-        try:
-            response = await client.post(f"{base_url}/auth/register", json=test_data)
-            print(f"Registration status: {response.status_code}")
-            if response.status_code == 200:
-                print("Registration successful!")
-                reg_data = response.json()
-                print(f"User ID: {reg_data.get('user', {}).get('id')}")
-            elif response.status_code == 400:
-                print("User might already exist or validation error")
-                print(f"Error: {response.json().get('detail')}")
-            elif response.status_code == 503:
-                print("Service unavailable - this is expected if Supabase is timing out")
-                print(f"Error: {response.json().get('detail')}")
-            else:
-                print(f"Unexpected response: {response.text}")
-        except httpx.TimeoutException as e:
-            print(f"Client timeout (this shouldn't happen with our retry logic): {e}")
-        except Exception as e:
-            print(f"Registration error: {e}")
-
-if __name__ == "__main__":
-    print("Authentication Timeout Test")
-    print("=" * 50)
-    print(f"AUTH_TIMEOUT_SECONDS: {settings.AUTH_TIMEOUT_SECONDS}")
-    print(f"AUTH_RETRY_ATTEMPTS: {settings.AUTH_RETRY_ATTEMPTS}")
-    print(f"AUTH_RETRY_DELAY: {settings.AUTH_RETRY_DELAY}")
-    
-    asyncio.run(test_auth_endpoints())