svc-infra 0.1.185__tar.gz → 0.1.187__tar.gz

{svc_infra-0.1.185 → svc_infra-0.1.187}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: svc-infra
-Version: 0.1.185
+Version: 0.1.187
 Summary: Infrastructure for building and deploying prod-ready services
 License: MIT
 Keywords: fastapi,sqlalchemy,alembic,auth,infra,async,pydantic

{svc_infra-0.1.185 → svc_infra-0.1.187}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "svc-infra"
-version = "0.1.185"
+version = "0.1.187"
 description = "Infrastructure for building and deploying prod-ready services"
 authors = ["Ali Khatami <aliikhatami94@gmail.com>"]
 license = "MIT"

{svc_infra-0.1.185 → svc_infra-0.1.187}/src/svc_infra/api/fastapi/db/add.py

@@ -4,7 +4,7 @@ from typing import Optional, Sequence
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 
-from svc_infra.auth.user_default import make_default_user_service
+from svc_infra.api.fastapi.db.user.user_default import make_default_user_service
 from .repository import Repository
 from .service import Service
 from .crud_router import make_crud_router_plus

svc_infra-0.1.187/src/svc_infra/api/fastapi/db/user/user_default.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict
+from fastapi_users.password import PasswordHelper
+
+from svc_infra.api.fastapi.db.repository import Repository
+from svc_infra.db.uniq_hooks import dedupe_service
+
+_pwd = PasswordHelper()
+
+def make_default_user_service(repo: Repository):
+
+    def _user_pre_create(data: Dict[str, Any]) -> Dict[str, Any]:
+        data = dict(data)
+        if "password" in data:
+            data["password_hash"] = _pwd.hash(data.pop("password"))
+        if "metadata" in data:
+            data["extra"] = data.pop("metadata")
+        data.setdefault("roles", [])
+        return data
+
+    def _user_pre_update(data: Dict[str, Any]) -> Dict[str, Any]:
+        data = dict(data)
+        if "password" in data:
+            data["password_hash"] = _pwd.hash(data.pop("password"))
+        if "metadata" in data:
+            data["extra"] = data.pop("metadata")
+        return data
+
+    # First wrap with the general uniqueness service
+    SvcUniq = dedupe_service(
+        repo,
+        unique_ci=["email"],
+        tenant_field="tenant_id",
+        messages={("email",): "User with this email already exists."},
+    )
+
+    # Then inject your prehooks by subclassing once
+    class _Svc(SvcUniq.__class__):  # keep the uniqueness behavior
+        async def pre_create(self, data):  # type: ignore[override]
+            return _user_pre_create(data)
+
+        async def pre_update(self, data):  # type: ignore[override]
+            return _user_pre_update(data)
+
+    # Instantiate with the same repo
+    return _Svc(repo)

{svc_infra-0.1.185/src/svc_infra/auth → svc_infra-0.1.187/src/svc_infra/api/fastapi/db/user}/users.py

@@ -7,7 +7,7 @@ from fastapi_users import FastAPIUsers
 from fastapi_users.authentication import AuthenticationBackend, BearerTransport, JWTStrategy
 from fastapi_users.manager import BaseUserManager, UUIDIDMixin
 
-from .settings import get_auth_settings
+from svc_infra.auth.settings import get_auth_settings
 
 
 def get_fastapi_users(

svc_infra-0.1.187/src/svc_infra/auth/__init__.py

@@ -0,0 +1,5 @@
+from .integration import enable_auth
+
+__all__ = [
+    "enable_auth",
+]

{svc_infra-0.1.185 → svc_infra-0.1.187}/src/svc_infra/auth/integration.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
+
 from fastapi import FastAPI
+from pydantic import ValidationError
+
+from svc_infra.api.fastapi.db.user.users import get_fastapi_users
 
-from .users import get_fastapi_users
 from .oauth_router import oauth_router_with_backend
 from .providers import providers_from_settings
-
 from .settings import get_auth_settings
-from pydantic import ValidationError
-
 
 def enable_auth(
         app: FastAPI,

svc_infra-0.1.187/src/svc_infra/db/uniq_hooks.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union
+
+from fastapi import HTTPException
+from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError
+
+from svc_infra.api.fastapi.db.repository import Repository
+from svc_infra.api.fastapi.db.service_hooks import ServiceWithHooks
+
+ColumnSpec = Union[str, Sequence[str]]  # "email" or ("first_name","last_name")
+
+def _as_tuple(spec: ColumnSpec) -> Tuple[str, ...]:
+    return (spec,) if isinstance(spec, str) else tuple(spec)
+
+def _all_present(data: Dict[str, Any], fields: Sequence[str]) -> bool:
+    return all(f in data for f in fields)
+
+def _nice_label(fields: Sequence[str], data: Dict[str, Any]) -> str:
+    # e.g. ("email",) -> email='a@b.com' ; ("first","last")-> (first='x', last='y')
+    if len(fields) == 1:
+        f = fields[0]
+        return f"{f}={data.get(f)!r}"
+    parts = [f"{f}={data.get(f)!r}" for f in fields]
+    return "(" + ", ".join(parts) + ")"
+
+def dedupe_service(
+        repo: Repository,
+        *,
+        unique_cs: Iterable[ColumnSpec] = (),
+        unique_ci: Iterable[ColumnSpec] = (),
+        tenant_field: Optional[str] = None,
+        # Optional: customize the error message per spec. Keys are tuples of column names.
+        messages: Optional[dict[Tuple[str, ...], str]] = None,
+):
+    """
+    Create a Service instance that:
+      - Pre-checks duplicates for the provided uniqueness specs (case sensitive & insensitive)
+      - Returns HTTP 409 with a friendly message
+      - Still catches IntegrityError to 409 for race-safety
+    The arguments mirror `make_unique_indexes(...)`.
+    """
+    Model = repo.model
+    messages = messages or {}
+
+    # Build a helper that turns a spec into a WHERE clause based on provided data
+    def _build_where_from_spec(data: Dict[str, Any], spec: Tuple[str, ...], *, ci: bool, exclude_id: Any | None):
+        clauses: List[Any] = []
+
+        # spec columns
+        for col_name in spec:
+            col = getattr(Model, col_name)
+            val = data.get(col_name)
+            if ci:
+                clauses.append(func.lower(col) == func.lower(val))
+            else:
+                clauses.append(col == val)
+
+        # tenant scope (match your index semantics)
+        if tenant_field and hasattr(Model, tenant_field):
+            tcol = getattr(Model, tenant_field)
+            tval = data.get(tenant_field)
+            if tval is None:
+                clauses.append(tcol.is_(None))
+            else:
+                clauses.append(tcol == tval)
+
+        # exclude the current row on update
+        if exclude_id is not None and hasattr(Model, "id"):
+            clauses.append(getattr(Model, "id") != exclude_id)
+
+        return clauses
+
+    async def _precheck(session, data: Dict[str, Any], *, exclude_id: Any | None) -> None:
+        # Check in deterministic order: CI specs, then CS specs
+        for ci, spec_list in ((True, unique_ci), (False, unique_cs)):
+            for spec in spec_list:
+                fields = _as_tuple(spec)
+                # only run if ALL fields (and tenant if used) are present in payload
+                needed = list(fields) + ([tenant_field] if tenant_field else [])
+                if not _all_present(data, needed):
+                    continue
+                where = _build_where_from_spec(data, fields, ci=ci, exclude_id=exclude_id)
+                if await repo.exists(session, where=where):
+                    msg = messages.get(fields) or f"Resource with {_nice_label(fields, data)} already exists."
+                    raise HTTPException(status_code=409, detail=msg)
+
+    class _Svc(ServiceWithHooks):
+        async def create(self, session, data):
+            data = await self.pre_create(data)
+            # Run prechecks — exclude_id=None on create
+            await _precheck(session, data, exclude_id=None)
+            try:
+                return await self.repo.create(session, data)
+            except IntegrityError as e:
+                # fall back to 409 for any of these uniqueness violations
+                raise HTTPException(status_code=409, detail="Resource already exists.") from e
+
+        async def update(self, session, id_value, data):
+            data = await self.pre_update(data)
+            # only run if payload contains some unique-relevant fields
+            await _precheck(session, data, exclude_id=id_value)
+            try:
+                return await self.repo.update(session, id_value, data)
+            except IntegrityError as e:
+                raise HTTPException(status_code=409, detail="Resource already exists.") from e
+
+    return _Svc(repo)

svc_infra-0.1.185/src/svc_infra/api/fastapi/db/uniq.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterable, Optional, Dict, Any, Callable
-from sqlalchemy import func, and_
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from .repository import Repository
-from svc_infra.db.uniq import ColumnSpec, _as_tuple
-
-def make_uniqueness_hooks(
-        *,
-        model: type,
-        repo: Repository,
-        unique_cs: Iterable[ColumnSpec] = (),
-        unique_ci: Iterable[ColumnSpec] = (),
-        tenant_field: Optional[str] = None,
-        duplicate_message: str = "Duplicate resource violates uniqueness policy.",
-) -> tuple[
-    Callable[[Dict[str, Any]], Any],  # async pre_create(data) -> data
-    Callable[[Dict[str, Any]], Any],  # async pre_update(data) -> data
-]:
-    """Return (pre_create, pre_update) hooks that check duplicates *before* insert/update.
-
-    Usage with ServiceWithHooks:
-        pre_c, pre_u = make_uniqueness_hooks(model=User, repo=repo, unique_ci=["email"], tenant_field="tenant_id")
-        svc = ServiceWithHooks(repo, pre_create=pre_c, pre_update=pre_u)
-    """
-    cs_specs = [_as_tuple(s) for s in unique_cs]
-    ci_specs = [_as_tuple(s) for s in unique_ci]
-
-    def _build_wheres(data: Dict[str, Any]):
-        wheres = []
-
-        def col(name: str):
-            return getattr(model, name)
-
-        tenant_val = data.get(tenant_field) if tenant_field else None
-
-        # case-sensitive groups
-        for spec in cs_specs:
-            if not all(k in data for k in spec):
-                continue
-            parts = []
-            if tenant_field:
-                parts.append(col(tenant_field).is_(None) if tenant_val is None else col(tenant_field) == tenant_val)
-            for k in spec:
-                parts.append(col(k) == data[k])
-            wheres.append(and_(*parts))
-
-        # case-insensitive groups
-        for spec in ci_specs:
-            if not all(k in data for k in spec):
-                continue
-            parts = []
-            if tenant_field:
-                parts.append(col(tenant_field).is_(None) if tenant_val is None else col(tenant_field) == tenant_val)
-            for k in spec:
-                # compare lower(db_col) == lower(<value>) safely
-                parts.append(func.lower(col(k)) == func.lower(func.cast(data[k], col(k).type)))
-            wheres.append(and_(*parts))
-
-        return wheres
-
-    async def _deferred_check(session: AsyncSession, data: Dict[str, Any]):
-        wheres = _build_wheres(data)
-        for where in wheres:
-            if await repo.exists(session, where=[where]):
-                from fastapi import HTTPException
-                raise HTTPException(status_code=409, detail=duplicate_message)
-
-    async def _pre_create(data: Dict[str, Any]) -> Dict[str, Any]:
-        # store a coroutine to be awaited when a session is available in Service.create
-        data = dict(data)
-        data.setdefault("__uniq_check__", _deferred_check)
-        return data
-
-    async def _pre_update(data: Dict[str, Any]) -> Dict[str, Any]:
-        data = dict(data)
-        data.setdefault("__uniq_check__", _deferred_check)
-        return data
-
-    return _pre_create, _pre_update

svc_infra-0.1.185/src/svc_infra/auth/__init__.py

@@ -1,7 +0,0 @@
-from .integration import enable_auth
-from .user_default import make_default_user_service
-
-__all__ = [
-    "enable_auth",
-    "make_default_user_service"
-]

svc_infra-0.1.185/src/svc_infra/auth/user_default.py

@@ -1,81 +0,0 @@
-from typing import Any, Dict
-from fastapi import HTTPException
-from fastapi_users.password import PasswordHelper
-from sqlalchemy import func
-
-from svc_infra.api.fastapi.db.service_hooks import ServiceWithHooks
-from svc_infra.api.fastapi.db.repository import Repository
-
-_pwd = PasswordHelper()
-
-def make_default_user_service(repo: Repository):
-    Model = repo.model  # <-- capture the actual mapped model from the repo
-
-    def _user_pre_create(data: Dict[str, Any]) -> Dict[str, Any]:
-        data = dict(data)
-        # normalize + map fields
-        if "password" in data:
-            data["password_hash"] = _pwd.hash(data.pop("password"))
-        if "metadata" in data:
-            data["extra"] = data.pop("metadata")
-        data.setdefault("roles", [])
-
-        # BEFORE insert: app-level guard (nice 409) aligned with DB uniqueness
-        email = data.get("email")
-        tenant_id = data.get("tenant_id")
-        if email is not None:
-            # case-insensitive email; scope by tenant (NULL => global)
-            where = [func.lower(Model.email) == func.lower(email)]
-            if hasattr(Model, "tenant_id"):
-                if tenant_id is None:
-                    where.append(Model.tenant_id.is_(None))
-                else:
-                    where.append(Model.tenant_id == tenant_id)
-
-            async def _exists(session):
-                return await repo.exists(session, where=where)
-
-            # stash the callback so Service.create can await it (has session)
-            data["_precreate_exists_check"] = _exists
-
-        return data
-
-    def _user_pre_update(data: Dict[str, Any]) -> Dict[str, Any]:
-        data = dict(data)
-        if "password" in data:
-            data["password_hash"] = _pwd.hash(data.pop("password"))
-        if "metadata" in data:
-            data["extra"] = data.pop("metadata")
-
-        # Optional: also protect email change from creating dupes
-        email = data.get("email")
-        tenant_id = data.get("tenant_id")
-        if email is not None:
-            where = [func.lower(Model.email) == func.lower(email)]
-            if hasattr(Model, "tenant_id"):
-                if tenant_id is None:
-                    where.append(Model.tenant_id.is_(None))
-                else:
-                    where.append(Model.tenant_id == tenant_id)
-
-            async def _exists(session):
-                return await repo.exists(session, where=where)
-
-            data["_precreate_exists_check"] = _exists  # reuse same key
-
-        return data
-
-    class _Svc(ServiceWithHooks):
-        async def create(self, session, data):
-            exists_cb = data.pop("_precreate_exists_check", None)
-            if exists_cb and await exists_cb(session):
-                raise HTTPException(status_code=409, detail="User with this email already exists.")
-            return await super().create(session, data)
-
-        async def update(self, session, id_value, data):
-            exists_cb = data.pop("_precreate_exists_check", None)
-            if exists_cb and await exists_cb(session):
-                raise HTTPException(status_code=409, detail="User with this email already exists.")
-            return await super().update(session, id_value, data)
-
-    return _Svc(repo, pre_create=_user_pre_create, pre_update=_user_pre_update)