Spaces:

dataera2013
/

podcraft_web_app

Sleeping

App Files Files Community

Nagesh Muralidhar commited on Mar 20, 2025

Commit

f8108f2

1 Parent(s): e01254e

Fix API calls from frontend by adding URL rewriting and proxy endpoints

Browse files

Files changed (1) hide show

app.py +151 -28

app.py CHANGED Viewed

@@ -60,6 +60,15 @@ def get_index_html():
     else:
         return "<html><body><h1>Index file not found</h1></body></html>"
 # Create the main application
 app = FastAPI(title="PodCraft")
@@ -72,38 +81,20 @@ app.add_middleware(
     allow_headers=["*"],
 )
-# Try to load the backend app
-backend_app = None
-try:
-    # Import the backend app
-    from backend.app.main import app as backend_app
-    logger.info("Backend module imported successfully")
-    # Add all non-root routes from the backend app to our main app
-    from fastapi.routing import APIRoute, APIRouter
-    # Create a router for backend routes
-    backend_router = APIRouter()
-    # Add all routes from the backend app to our router
-    for route in backend_app.routes:
-        if not (isinstance(route, APIRoute) and route.path == "/"):
-            # Add this route to our router
-            logger.info(f"Adding backend route: {route.path}")
-            backend_router.routes.append(route)
-    # Include the backend router in our main app
-    app.include_router(backend_router)
-except Exception as e:
-    logger.error(f"Error importing backend module: {str(e)}")
-    backend_app = None
 # Define the root route that directly serves index.html
 @app.get("/", response_class=HTMLResponse)
 async def root():
     logger.info("Root route accessed, serving index.html")
-    return HTMLResponse(content=get_index_html())
 # API status endpoint
 @app.get("/api/status")
@@ -135,6 +126,130 @@ async def serve_assets(file_path: str):
     logger.info(f"Serving asset: {file_path} with content-type: {content_type}")
     return FileResponse(file_full_path, media_type=content_type)
 # Mount the static directory for other static files
 if static_path.exists():
     app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
@@ -142,6 +257,14 @@ if static_path.exists():
 # Catch-all route for client-side routing in the React app
 @app.get("/{full_path:path}")
 async def catch_all(full_path: str, request: Request):
     # Skip static file paths
     if full_path.startswith("static/") or full_path.startswith("assets/"):
         raise HTTPException(status_code=404, detail="Not found")

     else:
         return "<html><body><h1>Index file not found</h1></body></html>"
+try:
+    # Try to import the backend app but don't use it directly
+    import backend.app.main
+    logger.info("Backend module imported successfully")
+    backend_available = True
+except Exception as e:
+    logger.error(f"Error importing backend module: {str(e)}")
+    backend_available = False
 # Create the main application
 app = FastAPI(title="PodCraft")
     allow_headers=["*"],
 )
 # Define the root route that directly serves index.html
 @app.get("/", response_class=HTMLResponse)
 async def root():
     logger.info("Root route accessed, serving index.html")
+    html_content = get_index_html()
+    # Check if this is the React app by looking for specific markers
+    if "<div id=\"root\"></div>" in html_content:
+        logger.info("Detected React app, injecting URL fixer")
+        # Inject our URL fixer script before the closing body tag
+        script_tag = '<script src="/api/fix-client-urls"></script>'
+        html_content = html_content.replace('</body>', f'{script_tag}</body>')
+    return HTMLResponse(content=html_content)
 # API status endpoint
 @app.get("/api/status")
     logger.info(f"Serving asset: {file_path} with content-type: {content_type}")
     return FileResponse(file_full_path, media_type=content_type)
+# Special handlers for API routes that the React app calls directly
+@app.post("/login")
+async def login_proxy(request: Request):
+    logger.info("Received login request, proxying to backend")
+    if backend_available:
+        # Forward the request to the backend
+        try:
+            # Get the raw request body and headers
+            body = await request.body()
+            json_data = await request.json()
+            # Import the actual login route from backend
+            from backend.app.main import login
+            # Create a mock request with the same data
+            mock_request = Request(scope=request.scope)
+            setattr(mock_request, "_json", json_data)
+            # Call the backend login route directly
+            response = await login(mock_request)
+            return response
+        except Exception as e:
+            logger.error(f"Error proxying login request: {str(e)}")
+            return JSONResponse(
+                content={"error": "Login failed", "message": str(e)},
+                status_code=500
+            )
+    else:
+        return JSONResponse(
+            content={"error": "Backend API not available for login"},
+            status_code=503
+        )
+@app.post("/signup")
+async def signup_proxy(request: Request):
+    logger.info("Received signup request, proxying to backend")
+    if backend_available:
+        try:
+            # Get the JSON data from the request
+            json_data = await request.json()
+            # Import the actual signup route from backend
+            from backend.app.main import signup
+            # Call the backend signup route
+            response = await signup(json_data)
+            return response
+        except Exception as e:
+            logger.error(f"Error proxying signup request: {str(e)}")
+            return JSONResponse(
+                content={"error": "Signup failed", "message": str(e)},
+                status_code=500
+            )
+    else:
+        return JSONResponse(
+            content={"error": "Backend API not available for signup"},
+            status_code=503
+        )
+@app.post("/token")
+async def token_proxy(request: Request):
+    logger.info("Received token request, proxying to backend")
+    if backend_available:
+        try:
+            # Get form data from the request
+            form_data = await request.form()
+            # Import the actual token route from backend
+            from backend.app.main import login_for_access_token
+            # Call the backend token route
+            response = await login_for_access_token(form_data)
+            return response
+        except Exception as e:
+            logger.error(f"Error proxying token request: {str(e)}")
+            return JSONResponse(
+                content={"error": "Token request failed", "message": str(e)},
+                status_code=500
+            )
+    else:
+        return JSONResponse(
+            content={"error": "Backend API not available for token request"},
+            status_code=503
+        )
+# Post-fix: Add a helper function to fix the client-side JS
+@app.get("/api/fix-client-urls")
+async def fix_client_urls():
+    """
+    This endpoint returns JavaScript to inject into the page that rewrites
+    hardcoded localhost URLs to relative URLs
+    """
+    return HTMLResponse(content="""
+    <script>
+    (function() {
+        console.log("URL Fixer running...");
+        // Override fetch to rewrite localhost URLs
+        const originalFetch = window.fetch;
+        window.fetch = function(url, options) {
+            if (typeof url === 'string' && url.includes('localhost:8000')) {
+                const newUrl = url.replace('http://localhost:8000', '');
+                console.log(`Rewriting URL from ${url} to ${newUrl}`);
+                return originalFetch(newUrl, options);
+            }
+            return originalFetch(url, options);
+        };
+        // Override XMLHttpRequest to rewrite localhost URLs
+        const originalOpen = XMLHttpRequest.prototype.open;
+        XMLHttpRequest.prototype.open = function(method, url, ...args) {
+            if (typeof url === 'string' && url.includes('localhost:8000')) {
+                const newUrl = url.replace('http://localhost:8000', '');
+                console.log(`Rewriting XHR URL from ${url} to ${newUrl}`);
+                return originalOpen.call(this, method, newUrl, ...args);
+            }
+            return originalOpen.call(this, method, url, ...args);
+        };
+        console.log("URL Fixer installed");
+    })();
+    </script>
+    """)
 # Mount the static directory for other static files
 if static_path.exists():
     app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
 # Catch-all route for client-side routing in the React app
 @app.get("/{full_path:path}")
 async def catch_all(full_path: str, request: Request):
+    # Skip API paths and redirect them to the backend
+    if full_path.startswith("api/") or full_path == "docs" or full_path == "openapi.json":
+        if backend_available:
+            # Use the backend.app.main module's routes
+            return backend.app.main.app.get(full_path)
+        else:
+            return {"error": "Backend API not available"}
     # Skip static file paths
     if full_path.startswith("static/") or full_path.startswith("assets/"):
         raise HTTPException(status_code=404, detail="Not found")