Simplify login, signup, and token handlers by directly accessing database and handling authentication

app.py

@@ -240,49 +240,65 @@ async def login_proxy(request: Request):
     logger.info("Received login request at /login endpoint")
     if backend_available:
         try:
-            # Read request body as bytes
-            body_bytes = await request.body()
+            # Get the JSON data from the request
+            user_data = await request.json()
+            logger.info(f"Login request data: {user_data}")
             
-            # Try to parse as JSON
+            # Extract username and password
+            username = user_data.get("username")
+            password = user_data.get("password")
+            
+            if not username or not password:
+                logger.error("Missing username or password in login request")
+                return JSONResponse(
+                    content={"error": "Missing username or password"},
+                    status_code=400
+                )
+            
+            # Import database connection and utility functions
+            try:
+                from backend.app.main import users, verify_password, create_access_token
+                from datetime import timedelta
+            except ImportError as e:
+                logger.error(f"Error importing backend modules: {str(e)}")
+                return JSONResponse(
+                    content={"error": "Backend configuration error"},
+                    status_code=500
+                )
+            
+            # Try to find the user in the database
             try:
-                from fastapi.encoders import jsonable_encoder
-                # Use backend login function directly
-                from backend.app.main import login
+                user = await users.find_one({"username": username})
+                if not user:
+                    logger.warning(f"User not found: {username}")
+                    return JSONResponse(
+                        content={"error": "Invalid username or password"},
+                        status_code=401
+                    )
                 
-                # Parse the request body
-                user_data = await request.json()
-                logger.info(f"Login request data: {user_data}")
+                # Verify password
+                if not verify_password(password, user["password"]):
+                    logger.warning(f"Invalid password for user: {username}")
+                    return JSONResponse(
+                        content={"error": "Invalid username or password"},
+                        status_code=401
+                    )
                 
-                # Call the backend function
-                result = await login(request)
-                return result
-            except Exception as json_error:
-                logger.error(f"Error parsing JSON in login request: {str(json_error)}")
+                # Create access token
+                access_token = create_access_token(
+                    data={"sub": username}
+                )
                 
-                # If JSON parsing fails, try using the raw request
-                try:
-                    # Forward to the backend as a new request
-                    from starlette.requests import Request as StarletteRequest
-                    
-                    # Create a new scope
-                    scope = {
-                        "type": "http",
-                        "method": "POST",
-                        "path": "/login",
-                        "headers": [[k.lower().encode(), v.encode()] for k, v in request.headers.items()],
-                    }
-                    
-                    # Create a new request with the same body
-                    from starlette.datastructures import Headers
-                    new_req = StarletteRequest(scope=scope, receive=lambda: {"type": "http.request", "body": body_bytes})
-                    
-                    # Call backend login function
-                    from backend.app.main import login
-                    result = await login(new_req)
-                    return result
-                except Exception as raw_error:
-                    logger.error(f"Error forwarding raw request to login: {str(raw_error)}")
-                    raise HTTPException(status_code=500, detail=f"Login processing error: {str(raw_error)}")
+                return JSONResponse(
+                    content={"access_token": access_token, "token_type": "bearer"},
+                    status_code=200
+                )
+            except Exception as db_error:
+                logger.error(f"Database error in login: {str(db_error)}")
+                return JSONResponse(
+                    content={"error": "Database error", "message": str(db_error)},
+                    status_code=500
+                )
         except Exception as e:
             logger.error(f"General error in login_proxy: {str(e)}")
             return JSONResponse(
@@ -301,48 +317,62 @@ async def signup_proxy(request: Request):
     logger.info("Received signup request at /signup endpoint")
     if backend_available:
         try:
-            # Read request body as bytes
-            body_bytes = await request.body()
+            # Get the JSON data from the request
+            user_data = await request.json()
+            logger.info(f"Signup request data: {user_data}")
+            
+            # Extract username and password
+            username = user_data.get("username")
+            password = user_data.get("password")
+            
+            if not username or not password:
+                logger.error("Missing username or password in signup request")
+                return JSONResponse(
+                    content={"error": "Missing username or password"},
+                    status_code=400
+                )
             
-            # Try to parse as JSON
+            # Import database connection and utility functions
             try:
-                from fastapi.encoders import jsonable_encoder
-                # Use backend signup function directly
-                from backend.app.main import signup
+                from backend.app.main import users, get_password_hash
+            except ImportError as e:
+                logger.error(f"Error importing backend modules: {str(e)}")
+                return JSONResponse(
+                    content={"error": "Backend configuration error"},
+                    status_code=500
+                )
+            
+            # Check if username exists
+            try:
+                existing_user = await users.find_one({"username": username})
+                if existing_user:
+                    logger.warning(f"Username already exists: {username}")
+                    return JSONResponse(
+                        content={"error": "Username already exists"},
+                        status_code=400
+                    )
                 
-                # Parse the request body
-                user_data = await request.json()
-                logger.info(f"Signup request data: {user_data}")
+                # Hash the password and create user
+                hashed_password = get_password_hash(password)
                 
-                # Call the backend function
-                result = await signup(user_data)
-                return result
-            except Exception as json_error:
-                logger.error(f"Error parsing JSON in signup request: {str(json_error)}")
+                # Insert the new user
+                new_user = {
+                    "username": username,
+                    "password": hashed_password
+                }
                 
-                # If JSON parsing fails, try using the raw request
-                try:
-                    # Forward to the backend as a new request
-                    from starlette.requests import Request as StarletteRequest
-                    
-                    # Create a new scope
-                    scope = {
-                        "type": "http",
-                        "method": "POST",
-                        "path": "/signup",
-                        "headers": [[k.lower().encode(), v.encode()] for k, v in request.headers.items()],
-                    }
-                    
-                    # Create a new request with the same body
-                    new_req = StarletteRequest(scope=scope, receive=lambda: {"type": "http.request", "body": body_bytes})
-                    
-                    # Call backend signup function
-                    from backend.app.main import signup
-                    result = await signup(new_req)
-                    return result
-                except Exception as raw_error:
-                    logger.error(f"Error forwarding raw request to signup: {str(raw_error)}")
-                    raise HTTPException(status_code=500, detail=f"Signup processing error: {str(raw_error)}")
+                await users.insert_one(new_user)
+                
+                return JSONResponse(
+                    content={"message": "User created successfully"},
+                    status_code=201
+                )
+            except Exception as db_error:
+                logger.error(f"Database error in signup: {str(db_error)}")
+                return JSONResponse(
+                    content={"error": "Database error", "message": str(db_error)},
+                    status_code=500
+                )
         except Exception as e:
             logger.error(f"General error in signup_proxy: {str(e)}")
             return JSONResponse(
@@ -361,45 +391,69 @@ async def token_proxy(request: Request):
     logger.info("Received token request at /token endpoint")
     if backend_available:
         try:
-            # Read request body as bytes
-            body_bytes = await request.body()
-            
-            # Try to get form data
+            # Get form data from the request
             try:
                 form_data = await request.form()
+                username = form_data.get("username")
+                password = form_data.get("password")
                 
-                # Import the token handler
-                from backend.app.main import login_for_access_token
+                if not username or not password:
+                    logger.error("Missing username or password in token request")
+                    return JSONResponse(
+                        content={"error": "Missing username or password"},
+                        status_code=400
+                    )
                 
-                # Call the backend function
-                result = await login_for_access_token(form_data)
-                return result
-            except Exception as form_error:
-                logger.error(f"Error processing form data in token request: {str(form_error)}")
+                # Import database connection and utility functions
+                try:
+                    from backend.app.main import users, verify_password, create_access_token
+                    from datetime import timedelta
+                except ImportError as e:
+                    logger.error(f"Error importing backend modules: {str(e)}")
+                    return JSONResponse(
+                        content={"error": "Backend configuration error"},
+                        status_code=500
+                    )
                 
-                # If form parsing fails, try forwarding the raw request
+                # Try to find the user in the database
                 try:
-                    # Forward to the backend as a new request
-                    from starlette.requests import Request as StarletteRequest
+                    user = await users.find_one({"username": username})
+                    if not user:
+                        logger.warning(f"User not found: {username}")
+                        return JSONResponse(
+                            content={"error": "Invalid username or password"},
+                            status_code=401
+                        )
                     
-                    # Create a new scope
-                    scope = {
-                        "type": "http",
-                        "method": "POST",
-                        "path": "/token",
-                        "headers": [[k.lower().encode(), v.encode()] for k, v in request.headers.items()],
-                    }
+                    # Verify password
+                    if not verify_password(password, user["password"]):
+                        logger.warning(f"Invalid password for user: {username}")
+                        return JSONResponse(
+                            content={"error": "Invalid username or password"},
+                            status_code=401
+                        )
                     
-                    # Create a new request with the same body
-                    new_req = StarletteRequest(scope=scope, receive=lambda: {"type": "http.request", "body": body_bytes})
+                    # Create access token
+                    access_token = create_access_token(
+                        data={"sub": username}
+                    )
                     
-                    # Call backend token function
-                    from backend.app.main import login_for_access_token
-                    result = await login_for_access_token(new_req)
-                    return result
-                except Exception as raw_error:
-                    logger.error(f"Error forwarding raw request to token: {str(raw_error)}")
-                    raise HTTPException(status_code=500, detail=f"Token processing error: {str(raw_error)}")
+                    return JSONResponse(
+                        content={"access_token": access_token, "token_type": "bearer"},
+                        status_code=200
+                    )
+                except Exception as db_error:
+                    logger.error(f"Database error in token request: {str(db_error)}")
+                    return JSONResponse(
+                        content={"error": "Database error", "message": str(db_error)},
+                        status_code=500
+                    )
+            except Exception as form_error:
+                logger.error(f"Error processing form data in token request: {str(form_error)}")
+                return JSONResponse(
+                    content={"error": "Invalid form data", "message": str(form_error)},
+                    status_code=400
+                )
         except Exception as e:
             logger.error(f"General error in token_proxy: {str(e)}")
             return JSONResponse(