feat: Implement uniform error handling and dynamic versioning

.github/workflows/ci.yml

@@ -31,4 +31,4 @@ jobs:
           DATABASE_URL: postgresql://postgres:postgres@localhost:5432/fluentmeet_test
           REDIS_URL: redis://localhost:6379/1
         run: |
-          pytest --cov=app --cov-fail-under=5 tests/
+          pytest --cov=app --cov-fail-under=60 tests/

app/core/config.py

@@ -1,9 +1,25 @@
+import pathlib
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
+def get_version() -> str:
+    pyproject_path = pathlib.Path(__file__).parent.parent.parent / "pyproject.toml"
+    if pyproject_path.exists():
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+            return str(data.get("project", {}).get("version", "1.0.0"))
+    return "1.0.0"
+
+
 class Settings(BaseSettings):
     PROJECT_NAME: str = "FluentMeet"
-    VERSION: str = "1.0.0"
+    VERSION: str = get_version()
     API_V1_STR: str = "/api/v1"
 
     # Security
@@ -31,7 +47,9 @@ class Settings(BaseSettings):
     VOICE_AI_API_KEY: str | None = None
     OPENAI_API_KEY: str | None = None
 
-    model_config = SettingsConfigDict(env_file=".env", case_sensitive=True)
+    model_config = SettingsConfigDict(
+        env_file=".env", case_sensitive=True, extra="ignore"
+    )
 
 
 settings = Settings()

app/core/error_responses.py

@@ -0,0 +1,50 @@
+from typing import Any
+
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+
+class ErrorDetail(BaseModel):
+    field: str | None = None
+    message: str
+
+
+class ErrorResponse(BaseModel):
+    status: str = "error"
+    code: str
+    message: str
+    details: list[ErrorDetail] = []
+
+
+def create_error_response(
+    status_code: int,
+    code: str,
+    message: str,
+    details: list[dict[str, Any]] | None = None,
+) -> JSONResponse:
+    """
+    Helper to create a standardized JSON error response.
+    """
+    error_details = []
+    if details:
+        for detail in details:
+            error_details.append(
+                ErrorDetail(
+                    field=detail.get("field"),
+                    message=detail.get("msg")
+                    or detail.get("message")
+                    or "Unknown error",
+                )
+            )
+
+    response_content = ErrorResponse(
+        status="error",
+        code=code,
+        message=message,
+        details=error_details,
+    )
+
+    return JSONResponse(
+        status_code=status_code,
+        content=response_content.model_dump(),
+    )

app/core/exception_handlers.py

@@ -0,0 +1,76 @@
+import logging
+
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from app.core.error_responses import create_error_response
+from app.core.exceptions import FluentMeetException
+
+logger = logging.getLogger(__name__)
+
+
+async def fluentmeet_exception_handler(request: Request, exc: FluentMeetException):
+    """
+    Handler for all custom FluentMeetException exceptions.
+    """
+    return create_error_response(
+        status_code=exc.status_code,
+        code=exc.code,
+        message=exc.message,
+        details=exc.details,
+    )
+
+
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """
+    Handler for Pydantic validation errors (422 -> 400).
+    """
+    details = []
+    for error in exc.errors():
+        details.append(
+            {
+                "field": ".".join(str(loc) for loc in error["loc"]),
+                "msg": error["msg"],
+            }
+        )
+
+    return create_error_response(
+        status_code=400,
+        code="VALIDATION_ERROR",
+        message="Request validation failed",
+        details=details,
+    )
+
+
+async def http_exception_handler(request: Request, exc: StarletteHTTPException):
+    """
+    Handler for Starlette/FastAPI HTTP exceptions.
+    """
+    return create_error_response(
+        status_code=exc.status_code,
+        code=getattr(exc, "code", "HTTP_ERROR"),
+        message=exc.detail,
+    )
+
+
+async def unhandled_exception_handler(request: Request, exc: Exception):
+    """
+    Handler for all other unhandled exceptions (500).
+    """
+    logger.exception("Unhandled exception occurred: %s", str(exc))
+    return create_error_response(
+        status_code=500,
+        code="INTERNAL_SERVER_ERROR",
+        message="An unexpected server error occurred",
+    )
+
+
+def register_exception_handlers(app: FastAPI) -> None:
+    """
+    Register all custom exception handlers to the FastAPI app.
+    """
+    app.add_exception_handler(FluentMeetException, fluentmeet_exception_handler)
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+    app.add_exception_handler(StarletteHTTPException, http_exception_handler)
+    app.add_exception_handler(Exception, unhandled_exception_handler)

app/core/exceptions.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+
+class FluentMeetException(Exception):
+    """
+    Base exception for all FluentMeet API errors.
+    """
+
+    def __init__(
+        self,
+        status_code: int = 500,
+        code: str = "INTERNAL_SERVER_ERROR",
+        message: str = "An unexpected error occurred",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        self.details = details or []
+        super().__init__(self.message)
+
+
+class BadRequestException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Bad Request",
+        code: str = "BAD_REQUEST",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(400, code, message, details)
+
+
+class UnauthorizedException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Unauthorized",
+        code: str = "UNAUTHORIZED",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(401, code, message, details)
+
+
+class ForbiddenException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Forbidden",
+        code: str = "FORBIDDEN",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(403, code, message, details)
+
+
+class NotFoundException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Not Found",
+        code: str = "NOT_FOUND",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(404, code, message, details)
+
+
+class ConflictException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Conflict",
+        code: str = "CONFLICT",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(409, code, message, details)
+
+
+class InternalServerException(FluentMeetException):
+    def __init__(
+        self,
+        message: str = "Internal Server Error",
+        code: str = "INTERNAL_SERVER_ERROR",
+        details: list[dict[str, Any]] | None = None,
+    ) -> None:
+        super().__init__(500, code, message, details)

app/main.py

@@ -1,10 +1,13 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
+from app.core.config import settings
+from app.core.exception_handlers import register_exception_handlers
+
 app = FastAPI(
-    title="FluentMeet API",
+    title=settings.PROJECT_NAME,
     description="Real-time voice translation video conferencing platform API",
-    version="1.1.0",
+    version=settings.VERSION,
 )
 
 # Set all CORS enabled origins
@@ -16,10 +19,12 @@
     allow_headers=["*"],
 )
 
+register_exception_handlers(app)
+
 
 @app.get("/health", tags=["health"])
 async def health_check() -> dict[str, str]:
-    return {"status": "ok", "version": "1.1.0"}
+    return {"status": "ok", "version": settings.VERSION}
 
 
 if __name__ == "__main__":