300 lines
11 KiB
Python
300 lines
11 KiB
Python
import datetime
|
|
import os
|
|
from typing import Annotated, Dict, List, Optional, Any
|
|
from contextlib import asynccontextmanager
|
|
|
|
import aiosqlite
|
|
from fastapi import Depends, FastAPI, APIRouter, Request, Response
|
|
from fastapi.encoders import jsonable_encoder
|
|
from fastapi.responses import JSONResponse
|
|
from pydantic import Field
|
|
|
|
import db
|
|
import products
|
|
|
|
from fastapi.routing import APIRoute
|
|
from common import ProblemDetails, Page, ApiModel
|
|
from settings import settings
|
|
from api.deps import get_db, cookie_person, error_response
|
|
|
|
|
|
class CamelCaseRoute(APIRoute):
|
|
def __init__(self, *args, **kwargs):
|
|
kwargs.setdefault("response_model_by_alias", True)
|
|
kwargs.setdefault("response_model_exclude_none", True)
|
|
super().__init__(*args, **kwargs)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def app_lifespan(app: FastAPI):
|
|
client = None
|
|
if not settings.prod:
|
|
import httpx
|
|
|
|
client = httpx.AsyncClient(base_url=settings.frontend_dev_url)
|
|
app.state.proxy_client = client
|
|
try:
|
|
yield
|
|
finally:
|
|
if client is not None:
|
|
await client.aclose()
|
|
|
|
|
|
app = FastAPI(title="Doof API", version="1.0.0", description="Doof Backend API", lifespan=app_lifespan)
|
|
api_v1 = APIRouter(route_class=CamelCaseRoute)
|
|
DATABASE_PATH = settings.database_path
|
|
|
|
# get_db, cookie_person, and error_response are imported from api.deps
|
|
|
|
|
|
# OpenAPI reusable responses for ProblemDetails
|
|
def _extend_openapi_with_problem_responses(app: FastAPI) -> None:
|
|
# Attach a custom openapi generation that injects reusable responses
|
|
original_openapi = app.openapi
|
|
|
|
def custom_openapi():
|
|
spec = original_openapi()
|
|
components = spec.setdefault("components", {})
|
|
responses = components.setdefault("responses", {})
|
|
security_schemes = components.setdefault("securitySchemes", {})
|
|
# Standard ProblemDetails responses
|
|
responses.setdefault(
|
|
"Problem400",
|
|
{
|
|
"description": "Bad Request",
|
|
"content": {
|
|
"application/problem+json": {},
|
|
"application/json": {"schema": {"$ref": "#/components/schemas/ProblemDetails"}},
|
|
},
|
|
},
|
|
)
|
|
responses.setdefault(
|
|
"Problem404",
|
|
{
|
|
"description": "Not Found",
|
|
"content": {
|
|
"application/problem+json": {},
|
|
"application/json": {"schema": {"$ref": "#/components/schemas/ProblemDetails"}},
|
|
},
|
|
},
|
|
)
|
|
responses.setdefault(
|
|
"Problem422",
|
|
{
|
|
"description": "Validation Error",
|
|
"content": {
|
|
"application/problem+json": {
|
|
"schema": {"$ref": "#/components/schemas/ProblemDetails"}
|
|
},
|
|
# Some clients may still expect FastAPI's default error; keep schema available
|
|
"application/json": {
|
|
"schema": {"$ref": "#/components/schemas/ProblemDetails"}
|
|
},
|
|
},
|
|
},
|
|
)
|
|
# Define cookie-based auth for documentation (does not enforce at runtime)
|
|
security_schemes.setdefault(
|
|
"cookieAuth",
|
|
{
|
|
"type": "apiKey",
|
|
"in": "cookie",
|
|
"name": "user_id",
|
|
"description": "Authentication via user_id cookie (session-style).",
|
|
},
|
|
)
|
|
|
|
# Normalize v1 responses to reference reusable ProblemDetails where appropriate
|
|
paths = spec.get("paths", {})
|
|
# Known operationIds that require cookie_person dependency
|
|
protected_ops: set[str] = {
|
|
# recipes
|
|
"parseRecipe", # GET /recipes/parse
|
|
"createRecipe", # POST /recipes
|
|
"deleteRecipe", # DELETE /recipes/{recipe_id}
|
|
# meals
|
|
"markMealConsumed", # POST /meals/{meal_id}/consumed
|
|
"deleteMeal", # DELETE /meals/{meal_id}
|
|
# shopping
|
|
"purchaseIngredients", # POST /shopping
|
|
"getMyShoppingList", # GET /shopping/current/me/ingredients
|
|
"syncMyShoppingList", # POST /shopping/current/me/ingredients
|
|
"requestMeal", # POST /shopping/current/meals/me
|
|
"unrequestMeal", # DELETE /shopping/current/meals/{meal_id}
|
|
# auth
|
|
"refresh",
|
|
}
|
|
for path, ops in paths.items():
|
|
if not isinstance(path, str) or not path.startswith("/api/v1/"):
|
|
continue
|
|
if not isinstance(ops, dict):
|
|
continue
|
|
for method, op in ops.items():
|
|
if not isinstance(op, dict):
|
|
continue
|
|
# Add ProblemDetails response references and cookie security if required
|
|
resp = op.get("responses")
|
|
if not isinstance(resp, dict):
|
|
continue
|
|
# Map 400/404 to reusable references; ensure 422 exists
|
|
if "400" in resp:
|
|
resp["400"] = {"$ref": "#/components/responses/Problem400"}
|
|
if "404" in resp:
|
|
resp["404"] = {"$ref": "#/components/responses/Problem404"}
|
|
# Only add 422 if not already present
|
|
if "422" not in resp:
|
|
resp["422"] = {"$ref": "#/components/responses/Problem422"}
|
|
|
|
op_id = op.get("operationId")
|
|
if isinstance(op_id, str) and op_id in protected_ops:
|
|
# Merge/append cookieAuth security requirement
|
|
security = op.setdefault("security", [])
|
|
# Avoid duplicating if already present
|
|
if not any(isinstance(s, dict) and "cookieAuth" in s for s in security):
|
|
security.append({"cookieAuth": []})
|
|
return spec
|
|
|
|
app.openapi = custom_openapi # type: ignore[assignment]
|
|
|
|
|
|
_extend_openapi_with_problem_responses(app)
|
|
|
|
|
|
class ProductUrl(ApiModel):
|
|
url: str
|
|
tags: List[str] = Field(default_factory=list)
|
|
|
|
|
|
@api_v1.post(
|
|
"/products",
|
|
operation_id="createProduct",
|
|
tags=["products"],
|
|
summary="Create or fetch a product from a URL",
|
|
response_model=products.Product,
|
|
)
|
|
async def create_product(
|
|
url: ProductUrl, response: Response, conn: aiosqlite.Connection = Depends(get_db)
|
|
) -> Optional[products.Product]:
|
|
product = await products.get_or_create(conn, url.url, url.tags)
|
|
if product:
|
|
response.headers["Location"] = f"/api/v1/products/{product.id}"
|
|
return product
|
|
|
|
|
|
|
|
|
|
|
|
from api import recipes as recipes_router # type: ignore
|
|
|
|
|
|
from api import meals as meals_router # type: ignore
|
|
from api.meals import validate_meal as _validate_meal, get_duplicates as _get_duplicates
|
|
from api import shopping as shopping_router # type: ignore
|
|
from api import persons as persons_router # type: ignore
|
|
from api import auth as auth_router # type: ignore
|
|
|
|
# RFC7807 Problem Details handlers
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
from pydantic import ValidationError
|
|
from fastapi.exceptions import RequestValidationError
|
|
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
async def http_exc_handler(request: Request, exc: StarletteHTTPException):
|
|
body = ProblemDetails(
|
|
title=str(exc.detail) if exc.detail else "HTTP Error",
|
|
status=exc.status_code,
|
|
type=f"https://httpstatuses.com/{exc.status_code}",
|
|
instance=str(request.url),
|
|
)
|
|
return JSONResponse(
|
|
content=body.model_dump(by_alias=True),
|
|
status_code=exc.status_code,
|
|
media_type="application/problem+json",
|
|
)
|
|
|
|
|
|
@app.exception_handler(ValidationError)
|
|
async def validation_exc_handler(request: Request, exc: ValidationError):
|
|
errors: Dict[str, Any] = {}
|
|
for e in exc.errors():
|
|
loc = ".".join([str(p) for p in e.get("loc", [])])
|
|
errors.setdefault(loc, []).append(e.get("msg"))
|
|
body = ProblemDetails(
|
|
title="Validation Error",
|
|
status=422,
|
|
type="https://datatracker.ietf.org/doc/html/rfc7807",
|
|
instance=str(request.url),
|
|
errors=errors,
|
|
)
|
|
return JSONResponse(
|
|
content=body.model_dump(by_alias=True), status_code=422, media_type="application/problem+json"
|
|
)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def request_validation_exc_handler(request: Request, exc: RequestValidationError):
|
|
errors: Dict[str, Any] = {}
|
|
for e in exc.errors():
|
|
loc = ".".join([str(p) for p in e.get("loc", [])])
|
|
errors.setdefault(loc, []).append(e.get("msg"))
|
|
body = ProblemDetails(
|
|
title="Validation Error",
|
|
status=422,
|
|
type="https://datatracker.ietf.org/doc/html/rfc7807",
|
|
instance=str(request.url),
|
|
errors=errors,
|
|
)
|
|
return JSONResponse(
|
|
content=body.model_dump(by_alias=True), status_code=422, media_type="application/problem+json"
|
|
)
|
|
|
|
|
|
# Mount versioned API router
|
|
app.include_router(api_v1, prefix="/api/v1", tags=["v1"])
|
|
app.include_router(recipes_router.router, prefix="/api/v1", tags=["v1"]) # extracted
|
|
app.include_router(meals_router.router, prefix="/api/v1", tags=["v1"]) # extracted
|
|
app.include_router(shopping_router.router, prefix="/api/v1", tags=["v1"]) # extracted
|
|
app.include_router(persons_router.router, prefix="/api/v1", tags=["v1"]) # extracted
|
|
app.include_router(auth_router.router, prefix="/api/v1", tags=["v1"]) # extracted
|
|
|
|
|
|
@app.get("/healthz")
|
|
async def healthz():
|
|
return {"status": "ok"}
|
|
|
|
# Backward-compatibility: expose helper functions expected by tests in main
|
|
def get_duplicates(items):
|
|
return _get_duplicates(items)
|
|
|
|
|
|
def validate_meal(meal, request: Request | None = None):
|
|
return _validate_meal(meal, request)
|
|
|
|
|
|
if settings.prod:
|
|
from fastapi.staticfiles import StaticFiles
|
|
|
|
app.mount("/", StaticFiles(directory="./front-dist", html=True), name="front-dist")
|
|
else:
|
|
# Proxy the request to the frontend development server
|
|
from starlette.background import BackgroundTask
|
|
from starlette.requests import Request
|
|
from starlette.responses import StreamingResponse
|
|
|
|
async def _reverse_proxy(request: Request):
|
|
import httpx
|
|
url = httpx.URL(path=request.url.path, query=request.url.query.encode("utf-8"))
|
|
client = app.state.proxy_client
|
|
rp_req = client.build_request(
|
|
request.method, url, headers=request.headers.raw, content=request.stream()
|
|
)
|
|
rp_resp = await client.send(rp_req, stream=True)
|
|
return StreamingResponse(
|
|
rp_resp.aiter_raw(),
|
|
status_code=rp_resp.status_code,
|
|
headers=rp_resp.headers,
|
|
background=BackgroundTask(rp_resp.aclose),
|
|
)
|
|
|
|
app.add_route("/{path:path}", _reverse_proxy, ["GET", "POST"])
|