deploy fix 96b9977b: OAuth callback fetch error: SyntaxError: Unexpected token 'I' is not valid JSON

Author: PythonToGo

backend/github_oauth.py

@@ -1,30 +1,68 @@
 import os
 import httpx
-from fastapi import Request
+import logging
+from fastapi import Request, HTTPException
+
+logger = logging.getLogger(__name__)
 
 GITHUB_CLIENT_ID = os.getenv("GITHUB_CLIENT_ID")
 GITHUB_CLIENT_SECRET = os.getenv("GITHUB_CLIENT_SECRET")
 
 if not GITHUB_CLIENT_ID or not GITHUB_CLIENT_SECRET:
+    logger.error("GitHub OAuth credentials missing!")
+    logger.error(f"GITHUB_CLIENT_ID: {'present' if GITHUB_CLIENT_ID else 'missing'}")
+    logger.error(f"GITHUB_CLIENT_SECRET: {'present' if GITHUB_CLIENT_SECRET else 'missing'}")
     raise ValueError("❌ GitHub OAuth credentials not found")
 
 async def exchange_code_for_token(code: str):
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            "https://github.com/login/oauth/access_token",
-            headers={"Accept": "application/json"},
-            data={
-                "client_id": GITHUB_CLIENT_ID,
-                "client_secret": GITHUB_CLIENT_SECRET,
-                "code": code
-            }
-        )
-        return response.json()
+    if not code:
+        raise HTTPException(status_code=400, detail="GitHub code is required")
+        
+    try:
+        async with httpx.AsyncClient() as client:
+            logger.info(f"Exchanging code for token with GitHub")
+            response = await client.post(
+                "https://github.com/login/oauth/access_token",
+                headers={"Accept": "application/json"},
+                data={
+                    "client_id": GITHUB_CLIENT_ID,
+                    "client_secret": GITHUB_CLIENT_SECRET,
+                    "code": code
+                }
+            )
+            response.raise_for_status()
+            data = response.json()
+            logger.info("Successfully exchanged code for token")
+            return data
+    except httpx.HTTPError as e:
+        logger.error(f"HTTP error during token exchange: {str(e)}")
+        logger.error(f"Response status: {e.response.status_code if hasattr(e, 'response') else 'unknown'}")
+        logger.error(f"Response body: {e.response.text if hasattr(e, 'response') else 'unknown'}")
+        raise HTTPException(status_code=500, detail=f"GitHub API error: {str(e)}")
+    except Exception as e:
+        logger.exception("Error exchanging code for token:")
+        raise HTTPException(status_code=500, detail=str(e))
 
 async def get_user_info(access_token: str):
-    async with httpx.AsyncClient() as client:
-        response = await client.get(
-            "https://api.github.com/user",
-            headers={"Authorization": f"Bearer {access_token}"}
-        )
-        return response.json()
+    if not access_token:
+        raise HTTPException(status_code=400, detail="Access token is required")
+        
+    try:
+        async with httpx.AsyncClient() as client:
+            logger.info("Fetching user info from GitHub")
+            response = await client.get(
+                "https://api.github.com/user",
+                headers={"Authorization": f"Bearer {access_token}"}
+            )
+            response.raise_for_status()
+            data = response.json()
+            logger.info("Successfully fetched user info")
+            return data
+    except httpx.HTTPError as e:
+        logger.error(f"HTTP error fetching user info: {str(e)}")
+        logger.error(f"Response status: {e.response.status_code if hasattr(e, 'response') else 'unknown'}")
+        logger.error(f"Response body: {e.response.text if hasattr(e, 'response') else 'unknown'}")
+        raise HTTPException(status_code=500, detail=f"GitHub API error: {str(e)}")
+    except Exception as e:
+        logger.exception("Error fetching user info:")
+        raise HTTPException(status_code=500, detail=str(e))

backend/routers/auth.py

@@ -6,49 +6,72 @@
 from database import SessionLocal
 from sqlalchemy import select
 from datetime import datetime
+import logging
 
 auth_router = APIRouter()
+logger = logging.getLogger(__name__)
 
 @auth_router.get("/login/github/callback")
 async def github_callback(request: Request):
-    code = request.query_params.get("code")
-    token_data = await exchange_code_for_token(code)
-    access_token = token_data.get("access_token")
+    try:
+        code = request.query_params.get("code")
+        logger.info(f"Received GitHub code: {code}")
+        
+        token_data = await exchange_code_for_token(code)
+        logger.info(f"GitHub token response: {token_data}")
+        
+        access_token = token_data.get("access_token")
+        if not access_token:
+            logger.error(f"No access token in response: {token_data}")
+            raise HTTPException(status_code=400, detail="Failed to get GitHub access token")
 
-    user_info = await get_user_info(access_token)
-    github_id = user_info.get("id")
-    username = user_info.get("login")
+        user_info = await get_user_info(access_token)
+        logger.info(f"GitHub user info: {user_info}")
+        
+        github_id = str(user_info.get("id"))  # Convert to string to match model
+        username = user_info.get("login")
+        
+        if not github_id or not username:
+            logger.error(f"Invalid user info: {user_info}")
+            raise HTTPException(status_code=400, detail="Invalid GitHub user info")
 
-    async with SessionLocal() as session:
-        result = await session.execute(select(User).where(User.github_id == github_id))
-        user = result.scalar_one_or_none()
+        async with SessionLocal() as session:
+            result = await session.execute(select(User).where(User.github_id == github_id))
+            user = result.scalar_one_or_none()
 
-        now = datetime.now()
+            now = datetime.now()
 
-        if not user:
-            user = User(
-                github_id=github_id,
-                username=username,
-                access_token=access_token,
-                last_login=now,
-                last_push=None
-            )
-            session.add(user)
-        else:
-            user.access_token = access_token
-            user.last_login = now
-        await session.commit()
+            if not user:
+                logger.info(f"Creating new user: {username}")
+                user = User(
+                    github_id=github_id,
+                    username=username,
+                    access_token=access_token,
+                    last_login=now,
+                    last_push=None
+                )
+                session.add(user)
+            else:
+                logger.info(f"Updating existing user: {username}")
+                user.access_token = access_token
+                user.last_login = now
+            await session.commit()
 
-    jwt_token = create_access_token({"github_id": github_id})
-    
-    # chrome URL redirect with JWT
-    return JSONResponse({
-        "message": "GitHub login successful",
-        "token": jwt_token,
-        "username": username,
-        "last_push": user.last_push.isoformat() if user.last_push else None,
-        "last_login": user.last_login.isoformat() if user.last_login else None
-    })
+        jwt_token = create_access_token({"github_id": github_id})
+        
+        response_data = {
+            "message": "GitHub login successful",
+            "token": jwt_token,
+            "username": username,
+            "last_push": user.last_push.isoformat() if user.last_push else None,
+            "last_login": user.last_login.isoformat() if user.last_login else None
+        }
+        logger.info(f"Login successful for user: {username}")
+        return JSONResponse(response_data)
+        
+    except Exception as e:
+        logger.exception("Error in GitHub callback:")
+        raise HTTPException(status_code=500, detail=str(e))
 
 async def get_current_user(authorization: str = Header(...)):
     token = authorization.replace("Bearer ", "")