fix : add centralized error handling and strong input validation

backend/app/routes/routes.py

@@ -29,9 +29,9 @@
     - ask_llm: Generates a natural language answer using retrieved context.
 """
 
-
-from fastapi import APIRouter
-from pydantic import BaseModel
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, HttpUrl, Field, validator
 from app.modules.pipeline import run_scraper_pipeline
 from app.modules.pipeline import run_langgraph_workflow
 from app.modules.bias_detection.check_bias import check_bias
@@ -46,12 +46,17 @@
 router = APIRouter()
 
 
-class URlRequest(BaseModel):
-    url: str
-
+class URLRequest(BaseModel):
+    url: HttpUrl  # Validates URL format automatically, returns 422 for invalid URLs
 
 class ChatQuery(BaseModel):
-    message: str
+    message: str = Field(..., min_length=1, strip_whitespace=True)  # Rejects empty/whitespace
+
+    @validator('message')
+    def message_must_not_be_blank(cls, v):
+        if not v.strip():
+            raise ValueError('Message cannot be empty or whitespace')
+        return v
 
 
 @router.get("/")
@@ -60,26 +65,41 @@ async def home():
 
 
 @router.post("/bias")
-async def bias_detection(request: URlRequest):
-    content = await asyncio.to_thread(run_scraper_pipeline, (request.url))
-    bias_score = await asyncio.to_thread(check_bias, (content))
-    logger.info(f"Bias detection result: {bias_score}")
-    return bias_score
+async def bias_detection(request: URLRequest):
+    try:
+        content = await asyncio.to_thread(run_scraper_pipeline, (str(request.url)))
+        bias_score = await asyncio.to_thread(check_bias, (content))
+        logger.info(f"Bias detection result: {bias_score}")
+        return bias_score
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception:
+        raise  # Let global handler in main.py catch it with trace_id
 
 
 @router.post("/process")
-async def run_pipelines(request: URlRequest):
-    article_text = await asyncio.to_thread(run_scraper_pipeline, (request.url))
-    logger.debug(f"Scraper output: {json.dumps(article_text, indent=2, ensure_ascii=False)}")
-    data = await asyncio.to_thread(run_langgraph_workflow, (article_text))
-    return data
+async def run_pipelines(request: URLRequest):
+    try:
+        article_text = await asyncio.to_thread(run_scraper_pipeline, (str(request.url)))
+        logger.debug(f"Scraper output: {json.dumps(article_text, indent=2, ensure_ascii=False)}")
+        data = await asyncio.to_thread(run_langgraph_workflow, (article_text))
+        return data
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception:
+        raise  # Let global handler in main.py catch it with trace_id
 
 
 @router.post("/chat")
 async def answer_query(request: ChatQuery):
-    query = request.message
-    results = search_pinecone(query)
-    answer = ask_llm(query, results)
-    logger.info(f"Chat answer generated: {answer}")
-
-    return {"answer": answer}
+    try:
+        query = request.message
+        results = search_pinecone(query)
+        answer = ask_llm(query, results)
+        logger.info(f"Chat answer generated: {answer}")
+        return {"answer": answer}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception:
+        raise
+

backend/main.py

@@ -19,34 +19,52 @@
     app (FastAPI): The FastAPI application instance.
 """
 
-from fastapi import FastAPI
-from app.routes.routes import router as article_router
-from fastapi.middleware.cors import CORSMiddleware
-from app.logging.logging_config import setup_logger
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+import logging
+import uuid
+
+app = FastAPI()
+
+logger = logging.getLogger(__name__)
+
+# Handle HTTPExceptions (400, 404, etc.)
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={
+            "error": exc.detail,
+            "code": f"HTTP_{exc.status_code}"
+        }
+    )
+
+# Handle ALL unhandled exceptions (500s)
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    trace_id = str(uuid.uuid4())  # Unique ID for debugging
+    logger.error(f"[{trace_id}] Unhandled exception: {exc}", exc_info=True)
 
-# Setup logger for this module
-logger = setup_logger(__name__)
-
-app = FastAPI(
-    title="Perspective API",
-    version="1.0.0",
-    description=("An API to generate alternative perspectives on biased articles"),
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(article_router, prefix="/api", tags=["Articles"])
-
-if __name__ == "__main__":
-    import uvicorn
-    import os
-
-    port = int(os.environ.get("PORT", 7860))
-    logger.info(f" Server is running on http://localhost:{port}")
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "An internal server error occurred",
+            "code": "INTERNAL_SERVER_ERROR",
+            "trace_id": trace_id  # Return to frontend for easier debugging
+        }
+    )
+
+from fastapi.exceptions import RequestValidationError
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    errors = exc.errors()
+    return JSONResponse(
+        status_code=400,
+        content={
+            "error": errors[0]['msg'] if errors else "Invalid input",
+            "code": "VALIDATION_ERROR",
+            "details": errors
+        }
+    )