graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/presentation/api/rest/exception_handlers.py

@@ -0,0 +1,174 @@
+"""
+FastAPI Exception Handlers (Task 9.3)
+
+Global exception handlers for the REST API.
+"""
+from fastapi import Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+import structlog
+
+from src.application.exceptions import (
+    ApplicationException,
+    EmptyRepositoryListError,
+    NoValidRepositoriesError,
+    RepositoryNotFoundError
+)
+from src.infrastructure.exceptions import (
+    InfrastructureException,
+    OpenAIAPIError,
+    QdrantConnectionError,
+    Neo4jConnectionError
+)
+from src.domain.exceptions import DomainException
+
+logger = structlog.get_logger(__name__)
+
+
+async def application_exception_handler(
+    request: Request,
+    exc: ApplicationException
+) -> JSONResponse:
+    """
+    Handle application layer exceptions.
+
+    Returns HTTP 400 for user errors.
+    """
+    logger.warning(
+        "application_error",
+        error_type=type(exc).__name__,
+        message=exc.message,
+        details=exc.details,
+        path=request.url.path
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={
+            "error": type(exc).__name__,
+            "message": exc.message,
+            "details": exc.details
+        }
+    )
+
+
+async def infrastructure_exception_handler(
+    request: Request,
+    exc: InfrastructureException
+) -> JSONResponse:
+    """
+    Handle infrastructure layer exceptions.
+
+    Returns HTTP 500 for system errors.
+    Logs full details but returns generic message to client.
+    """
+    logger.error(
+        "infrastructure_error",
+        error_type=type(exc).__name__,
+        message=exc.message,
+        details=exc.details,
+        path=request.url.path,
+        exc_info=True
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": "InternalServerError",
+            "message": "An internal error occurred. Please try again later."
+        }
+    )
+
+
+async def domain_exception_handler(
+    request: Request,
+    exc: DomainException
+) -> JSONResponse:
+    """
+    Handle domain layer exceptions.
+
+    Returns HTTP 400 for domain rule violations.
+    """
+    logger.warning(
+        "domain_error",
+        error_type=type(exc).__name__,
+        message=exc.message,
+        details=exc.details,
+        path=request.url.path
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content={
+            "error": type(exc).__name__,
+            "message": exc.message,
+            "details": exc.details
+        }
+    )
+
+
+async def validation_exception_handler(
+    request: Request,
+    exc: RequestValidationError
+) -> JSONResponse:
+    """
+    Handle Pydantic validation errors.
+
+    Returns HTTP 422 for validation failures.
+    """
+    logger.warning(
+        "validation_error",
+        errors=exc.errors(),
+        body=exc.body,
+        path=request.url.path
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={
+            "error": "ValidationError",
+            "message": "Request validation failed",
+            "details": exc.errors()
+        }
+    )
+
+
+async def unhandled_exception_handler(
+    request: Request,
+    exc: Exception
+) -> JSONResponse:
+    """
+    Handle any unhandled exceptions.
+
+    Returns HTTP 500 with generic message.
+    Logs full stack trace.
+    """
+    logger.error(
+        "unhandled_error",
+        error_type=type(exc).__name__,
+        message=str(exc),
+        path=request.url.path,
+        exc_info=True
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": "InternalServerError",
+            "message": "An unexpected error occurred. Please contact support."
+        }
+    )
+
+
+def register_exception_handlers(app):
+    """
+    Register all exception handlers with FastAPI app.
+
+    Args:
+        app: FastAPI application instance
+    """
+    app.add_exception_handler(ApplicationException, application_exception_handler)
+    app.add_exception_handler(InfrastructureException, infrastructure_exception_handler)
+    app.add_exception_handler(DomainException, domain_exception_handler)
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+    app.add_exception_handler(Exception, unhandled_exception_handler)

src/presentation/api/rest/main.py

@@ -0,0 +1,80 @@
+"""
+FastAPI Application (Task 9.2)
+
+Main FastAPI application with all routers and middleware.
+"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import structlog
+
+from src.config.container import get_container
+from src.presentation.api.rest.routers import health, indexing, analysis, admin, export, relationships
+from src.presentation.api.rest.exception_handlers import register_exception_handlers
+
+logger = structlog.get_logger(__name__)
+
+
+def create_app() -> FastAPI:
+    """
+    Create and configure FastAPI application.
+
+    Returns:
+        Configured FastAPI instance with all routers and middleware
+    """
+    app = FastAPI(
+        title="Knowledge Graph Indexing API",
+        description="API for indexing Java repositories and performing impact analysis",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc"
+    )
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Configure appropriately for production
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Configure dependency injection
+    container = get_container()
+    container.wire(modules=[
+        "src.presentation.api.rest.routers.indexing",
+        "src.presentation.api.rest.routers.analysis",
+        "src.presentation.api.rest.routers.admin",
+        "src.presentation.api.rest.routers.export",
+        "src.presentation.api.rest.routers.relationships",
+    ])
+
+    # Register exception handlers
+    register_exception_handlers(app)
+
+    # Register routers
+    app.include_router(health.router)
+    app.include_router(indexing.router)
+    app.include_router(analysis.router)
+    app.include_router(admin.router)
+    app.include_router(export.router)
+    app.include_router(relationships.router)
+
+    logger.info("fastapi_application_created", container_wired=True)
+
+    return app
+
+
+# Create application instance
+app = create_app()
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Application startup event handler."""
+    logger.info("application_starting")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Application shutdown event handler."""
+    logger.info("application_shutting_down")

src/presentation/api/rest/routers/__init__.py

@@ -0,0 +1,5 @@
+"""
+REST API Routers Module.
+
+Contains all FastAPI router implementations.
+"""

src/presentation/api/rest/routers/admin.py

@@ -0,0 +1,103 @@
+"""
+Admin Router
+
+REST API endpoints for administrative operations.
+
+⚠️ WARNING: These endpoints perform DESTRUCTIVE operations!
+Use with caution in production environments.
+"""
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+import structlog
+
+from dependency_injector.wiring import inject, Provide
+
+from src.application.use_cases.clear_all_data_use_case import ClearAllDataUseCase
+from src.config.container import Container
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+
+
+class ClearAllResponse(BaseModel):
+    """Response model for clear all operation."""
+    message: str
+    neo4j: dict
+    qdrant: dict
+
+
+@router.delete(
+    "/clear-all",
+    response_model=ClearAllResponse,
+    status_code=status.HTTP_200_OK,
+    responses={
+        200: {"description": "All data cleared successfully"},
+        500: {"description": "Internal server error"}
+    }
+)
+@inject
+async def clear_all_data(
+    use_case: ClearAllDataUseCase = Depends(Provide[Container.clear_all_data_use_case])
+) -> ClearAllResponse:
+    """
+    Clear all data from Qdrant and Neo4j.
+
+    ⚠️ **DESTRUCTIVE OPERATION** - Deletes:
+    - All nodes and relationships in Neo4j
+    - All vectors in Qdrant collection
+
+    This operation is **irreversible**. All indexed repositories will be lost.
+
+    Use case:
+    - Clean environment before re-indexing
+    - Reset system to initial state
+    - Testing and development
+
+    Returns:
+        ClearAllResponse with deletion metrics
+
+    Raises:
+        HTTP 500: Internal error during deletion
+    """
+    logger.warning("clear_all_requested", operation="DESTRUCTIVE")
+
+    try:
+        results = await use_case.execute()
+
+        # Check if both operations succeeded
+        neo4j_success = results["neo4j"]["success"]
+        qdrant_success = results["qdrant"]["success"]
+
+        if neo4j_success and qdrant_success:
+            message = "All data cleared successfully"
+        elif neo4j_success:
+            message = "Neo4j cleared, but Qdrant failed"
+        elif qdrant_success:
+            message = "Qdrant cleared, but Neo4j failed"
+        else:
+            message = "Both operations failed"
+
+        logger.warning(
+            "clear_all_completed",
+            message=message,
+            neo4j_success=neo4j_success,
+            qdrant_success=qdrant_success
+        )
+
+        return ClearAllResponse(
+            message=message,
+            neo4j=results["neo4j"],
+            qdrant=results["qdrant"]
+        )
+
+    except Exception as e:
+        logger.error(
+            "clear_all_failed",
+            error=str(e),
+            error_type=type(e).__name__
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to clear data: {str(e)}"
+        )