| """FastAPI application factory. |
| |
| No CORS middleware is registered: same-origin only by default (FR-016). |
| All error responses use the contract's error envelope (contracts/api.md). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import asyncio |
| import os |
| from contextlib import asynccontextmanager, suppress |
| from pathlib import Path |
|
|
| from fastapi import FastAPI, Request |
| from fastapi.exceptions import RequestValidationError |
| from fastapi.responses import JSONResponse |
| from starlette.exceptions import HTTPException as StarletteHTTPException |
|
|
| from cadmorph.api.routes import max_upload_bytes, router |
| from cadmorph.observability import configure_logging |
| from cadmorph.pipeline import JobStore, cleanup_loop |
|
|
|
|
| def error_envelope(code: str, message: str, comparison_id: str | None = None) -> dict: |
| error: dict = {"code": code, "message": message} |
| if comparison_id is not None: |
| error["comparison_id"] = comparison_id |
| return {"error": error} |
|
|
|
|
| def create_app(data_dir: str | Path | None = None) -> FastAPI: |
| configure_logging() |
|
|
| @asynccontextmanager |
| async def lifespan(app: FastAPI): |
| |
| interval = float(os.environ.get("CADMORPH_CLEANUP_INTERVAL_S", "3600")) |
| sweeper = asyncio.create_task(cleanup_loop(app.state.store, interval)) |
| try: |
| yield |
| finally: |
| sweeper.cancel() |
| with suppress(asyncio.CancelledError): |
| await sweeper |
|
|
| app = FastAPI(title="CADMorph", version="0.1.0", lifespan=lifespan) |
| app.state.store = JobStore(data_dir or os.environ.get("CADMORPH_DATA_DIR", "data")) |
| app.include_router(router, prefix="/api/v1") |
|
|
| @app.middleware("http") |
| async def upload_size_guard(request: Request, call_next): |
| """Fast-fail oversized uploads on declared Content-Length before the |
| body is buffered (T046). The per-file check in routes still guards |
| undeclared-length bodies.""" |
| declared = request.headers.get("content-length", "") |
| cap = 2 * max_upload_bytes() + 1_048_576 |
| if request.method == "POST" and declared.isdigit() and int(declared) > cap: |
| return JSONResponse( |
| status_code=413, |
| content=error_envelope( |
| "file_too_large", |
| f"request body exceeds {cap // 1_048_576} MiB " |
| f"(per-file limit {max_upload_bytes() // 1_048_576} MiB)", |
| ), |
| ) |
| return await call_next(request) |
|
|
| @app.exception_handler(RequestValidationError) |
| async def validation_handler(_: Request, exc: RequestValidationError) -> JSONResponse: |
| detail = str(exc.errors()[:1]) |
| return JSONResponse(status_code=400, content=error_envelope("missing_file", detail)) |
|
|
| @app.exception_handler(StarletteHTTPException) |
| async def http_exception_handler(_: Request, exc: StarletteHTTPException) -> JSONResponse: |
| """Route/method misses etc. must use the contract envelope too |
| (contracts/api.md: error envelope on ALL non-2xx).""" |
| code = {404: "not_found", 405: "method_not_allowed"}.get(exc.status_code, "error") |
| return JSONResponse( |
| status_code=exc.status_code, content=error_envelope(code, str(exc.detail)) |
| ) |
|
|
| @app.exception_handler(Exception) |
| async def internal_handler(_: Request, exc: Exception) -> JSONResponse: |
| return JSONResponse(status_code=500, content=error_envelope("internal", "internal error")) |
|
|
| return app |
|
|
|
|
| app = create_app() |
|
|
