svc-infra 0.1.562__py3-none-any.whl → 0.1.654__py3-none-any.whl

svc_infra/api/fastapi/docs/landing.py

@@ -115,7 +115,7 @@ def render_index_html(*, service_name: str, release: str, cards: Iterable[CardSp
     <section class="grid">
       {grid}
     </section>
-    <footer>Tip: each card exposes Swagger, ReDoc, and a pretty JSON view.</footer>
+    <footer>Tip: each card exposes Swagger, ReDoc, and a JSON view.</footer>
   </div>
 </body>
 </html>

svc_infra/api/fastapi/docs/scoped.py

@@ -65,11 +65,18 @@ def _close_over_component_refs(
 
 
 def _prune_to_paths(
-    full_schema: Dict, keep_paths: Dict[str, dict], title_suffix: Optional[str]
+    full_schema: Dict,
+    keep_paths: Dict[str, dict],
+    title_suffix: Optional[str],
+    server_prefix: Optional[str] = None,
 ) -> Dict:
     schema = copy.deepcopy(full_schema)
     schema["paths"] = keep_paths
 
+    # Set server URL for scoped docs
+    if server_prefix is not None:
+        schema["servers"] = [{"url": server_prefix}]
+
     used_tags: Set[str] = set()
     direct_refs: Set[Tuple[str, str]] = set()
     used_security_schemes: Set[str] = set()
@@ -124,7 +131,26 @@ def _build_filtered_schema(
     keep_paths = {
         p: v for p, v in paths.items() if _path_included(p, include_prefixes, exclude_prefixes)
     }
-    return _prune_to_paths(full_schema, keep_paths, title_suffix)
+
+    # Determine the server prefix for scoped docs
+    server_prefix = None
+    if include_prefixes and len(include_prefixes) == 1:
+        # Single include prefix = scoped docs
+        server_prefix = include_prefixes[0].rstrip("/") or "/"
+
+        # Strip prefix from paths to make them relative to the server
+        stripped_paths = {}
+        for path, spec in keep_paths.items():
+            if path.startswith(server_prefix) and path != server_prefix:
+                # Remove prefix, keeping the leading slash
+                relative_path = path[len(server_prefix) :]
+                stripped_paths[relative_path] = spec
+            else:
+                # Path equals prefix or doesn't start with it
+                stripped_paths[path] = spec
+        keep_paths = stripped_paths
+
+    return _prune_to_paths(full_schema, keep_paths, title_suffix, server_prefix=server_prefix)
 
 
 def _ensure_original_openapi_saved(app: FastAPI) -> None:
@@ -175,11 +201,23 @@ def add_prefixed_docs(
     auto_exclude_from_root: bool = True,
     visible_envs: Optional[Iterable[Environment | str]] = (LOCAL_ENV, DEV_ENV),
 ) -> None:
+    scope = prefix.rstrip("/") or "/"
+
+    # Always exclude from root if requested, regardless of environment
+    if auto_exclude_from_root:
+        _ensure_original_openapi_saved(app)
+        # Add to exclusion list for root docs
+        if not hasattr(app.state, "_scoped_root_exclusions"):
+            app.state._scoped_root_exclusions = []
+        if scope not in app.state._scoped_root_exclusions:
+            app.state._scoped_root_exclusions.append(scope)
+            _install_root_filter(app, app.state._scoped_root_exclusions)
+
+    # Only create scoped docs in allowed environments
     allow = _normalize_envs(visible_envs)
     if allow is not None and CURRENT_ENVIRONMENT not in allow:
         return
 
-    scope = prefix.rstrip("/") or "/"
     openapi_path = f"{scope}/openapi.json"
     swagger_path = f"{scope}/docs"
     redoc_path = f"{scope}/redoc"
@@ -211,9 +249,6 @@ def add_prefixed_docs(
 
     DOC_SCOPES.append((scope, swagger_path, redoc_path, openapi_path, title))
 
-    if auto_exclude_from_root:
-        _ensure_root_excludes_registered_scopes(app)
-
 
 def replace_root_openapi_with_exclusions(app: FastAPI, *, exclude_prefixes: List[str]) -> None:
     _install_root_filter(app, exclude_prefixes)

svc_infra/api/fastapi/middleware/errors/handlers.py

@@ -2,6 +2,7 @@ import logging
 import traceback
 from typing import Any, Dict, Optional
 
+import httpx
 from fastapi import Request
 from fastapi.exceptions import HTTPException, RequestValidationError
 from fastapi.responses import JSONResponse, Response
@@ -46,6 +47,7 @@ def problem_response(
     code: str | None = None,
     errors: list[dict] | None = None,
     trace_id: str | None = None,
+    headers: dict[str, str] | None = None,
 ) -> Response:
     body: Dict[str, Any] = {
         "type": type_uri,
@@ -62,10 +64,24 @@ def problem_response(
         body["errors"] = errors
     if trace_id:
         body["trace_id"] = trace_id
-    return JSONResponse(status_code=status, content=body, media_type=PROBLEM_MT)
+    return JSONResponse(status_code=status, content=body, media_type=PROBLEM_MT, headers=headers)
 
 
 def register_error_handlers(app):
+    @app.exception_handler(httpx.TimeoutException)
+    async def handle_httpx_timeout(request: Request, exc: httpx.TimeoutException):
+        trace_id = _trace_id_from_request(request)
+        # Map outbound HTTP client timeouts to 504 Gateway Timeout
+        # Keep details generic in prod
+        return problem_response(
+            status=504,
+            title="Gateway Timeout",
+            detail=("Upstream request timed out." if IS_PROD else (str(exc) or "httpx timeout")),
+            code="GATEWAY_TIMEOUT",
+            instance=str(request.url),
+            trace_id=trace_id,
+        )
+
     @app.exception_handler(FastApiException)
     async def handle_app_exception(request: Request, exc: FastApiException):
         trace_id = _trace_id_from_request(request)
@@ -104,14 +120,25 @@ def register_error_handlers(app):
     @app.exception_handler(HTTPException)
     async def handle_http_exception(request: Request, exc: HTTPException):
         trace_id = _trace_id_from_request(request)
-        title = {401: "Unauthorized", 403: "Forbidden", 404: "Not Found"}.get(
-            exc.status_code, "Error"
-        )
+        title = {
+            401: "Unauthorized",
+            403: "Forbidden",
+            404: "Not Found",
+            429: "Too Many Requests",
+        }.get(exc.status_code, "Error")
         detail = (
             exc.detail
             if not IS_PROD or exc.status_code < 500
             else "Something went wrong. Please contact support."
         )
+        # Preserve headers set on the exception (e.g., Retry-After for rate limits)
+        hdrs: dict[str, str] | None = None
+        try:
+            if getattr(exc, "headers", None):
+                # FastAPI/Starlette exceptions store headers as a dict[str, str]
+                hdrs = dict(getattr(exc, "headers"))  # type: ignore[arg-type]
+        except Exception:
+            hdrs = None
         return problem_response(
             status=exc.status_code,
             title=title,
@@ -119,19 +146,29 @@ def register_error_handlers(app):
             code=title.replace(" ", "_").upper(),
             instance=str(request.url),
             trace_id=trace_id,
+            headers=hdrs,
         )
 
     @app.exception_handler(StarletteHTTPException)
     async def handle_starlette_http_exception(request: Request, exc: StarletteHTTPException):
         trace_id = _trace_id_from_request(request)
-        title = {401: "Unauthorized", 403: "Forbidden", 404: "Not Found"}.get(
-            exc.status_code, "Error"
-        )
+        title = {
+            401: "Unauthorized",
+            403: "Forbidden",
+            404: "Not Found",
+            429: "Too Many Requests",
+        }.get(exc.status_code, "Error")
         detail = (
             exc.detail
             if not IS_PROD or exc.status_code < 500
             else "Something went wrong. Please contact support."
         )
+        hdrs: dict[str, str] | None = None
+        try:
+            if getattr(exc, "headers", None):
+                hdrs = dict(getattr(exc, "headers"))  # type: ignore[arg-type]
+        except Exception:
+            hdrs = None
         return problem_response(
             status=exc.status_code,
             title=title,
@@ -139,6 +176,7 @@ def register_error_handlers(app):
             code=title.replace(" ", "_").upper(),
             instance=str(request.url),
             trace_id=trace_id,
+            headers=hdrs,
         )
 
     @app.exception_handler(IntegrityError)

svc_infra/api/fastapi/middleware/graceful_shutdown.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from svc_infra.app.env import pick
+
+logger = logging.getLogger(__name__)
+
+
+def _get_grace_period_seconds() -> float:
+    default = pick(prod=20.0, nonprod=5.0)
+    raw = os.getenv("SHUTDOWN_GRACE_PERIOD_SECONDS")
+    if raw is None or raw == "":
+        return float(default)
+    try:
+        return float(raw)
+    except ValueError:
+        return float(default)
+
+
+class InflightTrackerMiddleware:
+    """Tracks number of in-flight requests to support graceful shutdown drains."""
+
+    def __init__(self, app: ASGIApp):
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send):
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        state = scope.get("app").state  # type: ignore[attr-defined]
+        state._inflight_requests = getattr(state, "_inflight_requests", 0) + 1
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            state._inflight_requests = max(0, getattr(state, "_inflight_requests", 1) - 1)
+
+
+async def _wait_for_drain(app: FastAPI, grace: float) -> None:
+    interval = 0.1
+    waited = 0.0
+    while waited < grace:
+        inflight = int(getattr(app.state, "_inflight_requests", 0))
+        if inflight <= 0:
+            return
+        await asyncio.sleep(interval)
+        waited += interval
+    inflight = int(getattr(app.state, "_inflight_requests", 0))
+    if inflight > 0:
+        logger.warning(
+            "Graceful shutdown timeout: %s in-flight request(s) after %.2fs", inflight, waited
+        )
+
+
+def install_graceful_shutdown(app: FastAPI, *, grace_seconds: Optional[float] = None) -> None:
+    """Install inflight tracking and lifespan hooks to wait for requests to drain.
+
+    - Adds InflightTrackerMiddleware
+    - Registers a lifespan handler that initializes state and waits up to grace_seconds on shutdown
+    """
+    app.add_middleware(InflightTrackerMiddleware)
+
+    g = float(grace_seconds) if grace_seconds is not None else _get_grace_period_seconds()
+
+    # Preserve any existing lifespan and wrap it so our drain runs on shutdown.
+    previous_lifespan = getattr(app.router, "lifespan_context", None)
+
+    @asynccontextmanager
+    async def _lifespan(a: FastAPI):  # noqa: ANN202
+        # Startup: initialize inflight counter
+        a.state._inflight_requests = 0
+        if previous_lifespan is not None:
+            async with previous_lifespan(a):
+                yield
+        else:
+            yield
+        # Shutdown: wait for in-flight requests to drain (up to grace period)
+        await _wait_for_drain(a, g)
+
+    app.router.lifespan_context = _lifespan

svc_infra/api/fastapi/middleware/idempotency.py

@@ -1,36 +1,32 @@
+import base64
 import hashlib
 import time
+from typing import Annotated, Dict, Optional
 
+from fastapi import Header, HTTPException, Request
 from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.responses import Response
+from starlette.responses import JSONResponse, Response
+
+from .idempotency_store import IdempotencyStore, InMemoryIdempotencyStore
 
 
 class IdempotencyMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, ttl_seconds: int = 24 * 3600, store=None):
+    def __init__(
+        self,
+        app,
+        ttl_seconds: int = 24 * 3600,
+        store: Optional[IdempotencyStore] = None,
+        header_name: str = "Idempotency-Key",
+    ):
         super().__init__(app)
         self.ttl = ttl_seconds
-        self.store = store or {}  # replace with Redis
+        self.store: IdempotencyStore = store or InMemoryIdempotencyStore()
+        self.header_name = header_name
 
     def _cache_key(self, request, idkey: str):
-        body = getattr(request, "_body", None)
-        if body is None:
-            body = b""
-
-            async def _read():
-                data = await request.body()
-                request._body = data  # stash for downstream
-                return data
-
-            # read once
-            # note: starlette Request is awaitable; we read in dispatch below
-
+        # The cache key must NOT include the body to allow conflict detection for mismatched payloads.
         sig = hashlib.sha256(
-            (
-                request.method + "|" + request.url.path + "|" + idkey + "|" + (request._body or b"")
-            ).encode()
-            if isinstance(request._body, str)
-            else (request.method + "|" + request.url.path + "|" + idkey).encode()
-            + (request._body or b"")
+            (request.method + "|" + request.url.path + "|" + idkey).encode()
         ).hexdigest()
         return f"idmp:{sig}"
 
@@ -39,33 +35,69 @@ class IdempotencyMiddleware(BaseHTTPMiddleware):
             # read & buffer body once
             body = await request.body()
             request._body = body
-            idkey = request.headers.get("Idempotency-Key")
+            idkey = request.headers.get(self.header_name)
             if idkey:
                 k = self._cache_key(request, idkey)
-                entry = self.store.get(k)
                 now = time.time()
-                if entry and entry["exp"] > now:
-                    cached = entry["resp"]
-                    return Response(
-                        content=cached["body"],
-                        status_code=cached["status"],
-                        headers=cached["headers"],
-                        media_type=cached.get("media_type"),
-                    )
+                # build request hash to detect mismatched replays
+                req_hash = hashlib.sha256(body or b"").hexdigest()
+
+                existing = self.store.get(k)
+                if existing and existing.exp > now:
+                    # If payload mismatches any existing claim, return conflict
+                    if existing.req_hash and existing.req_hash != req_hash:
+                        return JSONResponse(
+                            status_code=409,
+                            content={
+                                "type": "about:blank",
+                                "title": "Conflict",
+                                "detail": "Idempotency-Key re-used with different request payload.",
+                            },
+                        )
+                    # If response cached and payload matches, replay it
+                    if existing.status is not None and existing.body_b64 is not None:
+                        return Response(
+                            content=base64.b64decode(existing.body_b64),
+                            status_code=existing.status,
+                            headers=existing.headers or {},
+                            media_type=existing.media_type,
+                        )
+
+                # Claim the key if not present
+                exp = now + self.ttl
+                created = self.store.set_initial(k, req_hash, exp)
+                if not created:
+                    # Someone else claimed; re-check for conflict or replay
+                    existing = self.store.get(k)
+                    if existing and existing.req_hash and existing.req_hash != req_hash:
+                        return JSONResponse(
+                            status_code=409,
+                            content={
+                                "type": "about:blank",
+                                "title": "Conflict",
+                                "detail": "Idempotency-Key re-used with different request payload.",
+                            },
+                        )
+                    if existing and existing.status is not None and existing.body_b64 is not None:
+                        return Response(
+                            content=base64.b64decode(existing.body_b64),
+                            status_code=existing.status,
+                            headers=existing.headers or {},
+                            media_type=existing.media_type,
+                        )
+
+                # Proceed to handler
                 resp = await call_next(request)
-                # cache only 2xx/201 responses
                 if 200 <= resp.status_code < 300:
                     body_bytes = b"".join([section async for section in resp.body_iterator])
-                    headers = dict(resp.headers)
-                    self.store[k] = {
-                        "resp": {
-                            "status": resp.status_code,
-                            "body": body_bytes,
-                            "headers": headers,
-                            "media_type": resp.media_type,
-                        },
-                        "exp": now + self.ttl,
-                    }
+                    headers: Dict[str, str] = dict(resp.headers)
+                    self.store.set_response(
+                        k,
+                        status=resp.status_code,
+                        body=body_bytes,
+                        headers=headers,
+                        media_type=resp.media_type,
+                    )
                     return Response(
                         content=body_bytes,
                         status_code=resp.status_code,
@@ -74,3 +106,11 @@ class IdempotencyMiddleware(BaseHTTPMiddleware):
                     )
                 return resp
         return await call_next(request)
+
+
+async def require_idempotency_key(
+    idempotency_key: Annotated[str, Header(alias="Idempotency-Key")],
+    request: Request,
+) -> None:
+    if not idempotency_key.strip():
+        raise HTTPException(status_code=400, detail="Idempotency-Key must not be empty.")

svc_infra/api/fastapi/middleware/idempotency_store.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import base64
+import json
+import time
+from dataclasses import dataclass
+from typing import Dict, Optional, Protocol
+
+
+@dataclass
+class IdempotencyEntry:
+    req_hash: str
+    exp: float
+    # Optional response fields when available
+    status: Optional[int] = None
+    body_b64: Optional[str] = None
+    headers: Optional[Dict[str, str]] = None
+    media_type: Optional[str] = None
+
+
+class IdempotencyStore(Protocol):
+    def get(self, key: str) -> Optional[IdempotencyEntry]:
+        pass
+
+    def set_initial(self, key: str, req_hash: str, exp: float) -> bool:
+        """Atomically create an entry if absent. Returns True if created, False if already exists."""
+        pass
+
+    def set_response(
+        self,
+        key: str,
+        *,
+        status: int,
+        body: bytes,
+        headers: Dict[str, str],
+        media_type: Optional[str],
+    ) -> None:
+        pass
+
+    def delete(self, key: str) -> None:
+        pass
+
+
+class InMemoryIdempotencyStore:
+    def __init__(self):
+        self._store: dict[str, IdempotencyEntry] = {}
+
+    def get(self, key: str) -> Optional[IdempotencyEntry]:
+        entry = self._store.get(key)
+        if not entry:
+            return None
+        # expire lazily
+        if entry.exp <= time.time():
+            self._store.pop(key, None)
+            return None
+        return entry
+
+    def set_initial(self, key: str, req_hash: str, exp: float) -> bool:
+        now = time.time()
+        existing = self._store.get(key)
+        if existing and existing.exp > now:
+            return False
+        self._store[key] = IdempotencyEntry(req_hash=req_hash, exp=exp)
+        return True
+
+    def set_response(
+        self,
+        key: str,
+        *,
+        status: int,
+        body: bytes,
+        headers: Dict[str, str],
+        media_type: Optional[str],
+    ) -> None:
+        entry = self._store.get(key)
+        if not entry:
+            # Create if missing to ensure replay works until exp
+            entry = IdempotencyEntry(req_hash="", exp=time.time() + 60)
+            self._store[key] = entry
+        entry.status = status
+        entry.body_b64 = base64.b64encode(body).decode()
+        entry.headers = dict(headers)
+        entry.media_type = media_type
+
+    def delete(self, key: str) -> None:
+        self._store.pop(key, None)
+
+
+class RedisIdempotencyStore:
+    """A simple Redis-backed store.
+
+    Notes:
+        - Uses GET/SET with JSON payload; initial claim uses SETNX semantics.
+        - Not fully atomic for response update; sufficient for basic dedupe.
+        - For strict guarantees, replace with a Lua script (future improvement).
+    """
+
+    def __init__(self, redis_client, *, prefix: str = "idmp"):
+        self.r = redis_client
+        self.prefix = prefix
+
+    def _k(self, key: str) -> str:
+        return f"{self.prefix}:{key}"
+
+    def get(self, key: str) -> Optional[IdempotencyEntry]:
+        raw = self.r.get(self._k(key))
+        if not raw:
+            return None
+        try:
+            data = json.loads(raw)
+        except Exception:
+            return None
+        entry = IdempotencyEntry(
+            req_hash=data.get("req_hash", ""),
+            exp=float(data.get("exp", 0)),
+            status=data.get("status"),
+            body_b64=data.get("body_b64"),
+            headers=data.get("headers"),
+            media_type=data.get("media_type"),
+        )
+        if entry.exp <= time.time():
+            try:
+                self.r.delete(self._k(key))
+            except Exception:
+                pass
+            return None
+        return entry
+
+    def set_initial(self, key: str, req_hash: str, exp: float) -> bool:
+        payload = json.dumps({"req_hash": req_hash, "exp": exp})
+        # Attempt NX set
+        ok = self.r.set(self._k(key), payload, nx=True)
+        # If set, also set TTL (expire at exp)
+        if ok:
+            ttl = max(1, int(exp - time.time()))
+            try:
+                self.r.expire(self._k(key), ttl)
+            except Exception:
+                pass
+            return True
+        # If exists but expired, overwrite
+        entry = self.get(key)
+        if not entry:
+            self.r.set(self._k(key), payload)
+            ttl = max(1, int(exp - time.time()))
+            try:
+                self.r.expire(self._k(key), ttl)
+            except Exception:
+                pass
+            return True
+        return False
+
+    def set_response(
+        self,
+        key: str,
+        *,
+        status: int,
+        body: bytes,
+        headers: Dict[str, str],
+        media_type: Optional[str],
+    ) -> None:
+        entry = self.get(key)
+        if not entry:
+            # default short ttl if missing; caller should have set initial
+            entry = IdempotencyEntry(req_hash="", exp=time.time() + 60)
+        entry.status = status
+        entry.body_b64 = base64.b64encode(body).decode()
+        entry.headers = dict(headers)
+        entry.media_type = media_type
+        ttl = max(1, int(entry.exp - time.time()))
+        payload = json.dumps(
+            {
+                "req_hash": entry.req_hash,
+                "exp": entry.exp,
+                "status": entry.status,
+                "body_b64": entry.body_b64,
+                "headers": entry.headers,
+                "media_type": entry.media_type,
+            }
+        )
+        self.r.set(self._k(key), payload, ex=ttl)
+
+    def delete(self, key: str) -> None:
+        try:
+            self.r.delete(self._k(key))
+        except Exception:
+            pass

svc_infra/api/fastapi/middleware/optimistic_lock.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Annotated, Any, Callable, Optional
+
+from fastapi import Header, HTTPException
+
+
+async def require_if_match(
+    version: Annotated[Optional[str], Header(alias="If-Match")] = None
+) -> str:
+    """Require If-Match header for optimistic locking on mutating operations.
+
+    Returns the header value. Raises 428 if missing.
+    """
+    if not version:
+        raise HTTPException(
+            status_code=428, detail="Missing If-Match header for optimistic locking."
+        )
+    return version
+
+
+def check_version_or_409(get_current_version: Callable[[], Any], provided: str) -> None:
+    """Compare provided version with current version; raise 409 on mismatch.
+
+    - get_current_version: callable returning the resource's current version (int/str)
+    - provided: header value; attempts to coerce to int if current is int
+    """
+    current = get_current_version()
+    if isinstance(current, int):
+        try:
+            p = int(provided)
+        except Exception:
+            raise HTTPException(status_code=400, detail="Invalid If-Match value; expected integer.")
+    else:
+        p = provided
+    if p != current:
+        raise HTTPException(status_code=409, detail="Version mismatch (optimistic locking).")