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

svc_infra/api/fastapi/db/http.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Generic, Iterable, List, Optional, Sequence, TypeVar
+from collections.abc import Iterable, Sequence
+from typing import Any, Generic, TypeVar
 
 from fastapi import Query
 from pydantic import BaseModel
@@ -21,37 +22,37 @@ def dep_limit_offset(
 
 
 class OrderParams(BaseModel):
-    order_by: Optional[str] = None
+    order_by: str | None = None
 
 
 def dep_order(
-    order_by: Optional[str] = Query(None, description="Comma-separated fields; '-' for DESC"),
+    order_by: str | None = Query(None, description="Comma-separated fields; '-' for DESC"),
 ) -> OrderParams:
     return OrderParams(order_by=order_by)
 
 
 class SearchParams(BaseModel):
-    q: Optional[str] = None
-    fields: Optional[str] = None
+    q: str | None = None
+    fields: str | None = None
 
 
 def dep_search(
-    q: Optional[str] = Query(None, description="Search query"),
-    fields: Optional[str] = Query(None, description="Comma-separated list of fields"),
+    q: str | None = Query(None, description="Search query"),
+    fields: str | None = Query(None, description="Comma-separated list of fields"),
 ) -> SearchParams:
     return SearchParams(q=q, fields=fields)
 
 
 class Page(BaseModel, Generic[T]):
     total: int
-    items: List[T]
+    items: list[T]
     limit: int
     offset: int
 
     @classmethod
     def from_items(
         cls, *, total: int, items: Sequence[T] | Iterable[T], limit: int, offset: int
-    ) -> "Page[T]":
+    ) -> Page[T]:
         return cls(total=total, items=list(items), limit=limit, offset=offset)
 
 

svc_infra/api/fastapi/db/nosql/__init__.py

@@ -1,4 +1,42 @@
-from .mongo.add import add_mongo_db, add_mongo_health, add_mongo_resources
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+    from svc_infra.db.nosql.resource import NoSqlResource
+
+
+def _missing_mongo_dependency() -> ModuleNotFoundError:
+    return ModuleNotFoundError(
+        "MongoDB support is an optional dependency. Install pymongo (and motor) to use "
+        "Mongo helpers like add_mongo_db/add_mongo_health/add_mongo_resources."
+    )
+
+
+try:
+    from .mongo.add import add_mongo_db, add_mongo_health, add_mongo_resources
+except ModuleNotFoundError as exc:
+    mongo_import_error = exc
+
+    # NOTE: pymongo provides `bson`, which can be absent in minimal installs/CI.
+    # We keep imports working for non-mongo users/tests by providing stubs.
+    def add_mongo_db(app: FastAPI, *, dsn_env: str = "MONGO_URL") -> None:
+        raise _missing_mongo_dependency() from mongo_import_error
+
+    def add_mongo_health(
+        app: FastAPI,
+        *,
+        prefix: str = "/_mongo/health",
+        include_in_schema: bool = False,
+    ) -> None:
+        raise _missing_mongo_dependency() from mongo_import_error
+
+    def add_mongo_resources(app: FastAPI, resources: Sequence[NoSqlResource]) -> None:
+        raise _missing_mongo_dependency() from mongo_import_error
+
 
 __all__ = [
     # MongoDB

svc_infra/api/fastapi/db/nosql/mongo/add.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Sequence
 from contextlib import asynccontextmanager
-from typing import Sequence
 
 from bson import ObjectId
 from fastapi import FastAPI
@@ -24,7 +24,8 @@ from .health import make_mongo_health_router
 def add_mongo_db_with_url(app: FastAPI, url: str, db_name: str) -> None:
     @asynccontextmanager
     async def lifespan(_app: FastAPI):
-        await init_mongo(MongoSettings(url=url, db_name=db_name))
+        # MongoSettings expects url as AnyUrl, which can be constructed from str via Pydantic
+        await init_mongo(MongoSettings(url=url, db_name=db_name))  # type: ignore[arg-type]  # Pydantic coerces str to AnyUrl
         try:
             expected = get_mongo_dbname_from_env(required=False)
             db = await acquire_db()
@@ -38,8 +39,8 @@ def add_mongo_db_with_url(app: FastAPI, url: str, db_name: str) -> None:
 
 
 def add_mongo_db(app: FastAPI, *, dsn_env: str = "MONGO_URL") -> None:
-    @app.on_event("startup")
-    async def _startup() -> None:
+    @asynccontextmanager
+    async def lifespan(_app: FastAPI):
         if not os.getenv(dsn_env):
             raise RuntimeError(f"Missing environment variable {dsn_env} for Mongo URL")
         await init_mongo()
@@ -47,10 +48,12 @@ def add_mongo_db(app: FastAPI, *, dsn_env: str = "MONGO_URL") -> None:
         db = await acquire_db()
         if expected and db.name != expected:
             raise RuntimeError(f"Connected to Mongo DB '{db.name}', expected '{expected}'.")
+        try:
+            yield
+        finally:
+            await close_mongo()
 
-    @app.on_event("shutdown")
-    async def _shutdown() -> None:
-        await close_mongo()
+    app.router.lifespan_context = lifespan
 
 
 def add_mongo_health(
@@ -62,46 +65,48 @@ def add_mongo_health(
 
 
 def add_mongo_resources(app: FastAPI, resources: Sequence[NoSqlResource]) -> None:
-    for r in resources:
+    for resource in resources:
         repo = NoSqlRepository(
-            collection_name=r.resolved_collection(),
-            id_field=r.id_field,
-            soft_delete=r.soft_delete,
-            soft_delete_field=r.soft_delete_field,
-            soft_delete_flag_field=r.soft_delete_flag_field,
+            collection_name=resource.resolved_collection(),
+            id_field=resource.id_field,
+            soft_delete=resource.soft_delete,
+            soft_delete_field=resource.soft_delete_field,
+            soft_delete_flag_field=resource.soft_delete_flag_field,
         )
-        svc = r.service_factory(repo) if r.service_factory else NoSqlService(repo)
+        svc = resource.service_factory(repo) if resource.service_factory else NoSqlService(repo)
 
-        if r.read_schema and r.create_schema and r.update_schema:
-            Read, Create, Update = r.read_schema, r.create_schema, r.update_schema
-        elif r.document_model is not None:
+        if resource.read_schema and resource.create_schema and resource.update_schema:
+            Read, Create, Update = (
+                resource.read_schema,
+                resource.create_schema,
+                resource.update_schema,
+            )
+        elif resource.document_model is not None:
             # CRITICAL: teach Pydantic to dump ObjectId/PyObjectId
             Read, Create, Update = make_document_crud_schemas(
-                r.document_model,
-                create_exclude=r.create_exclude,
-                read_name=r.read_name,
-                create_name=r.create_name,
-                update_name=r.update_name,
-                read_exclude=r.read_exclude,
-                update_exclude=r.update_exclude,
+                resource.document_model,
+                create_exclude=resource.create_exclude,
+                read_name=resource.read_name,
+                create_name=resource.create_name,
+                update_name=resource.update_name,
+                read_exclude=resource.read_exclude,
+                update_exclude=resource.update_exclude,
                 json_encoders={ObjectId: str, PyObjectId: str},
             )
         else:
             raise RuntimeError(
-                f"Resource for collection '{r.collection}' requires either explicit schemas "
+                f"Resource for collection '{resource.collection}' requires either explicit schemas "
                 f"(read/create/update) or a 'document_model' to derive them."
             )
 
         router = make_crud_router_plus_mongo(
-            collection=r.resolved_collection(),
-            repo=repo,
             service=svc,
             read_schema=Read,
             create_schema=Create,
             update_schema=Update,
-            prefix=r.prefix,
-            tags=r.tags,
-            search_fields=r.search_fields,
+            prefix=resource.prefix,
+            tags=resource.tags,
+            search_fields=resource.search_fields,
             default_ordering=None,
             allowed_order_fields=None,
         )

svc_infra/api/fastapi/db/nosql/mongo/crud_router.py

@@ -1,7 +1,15 @@
-from typing import Annotated, Any, Optional, Sequence, Type, cast
+from collections.abc import Sequence
+from typing import Annotated, Any, cast
 
 from fastapi import APIRouter, Body, Depends, HTTPException
-from motor.motor_asyncio import AsyncIOMotorDatabase
+
+try:
+    from motor.motor_asyncio import AsyncIOMotorDatabase
+
+    HAS_MOTOR = True
+except ImportError:  # pragma: no cover
+    HAS_MOTOR = False
+    AsyncIOMotorDatabase = Any  # type: ignore[assignment, misc]
 
 from svc_infra.api.fastapi.db.http import (
     LimitOffsetParams,
@@ -20,7 +28,7 @@ DBDep = Annotated[AsyncIOMotorDatabase, Depends(acquire_db)]
 
 
 def _parse_sort(
-    order_spec: Optional[str], allowed_order_fields: Optional[list[str]]
+    order_spec: str | None, allowed_order_fields: list[str] | None
 ) -> list[tuple[str, int]]:
     if not order_spec:
         return []
@@ -36,16 +44,19 @@ def _parse_sort(
 def make_crud_router_plus_mongo(
     *,
     service: NoSqlService,
-    read_schema: Type[Any],
-    create_schema: Type[Any],
-    update_schema: Type[Any],
+    read_schema: type[Any],
+    create_schema: type[Any],
+    update_schema: type[Any],
     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:
+    read_model = cast("Any", read_schema)
+    page_model = cast("Any", Page[read_schema])  # type: ignore[valid-type]
+
     router_prefix = ("/_mongo" + prefix) if mount_under_db_prefix else prefix
     router = public_router(
         prefix=router_prefix,
@@ -56,7 +67,7 @@ def make_crud_router_plus_mongo(
     # LIST
     @router.get(
         "",
-        response_model=cast(Any, Page[read_schema]),
+        response_model=page_model,
         description=f"List items in {prefix} collection",
     )
     async def list_items(
@@ -68,20 +79,23 @@ def make_crud_router_plus_mongo(
         sort = _parse_sort(op.order_by or default_ordering, allowed_order_fields)
         if sp.q and search_fields:
             items = await service.search(
-                db, q=sp.q, fields=search_fields, limit=lp.limit, offset=lp.offset, sort=sort
+                db,
+                q=sp.q,
+                fields=search_fields,
+                limit=lp.limit,
+                offset=lp.offset,
+                sort=sort,
             )
             total = await service.count_filtered(db, q=sp.q, fields=search_fields)
         else:
             items = await service.list(db, limit=lp.limit, offset=lp.offset, sort=sort)
             total = await service.count(db)
-        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_model,
         description=f"Get item from {prefix} collection",
     )
     async def get_item(db: DBDep, item_id: Any):
@@ -93,22 +107,26 @@ def make_crud_router_plus_mongo(
     # CREATE
     @router.post(
         "",
-        response_model=cast(Any, read_schema),
+        response_model=read_model,
         status_code=201,
         description=f"Create item in {prefix} collection",
     )
-    async def create_item(db: DBDep, payload: create_schema = Body(...)):
-        data = payload.model_dump(exclude_unset=True)
+    async def create_item(db: DBDep, payload: create_schema = Body(...)):  # type: ignore[valid-type]
+        data = cast("Any", payload).model_dump(exclude_unset=True)
         return await service.create(db, data)
 
     # UPDATE
     @router.patch(
         "/{item_id}",
-        response_model=cast(Any, read_schema),
+        response_model=read_model,
         description=f"Update item in {prefix} collection",
     )
-    async def update_item(db: DBDep, item_id: Any, payload: update_schema = Body(...)):
-        data = payload.model_dump(exclude_unset=True)
+    async def update_item(
+        db: DBDep,
+        item_id: Any,
+        payload: update_schema = Body(...),  # type: ignore[valid-type]
+    ):
+        data = cast("Any", payload).model_dump(exclude_unset=True)
         row = await service.update(db, item_id, data)
         if not row:
             raise HTTPException(404, "Not found")

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

@@ -1,4 +1,8 @@
-from svc_infra.api.fastapi.db.sql.add import add_sql_db, add_sql_health, add_sql_resources
+from svc_infra.api.fastapi.db.sql.add import (
+    add_sql_db,
+    add_sql_health,
+    add_sql_resources,
+)
 from svc_infra.api.fastapi.db.sql.session import SqlSessionDep
 
 __all__ = [

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

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Sequence
 from contextlib import asynccontextmanager
-from typing import Optional, Sequence
 
 from fastapi import FastAPI
 
@@ -10,7 +10,7 @@ from svc_infra.db.sql.management import make_crud_schemas
 from svc_infra.db.sql.repository import SqlRepository
 from svc_infra.db.sql.resource import SqlResource
 
-from .crud_router import make_crud_router_plus_sql
+from .crud_router import make_crud_router_plus_sql, make_tenant_crud_router_plus_sql
 from .health import _make_db_health_router
 from .session import dispose_session, initialize_session
 
@@ -37,46 +37,83 @@ def add_sql_resources(app: FastAPI, resources: Sequence[SqlResource]) -> None:
                 update_name=r.update_name,
             )
 
-        router = make_crud_router_plus_sql(
-            model=r.model,
-            service=svc,
-            read_schema=Read,
-            create_schema=Create,
-            update_schema=Update,
-            prefix=r.prefix,
-            tags=r.tags,
-            search_fields=r.search_fields,
-            default_ordering=r.ordering_default,
-            allowed_order_fields=r.allowed_order_fields,
-        )
+        if r.tenant_field:
+            # wrap service factory/instance through tenant router
+            def _factory():
+                return svc
+
+            router = make_tenant_crud_router_plus_sql(
+                model=r.model,
+                service_factory=_factory,
+                read_schema=Read,
+                create_schema=Create,
+                update_schema=Update,
+                prefix=r.prefix,
+                tenant_field=r.tenant_field,
+                tags=r.tags,
+                search_fields=r.search_fields,
+                default_ordering=r.ordering_default,
+                allowed_order_fields=r.allowed_order_fields,
+            )
+        else:
+            router = make_crud_router_plus_sql(
+                model=r.model,
+                service=svc,
+                read_schema=Read,
+                create_schema=Create,
+                update_schema=Update,
+                prefix=r.prefix,
+                tags=r.tags,
+                search_fields=r.search_fields,
+                default_ordering=r.ordering_default,
+                allowed_order_fields=r.allowed_order_fields,
+            )
         app.include_router(router)
 
 
-def add_sql_db(app: FastAPI, *, url: Optional[str] = None, dsn_env: str = "SQL_URL") -> None:
-    """Configure DB lifecycle for the app (either explicit URL or from env)."""
+def add_sql_db(app: FastAPI, *, url: str | None = None, dsn_env: str = "SQL_URL") -> None:
+    """Configure DB lifecycle for the app (either explicit URL or from env).
+
+    This preserves any existing lifespan context (like user-defined lifespans)
+    and wraps it with the database session initialization/cleanup.
+    """
+    # Preserve existing lifespan to wrap it
+    existing_lifespan = getattr(app.router, "lifespan_context", None)
+
     if url:
 
         @asynccontextmanager
-        async def lifespan(_app: FastAPI):
+        async def lifespan_with_url(_app: FastAPI):
             initialize_session(url)
             try:
-                yield
+                if existing_lifespan is not None:
+                    async with existing_lifespan(_app):
+                        yield
+                else:
+                    yield
             finally:
                 await dispose_session()
 
-        app.router.lifespan_context = lifespan
+        app.router.lifespan_context = lifespan_with_url
         return
 
-    @app.on_event("startup")
-    async def _startup() -> None:  # noqa: ANN202
+    # Use lifespan context manager instead of deprecated on_event
+    @asynccontextmanager
+    async def lifespan_from_env(_app: FastAPI):
         env_url = os.getenv(dsn_env)
         if not env_url:
             raise RuntimeError(f"Missing environment variable {dsn_env} for database URL")
         initialize_session(env_url)
+        try:
+            if existing_lifespan is not None:
+                async with existing_lifespan(_app):
+                    yield
+            else:
+                yield
+        finally:
+            await dispose_session()
 
-    @app.on_event("shutdown")
-    async def _shutdown() -> None:  # noqa: ANN202
-        await dispose_session()
+    app.router.lifespan_context = lifespan_from_env
 
 
 def add_sql_health(
@@ -89,7 +126,7 @@ def setup_sql(
     app: FastAPI,
     resources: Sequence[SqlResource],
     *,
-    url: Optional[str] = None,
+    url: str | None = None,
     dsn_env: str = "SQL_URL",
     include_health: bool = True,
     health_prefix: str = "/_sql/health",