svc-infra 0.1.595__py3-none-any.whl → 1.1.0__py3-none-any.whl

svc_infra/api/fastapi/db/sql/crud_router.py

@@ -1,4 +1,5 @@
-from typing import Annotated, Any, Optional, Sequence, Type, TypeVar, cast
+from collections.abc import Callable, Sequence
+from typing import Annotated, Any, TypeVar, cast
 
 from fastapi import APIRouter, Body, Depends, HTTPException
 from pydantic import BaseModel
@@ -15,7 +16,9 @@ from svc_infra.api.fastapi.db.http import (
 )
 from svc_infra.api.fastapi.dual.public import public_router
 from svc_infra.db.sql.service import SqlService
+from svc_infra.db.sql.tenant import TenantSqlService
 
+from ...tenancy.context import TenantId
 from .session import SqlSessionDep
 
 CreateModel = TypeVar("CreateModel", bound=BaseModel)
@@ -27,14 +30,14 @@ def make_crud_router_plus_sql(
     *,
     model: type[Any],
     service: SqlService,
-    read_schema: Type[ReadModel],
-    create_schema: Type[CreateModel],
-    update_schema: Type[UpdateModel],
+    read_schema: type[ReadModel],
+    create_schema: type[CreateModel],
+    update_schema: type[UpdateModel],
     prefix: str,
     tags: list[str] | None = None,
-    search_fields: Optional[Sequence[str]] = None,
-    default_ordering: Optional[str] = None,
-    allowed_order_fields: Optional[list[str]] = None,
+    search_fields: Sequence[str] | None = None,
+    default_ordering: str | None = None,
+    allowed_order_fields: list[str] | None = None,
     mount_under_db_prefix: bool = True,
 ) -> APIRouter:
     router_prefix = ("/_sql" + prefix) if mount_under_db_prefix else prefix
@@ -44,7 +47,19 @@ def make_crud_router_plus_sql(
         redirect_slashes=False,
     )
 
-    def _parse_ordering_to_fields(order_spec: Optional[str]) -> list[str]:
+    def _coerce_id(v: Any) -> Any:
+        """Best-effort coercion of path ids: cast digit-only strings to int.
+
+        Keeps original type otherwise to avoid breaking non-integer IDs.
+        """
+        if isinstance(v, str) and v.isdigit():
+            try:
+                return int(v)
+            except Exception:
+                return v
+        return v
+
+    def _parse_ordering_to_fields(order_spec: str | None) -> list[str]:
         if not order_spec:
             return []
         pieces = [p.strip() for p in order_spec.split(",") if p.strip()]
@@ -59,14 +74,14 @@ def make_crud_router_plus_sql(
     # -------- LIST --------
     @router.get(
         "",
-        response_model=cast(Any, Page[read_schema]),
+        response_model=Page[read_schema],  # type: ignore[valid-type]
         description=f"List items of type {model.__name__}",
     )
     async def list_items(
         lp: Annotated[LimitOffsetParams, Depends(dep_limit_offset)],
         op: Annotated[OrderParams, Depends(dep_order)],
         sp: Annotated[SearchParams, Depends(dep_search)],
-        session: SqlSessionDep,  # type: ignore[name-defined]
+        session: SqlSessionDep,
     ):
         order_spec = op.order_by or default_ordering
         order_fields = _parse_ordering_to_fields(order_spec)
@@ -79,24 +94,27 @@ def make_crud_router_plus_sql(
                 if f.strip()
             ]
             items = await service.search(
-                session, q=sp.q, fields=fields, limit=lp.limit, offset=lp.offset, order_by=order_by
+                session,
+                q=sp.q,
+                fields=fields,
+                limit=lp.limit,
+                offset=lp.offset,
+                order_by=order_by,
             )
             total = await service.count_filtered(session, q=sp.q, fields=fields)
         else:
             items = await service.list(session, limit=lp.limit, offset=lp.offset, order_by=order_by)
             total = await service.count(session)
-        return Page[read_schema].from_items(
-            total=total, items=items, limit=lp.limit, offset=lp.offset
-        )
+        return Page[Any].from_items(total=total, items=items, limit=lp.limit, offset=lp.offset)
 
     # -------- GET by id --------
     @router.get(
         "/{item_id}",
-        response_model=cast(Any, read_schema),
+        response_model=read_schema,
         description=f"Get item of type {model.__name__}",
     )
-    async def get_item(item_id: Any, session: SqlSessionDep):  # type: ignore[name-defined]
-        row = await service.get(session, item_id)
+    async def get_item(item_id: Any, session: SqlSessionDep):
+        row = await service.get(session, _coerce_id(item_id))
         if not row:
             raise HTTPException(404, "Not found")
         return row
@@ -104,40 +122,197 @@ def make_crud_router_plus_sql(
     # -------- CREATE --------
     @router.post(
         "",
-        response_model=cast(Any, read_schema),
+        response_model=read_schema,
         status_code=201,
         description=f"Create item of type {model.__name__}",
     )
     async def create_item(
-        session: SqlSessionDep,  # type: ignore[name-defined]
-        payload: create_schema = Body(...),
+        session: SqlSessionDep,
+        payload: create_schema = Body(...),  # type: ignore[valid-type]
     ):
-        data = cast(BaseModel, payload).model_dump(exclude_unset=True)
+        if isinstance(payload, BaseModel):
+            data = cast("BaseModel", payload).model_dump(exclude_unset=True)
+        elif isinstance(payload, dict):
+            data = payload
+        else:
+            raise HTTPException(422, "invalid_payload")
         return await service.create(session, data)
 
     # -------- UPDATE --------
     @router.patch(
         "/{item_id}",
-        response_model=cast(Any, read_schema),
+        response_model=read_schema,
         description=f"Update item of type {model.__name__}",
     )
     async def update_item(
         item_id: Any,
-        session: SqlSessionDep,  # type: ignore[name-defined]
-        payload: update_schema = Body(...),
+        session: SqlSessionDep,
+        payload: update_schema = Body(...),  # type: ignore[valid-type]
     ):
-        data = cast(BaseModel, payload).model_dump(exclude_unset=True)
-        row = await service.update(session, item_id, data)
+        if isinstance(payload, BaseModel):
+            data = cast("BaseModel", payload).model_dump(exclude_unset=True)
+        elif isinstance(payload, dict):
+            data = payload
+        else:
+            raise HTTPException(422, "invalid_payload")
+        row = await service.update(session, _coerce_id(item_id), data)
         if not row:
             raise HTTPException(404, "Not found")
         return row
 
     # -------- DELETE --------
     @router.delete(
-        "/{item_id}", status_code=204, description=f"Delete item of type {model.__name__}"
+        "/{item_id}",
+        status_code=204,
+        description=f"Delete item of type {model.__name__}",
     )
-    async def delete_item(item_id: Any, session: SqlSessionDep):  # type: ignore[name-defined]
-        ok = await service.delete(session, item_id)
+    async def delete_item(item_id: Any, session: SqlSessionDep):
+        ok = await service.delete(session, _coerce_id(item_id))
+        if not ok:
+            raise HTTPException(404, "Not found")
+        return
+
+    return router
+
+
+def make_tenant_crud_router_plus_sql(
+    *,
+    model: type[Any],
+    service_factory: Callable[[], Any],  # factory that returns a SqlService (will be wrapped)
+    read_schema: type[ReadModel],
+    create_schema: type[CreateModel],
+    update_schema: type[UpdateModel],
+    prefix: str,
+    tenant_field: str = "tenant_id",
+    tags: list[str] | None = None,
+    search_fields: Sequence[str] | None = None,
+    default_ordering: str | None = None,
+    allowed_order_fields: list[str] | None = None,
+    mount_under_db_prefix: bool = True,
+) -> APIRouter:
+    """Like make_crud_router_plus_sql, but requires TenantId and scopes all operations."""
+    router_prefix = ("/_sql" + prefix) if mount_under_db_prefix else prefix
+    router = public_router(
+        prefix=router_prefix,
+        tags=tags or [prefix.strip("/")],
+        redirect_slashes=False,
+    )
+
+    # Evaluate the base service once to preserve in-memory state across requests in tests/local.
+    # Consumers may pass either an instance or a zero-arg factory function.
+    try:
+        _base_instance = service_factory() if callable(service_factory) else service_factory
+    except TypeError:
+        # If the callable requires args, assume it's already an instance
+        _base_instance = service_factory
+
+    def _coerce_id(v: Any) -> Any:
+        """Best-effort coercion of path ids: cast digit-only strings to int.
+        Keeps original type otherwise.
+        """
+        if isinstance(v, str) and v.isdigit():
+            try:
+                return int(v)
+            except Exception:
+                return v
+        return v
+
+    def _parse_ordering_to_fields(order_spec: str | None) -> list[str]:
+        if not order_spec:
+            return []
+        pieces = [p.strip() for p in order_spec.split(",") if p.strip()]
+        fields: list[str] = []
+        for p in pieces:
+            name = p[1:] if p.startswith("-") else p
+            if allowed_order_fields and name not in (allowed_order_fields or []):
+                continue
+            fields.append(p)
+        return fields
+
+    # create per-request service with tenant scoping
+    async def _svc(session: SqlSessionDep, tenant_id: TenantId):
+        repo_or_service = getattr(_base_instance, "repo", _base_instance)
+        svc: Any = TenantSqlService(repo_or_service, tenant_id=tenant_id, tenant_field=tenant_field)
+        return svc
+
+    @router.get("", response_model=Page[read_schema])  # type: ignore[valid-type]
+    async def list_items(
+        lp: Annotated[LimitOffsetParams, Depends(dep_limit_offset)],
+        op: Annotated[OrderParams, Depends(dep_order)],
+        sp: Annotated[SearchParams, Depends(dep_search)],
+        session: SqlSessionDep,
+        tenant_id: TenantId,
+    ):
+        svc = await _svc(session, tenant_id)
+        order_spec = op.order_by or default_ordering
+        order_fields = _parse_ordering_to_fields(order_spec)
+        order_by = build_order_by(model, order_fields)
+        if sp.q:
+            fields = [
+                f.strip()
+                for f in (sp.fields or (",".join(search_fields or []) or "")).split(",")
+                if f.strip()
+            ]
+            items = await svc.search(
+                session,
+                q=sp.q,
+                fields=fields,
+                limit=lp.limit,
+                offset=lp.offset,
+                order_by=order_by,
+            )
+            total = await svc.count_filtered(session, q=sp.q, fields=fields)
+        else:
+            items = await svc.list(session, limit=lp.limit, offset=lp.offset, order_by=order_by)
+            total = await svc.count(session)
+        return Page[Any].from_items(total=total, items=items, limit=lp.limit, offset=lp.offset)
+
+    @router.get("/{item_id}", response_model=read_schema)
+    async def get_item(item_id: Any, session: SqlSessionDep, tenant_id: TenantId):
+        svc = await _svc(session, tenant_id)
+        obj = await svc.get(session, item_id)
+        if not obj:
+            raise HTTPException(404, "not_found")
+        return obj
+
+    @router.post("", response_model=read_schema, status_code=201)
+    async def create_item(
+        session: SqlSessionDep,
+        tenant_id: TenantId,
+        payload: create_schema = Body(...),  # type: ignore[valid-type]
+    ):
+        svc = await _svc(session, tenant_id)
+        if isinstance(payload, BaseModel):
+            data = cast("BaseModel", payload).model_dump(exclude_unset=True)
+        elif isinstance(payload, dict):
+            data = payload
+        else:
+            raise HTTPException(422, "invalid_payload")
+        return await svc.create(session, data)
+
+    @router.patch("/{item_id}", response_model=read_schema)
+    async def update_item(
+        item_id: Any,
+        session: SqlSessionDep,
+        tenant_id: TenantId,
+        payload: update_schema = Body(...),  # type: ignore[valid-type]
+    ):
+        svc = await _svc(session, tenant_id)
+        if isinstance(payload, BaseModel):
+            data = cast("BaseModel", payload).model_dump(exclude_unset=True)
+        elif isinstance(payload, dict):
+            data = payload
+        else:
+            raise HTTPException(422, "invalid_payload")
+        updated = await svc.update(session, item_id, data)
+        if not updated:
+            raise HTTPException(404, "not_found")
+        return updated
+
+    @router.delete("/{item_id}", status_code=204)
+    async def delete_item(item_id: Any, session: SqlSessionDep, tenant_id: TenantId):
+        svc = await _svc(session, tenant_id)
+        ok = await svc.delete(session, _coerce_id(item_id))
         if not ok:
             raise HTTPException(404, "Not found")
         return
@@ -145,4 +320,4 @@ def make_crud_router_plus_sql(
     return router
 
 
-__all__ = ["make_crud_router_plus_sql"]
+__all__ = ["make_crud_router_plus_sql", "make_tenant_crud_router_plus_sql"]

svc_infra/api/fastapi/db/sql/session.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import logging
-from typing import Annotated, AsyncIterator, Tuple
+import os
+from collections.abc import AsyncIterator
+from typing import Annotated
 
 from fastapi import Depends
+from sqlalchemy import text
 from sqlalchemy.ext.asyncio import (
     AsyncEngine,
     AsyncSession,
@@ -21,7 +24,7 @@ _SessionLocal: async_sessionmaker[AsyncSession] | None = None
 
 def _init_engine_and_session(
     url: str,
-) -> Tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
+) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
     async_url = _coerce_to_async_url(url)
     if async_url != url:
         logger.info(
@@ -53,6 +56,20 @@ async def get_session() -> AsyncIterator[AsyncSession]:
     if _SessionLocal is None:
         raise RuntimeError("Database not initialized. Call add_sql_db(app, ...) first.")
     async with _SessionLocal() as session:
+        # Optional: set a per-transaction statement timeout for Postgres if configured
+        raw_ms = os.getenv("DB_STATEMENT_TIMEOUT_MS")
+        if raw_ms:
+            try:
+                ms = int(raw_ms)
+                if ms > 0:
+                    try:
+                        # SET LOCAL applies for the duration of the current transaction only
+                        await session.execute(text("SET LOCAL statement_timeout = :ms"), {"ms": ms})
+                    except Exception:
+                        # Non-PG dialects (e.g., SQLite) will error; ignore silently
+                        pass
+            except ValueError:
+                pass
         try:
             yield session
             await session.commit()

svc_infra/api/fastapi/db/sql/users.py

@@ -1,17 +1,22 @@
 from __future__ import annotations
 
-from typing import Any, AsyncIterator, Callable, Tuple
+from collections.abc import AsyncIterator, Callable
+from typing import Any
 from uuid import UUID
 
 from fastapi import Depends
 from fastapi_users import FastAPIUsers
-from fastapi_users.authentication import AuthenticationBackend, BearerTransport, JWTStrategy
+from fastapi_users.authentication import (
+    AuthenticationBackend,
+    BearerTransport,
+    JWTStrategy,
+)
 from fastapi_users.manager import BaseUserManager, UUIDIDMixin
 
 from svc_infra.api.fastapi.auth.settings import get_auth_settings
 from svc_infra.api.fastapi.dual.dualize import dualize_public, dualize_user
 from svc_infra.api.fastapi.dual.router import DualAPIRouter
-from svc_infra.app.env import CURRENT_ENVIRONMENT, DEV_ENV, LOCAL_ENV
+from svc_infra.app.env import CURRENT_ENVIRONMENT, DEV_ENV, LOCAL_ENV, require_secret
 from svc_infra.security.jwt_rotation import RotatingJWTStrategy
 
 from ...auth.security import auth_login_path
@@ -26,7 +31,7 @@ def get_fastapi_users(
     user_schema_update: Any,
     *,
     public_auth_prefix: str = "/auth",
-) -> Tuple[
+) -> tuple[
     FastAPIUsers,
     AuthenticationBackend,
     DualAPIRouter,
@@ -56,10 +61,10 @@ def get_fastapi_users(
             verify_url = f"{public_auth_prefix}/verify?token={token}"
             sender = get_sender()
             sender.send(
-                to=getattr(user, "email"),
+                to=user.email,
                 subject="Verify your account",
                 html_body=f"""
-                    <p>Hi {getattr(user, 'full_name', '') or 'there'},</p>
+                    <p>Hi {getattr(user, "full_name", "") or "there"},</p>
                     <p>Click to verify your account:</p>
                     <p><a href="{verify_url}">{verify_url}</a></p>
                 """,
@@ -69,7 +74,7 @@ def get_fastapi_users(
             reset_url = f"{public_auth_prefix}/reset-password?token={token}"
             sender = get_sender()
             sender.send(
-                to=getattr(user, "email"),
+                to=user.email,
                 subject="Reset your password",
                 html_body=f"""
                     <p>We received a request to reset your password.</p>
@@ -91,14 +96,18 @@ def get_fastapi_users(
         if jwt_block and getattr(jwt_block, "secret", None):
             secret = jwt_block.secret.get_secret_value()
         else:
-            secret = "svc-dev-secret-change-me"
+            secret = require_secret(
+                None,
+                "JWT_SECRET (via auth settings jwt.secret)",
+                dev_default="dev-only-jwt-secret-not-for-production",
+            )
         lifetime = getattr(jwt_block, "lifetime_seconds", None) if jwt_block else None
         if not isinstance(lifetime, int) or lifetime <= 0:
             lifetime = 3600
         old = []
         if jwt_block and getattr(jwt_block, "old_secrets", None):
             old = [s.get_secret_value() for s in jwt_block.old_secrets or []]
-        audience = "fastapi-users:auth"
+        audience = ["fastapi-users:auth"]
         if old:
             return RotatingJWTStrategy(
                 secret=secret,

svc_infra/api/fastapi/dependencies/ratelimit.py

@@ -1,14 +1,27 @@
 from __future__ import annotations
 
+import logging
 import time
-from typing import Callable
+from collections.abc import Callable
 
 from fastapi import HTTPException
 from starlette.requests import Request
 
-from svc_infra.api.fastapi.middleware.ratelimit_store import InMemoryRateLimitStore, RateLimitStore
+from svc_infra.api.fastapi.middleware.ratelimit_store import (
+    InMemoryRateLimitStore,
+    RateLimitStore,
+)
 from svc_infra.obs.metrics import emit_rate_limited
 
+logger = logging.getLogger(__name__)
+
+try:
+    from svc_infra.api.fastapi.tenancy.context import (
+        resolve_tenant_id as _resolve_tenant_id,
+    )
+except Exception:  # pragma: no cover - minimal builds
+    _resolve_tenant_id = None  # type: ignore[assignment]
+
 
 class RateLimiter:
     def __init__(
@@ -17,24 +30,50 @@ class RateLimiter:
         limit: int,
         window: int = 60,
         key_fn: Callable = lambda r: "global",
+        limit_resolver: Callable[[Request, str | None], int | None] | None = None,
+        scope_by_tenant: bool = False,
         store: RateLimitStore | None = None,
     ):
         self.limit = limit
         self.window = window
         self.key_fn = key_fn
+        self._limit_resolver = limit_resolver
+        self.scope_by_tenant = scope_by_tenant
         self.store = store or InMemoryRateLimitStore(limit=limit)
 
     async def __call__(self, request: Request):
+        # Try resolving tenant when asked
+        tenant_id = None
+        if self.scope_by_tenant or self._limit_resolver:
+            try:
+                if _resolve_tenant_id is not None:
+                    tenant_id = await _resolve_tenant_id(request)
+            except Exception:
+                tenant_id = None
+
         key = self.key_fn(request)
-        count, limit, reset = self.store.incr(str(key), self.window)
-        if count > limit:
-            retry = max(0, reset - int(time.time()))
+        if self.scope_by_tenant and tenant_id:
+            key = f"{key}:tenant:{tenant_id}"
+
+        eff_limit = self.limit
+        if self._limit_resolver:
             try:
-                emit_rate_limited(str(key), limit, retry)
+                v = self._limit_resolver(request, tenant_id)
+                eff_limit = int(v) if v is not None else self.limit
             except Exception:
-                pass
+                eff_limit = self.limit
+
+        count, _store_limit, reset = self.store.incr(str(key), self.window)
+        if count > eff_limit:
+            retry = max(0, reset - int(time.time()))
+            try:
+                emit_rate_limited(str(key), eff_limit, retry)
+            except Exception as e:
+                logger.warning("Failed to emit rate limit metric: %s", e)
             raise HTTPException(
-                status_code=429, detail="Rate limit exceeded", headers={"Retry-After": str(retry)}
+                status_code=429,
+                detail="Rate limit exceeded",
+                headers={"Retry-After": str(retry)},
             )
 
 
@@ -46,21 +85,44 @@ def rate_limiter(
     limit: int,
     window: int = 60,
     key_fn: Callable = lambda r: "global",
+    limit_resolver: Callable[[Request, str | None], int | None] | None = None,
+    scope_by_tenant: bool = False,
     store: RateLimitStore | None = None,
 ):
     store_ = store or InMemoryRateLimitStore(limit=limit)
 
     async def dep(request: Request):
+        tenant_id = None
+        if scope_by_tenant or limit_resolver:
+            try:
+                if _resolve_tenant_id is not None:
+                    tenant_id = await _resolve_tenant_id(request)
+            except Exception:
+                tenant_id = None
+
         key = key_fn(request)
-        count, lim, reset = store_.incr(str(key), window)
-        if count > lim:
-            retry = max(0, reset - int(time.time()))
+        if scope_by_tenant and tenant_id:
+            key = f"{key}:tenant:{tenant_id}"
+
+        eff_limit = limit
+        if limit_resolver:
             try:
-                emit_rate_limited(str(key), lim, retry)
+                v = limit_resolver(request, tenant_id)
+                eff_limit = int(v) if v is not None else limit
             except Exception:
-                pass
+                eff_limit = limit
+
+        count, _store_limit, reset = store_.incr(str(key), window)
+        if count > eff_limit:
+            retry = max(0, reset - int(time.time()))
+            try:
+                emit_rate_limited(str(key), eff_limit, retry)
+            except Exception as e:
+                logger.warning("Failed to emit rate limit metric: %s", e)
             raise HTTPException(
-                status_code=429, detail="Rate limit exceeded", headers={"Retry-After": str(retry)}
+                status_code=429,
+                detail="Rate limit exceeded",
+                headers={"Retry-After": str(retry)},
             )
 
     return dep