svc-infra 0.1.181__tar.gz → 0.1.183__tar.gz

{svc_infra-0.1.181 → svc_infra-0.1.183}/PKG-INFO

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

{svc_infra-0.1.181 → svc_infra-0.1.183}/pyproject.toml

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

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

@@ -0,0 +1,53 @@
+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 _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")
+
+    # BEFORE insert: application-level guard (nice error)
+    # case-insensitive email; handle tenant/null logic the same way as your unique index
+    email = data.get("email")
+    tenant_id = data.get("tenant_id")
+    if email:
+        where = [func.lower(Repository.model.email) == func.lower(email)]
+        if tenant_id is None:
+            where.append(Repository.model.tenant_id.is_(None))
+        else:
+            where.append(Repository.model.tenant_id == tenant_id)
+
+        # use a small “exists” helper on the repo if you have it
+        async def _exists(session):
+            return await Repository.exists(session, where=where)
+
+        data["_precreate_exists_check"] = _exists  # stash callable for service.create to run
+
+    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
+
+def make_default_user_service(repo: Repository):
+    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)
+    return _Svc(repo, pre_create=_user_pre_create, pre_update=_user_pre_update)

{svc_infra-0.1.181 → svc_infra-0.1.183}/src/svc_infra/db/templates/models_schemas/auth/models.py.tmpl

@@ -4,14 +4,16 @@ from typing import Optional
 import uuid
 
 from sqlalchemy import (
-    String, Boolean, DateTime, JSON, Text, func, UniqueConstraint, Index
+    String, Boolean, DateTime, JSON, Text, func, Index
 )
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy.ext.mutable import MutableDict, MutableList  # <-- add
+from sqlalchemy.ext.mutable import MutableDict, MutableList
 
 from svc_infra.db.base import ModelBase
 from svc_infra.auth.user_default import _pwd
+from svc_infra.db.uniq import make_unique_indexes
+
 
 class User(ModelBase):
     __tablename__ = "users"
@@ -24,10 +26,12 @@ class User(ModelBase):
     is_superuser: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
     is_verified: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
 
+    # auth state
     password_hash: Mapped[str] = mapped_column(String(512), nullable=False)
 
+    # Write-only facade over password
     @property
-    def password(self) -> str:  # never readable
+    def password(self) -> str:
         raise AttributeError("password is write-only")
 
     @password.setter
@@ -53,12 +57,16 @@ class User(ModelBase):
         DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False
     )
 
-    __table_args__ = (
-        UniqueConstraint("tenant_id", "email", name="uq_users_tenant_email"),
-    )
-
     def __repr__(self) -> str:
         return f"<User id={self.id} email={self.email!r}>"
 
-# define functional index *after* class definition
-Index("ix_users_email_lower", func.lower(User.email))
+
+# Unique indexes, including case-insensitive and/or tenant-scoped.
+for _ix in make_unique_indexes(
+    User,
+    unique_ci=["email"],            # case-insensitive unique email
+    tenant_field="tenant_id",       # scoped by tenant if provided
+):
+    # Simply iterating keeps them registered with the Table metadata.
+    # (No further action needed if you use Alembic autogenerate or metadata.create_all.)
+    pass

svc_infra-0.1.183/src/svc_infra/db/templates/models_schemas/entity/models.py.tmpl

@@ -0,0 +1,52 @@
+# models/${table_name}.py
+from __future__ import annotations
+from datetime import datetime
+from typing import Optional
+import uuid
+
+from sqlalchemy import String, Boolean, DateTime, JSON, Text, func
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.ext.mutable import MutableDict
+
+from svc_infra.db.base import ModelBase
+from svc_infra.db.uniq import make_unique_indexes
+
+
+class ${Entity}(ModelBase):
+    __tablename__ = "${table_name}"
+
+    # identity
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+    # core fields
+    name: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    description: Mapped[Optional[str]] = mapped_column(Text)
+
+${tenant_field}\
+${soft_delete_field}\
+    # misc (avoid attr name "metadata" clash)
+    extra: Mapped[dict] = mapped_column(MutableDict.as_mutable(JSON), default=dict)
+
+    # auditing (DB-side timestamps)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False
+    )
+
+    def __repr__(self) -> str:
+        return f"<${Entity} id={self.id} name={self.name!r}>"
+
+
+# --- Uniqueness policy --------------------------------------------------------
+# Register functional unique indexes (case-insensitive on "name"),
+# optionally scoped by tenant if present.
+for _ix in make_unique_indexes(
+    ${Entity},
+    unique_ci=["name"]${tenant_arg}
+):
+    # Iteration is enough to attach them to the Table metadata
+    # (Alembic autogenerate / metadata.create_all will pick them up)
+    pass

svc_infra-0.1.183/src/svc_infra/db/uniq.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+from typing import Iterable, Sequence, Tuple, Union, List, Optional
+from sqlalchemy import Index, func
+
+
+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 make_unique_indexes(
+        model: type,
+        *,
+        # Case-sensitive uniqueness specs (exact match)
+        unique_cs: Iterable[ColumnSpec] = (),
+        # Case-insensitive uniqueness specs: lower() applied to string columns
+        unique_ci: Iterable[ColumnSpec] = (),
+        # Optional tenant scoping (e.g. "tenant_id"). If provided:
+        #   - when tenant is NULL -> global uniqueness
+        #   - when tenant is NOT NULL -> uniqueness within tenant
+        tenant_field: Optional[str] = None,
+        # Prefix for index names
+        name_prefix: str = "uq",
+) -> List[Index]:
+    """
+    Returns a list of SQLAlchemy Index objects enforcing uniqueness.
+
+    Notes:
+    - For case-insensitive specs, we use functional unique indexes with lower(col).
+    - If tenant_field is given and the tenant column is nullable, we generate two partial
+      unique indexes: one for tenant IS NULL (global), one for tenant IS NOT NULL (scoped).
+    - Attach these indexes after your model class definition, before migrations/DDL run:
+        Indexes = make_unique_indexes(User, unique_ci=["email"], tenant_field="tenant_id")
+        for ix in Indexes:
+            ix.create(model.metadata.bind)  # OR just rely on Alembic autogenerate / metadata.create_all
+      Most apps just *define* them at module import time:
+        for ix in Indexes:  # they auto-register with the Table; no manual create() needed
+            pass
+    """
+    idxs: List[Index] = []
+
+    def _col(name: str):
+        return getattr(model, name)
+
+    def _to_sa_cols(spec: Tuple[str, ...], *, ci: bool):
+        cols = []
+        for cname in spec:
+            c = _col(cname)
+            cols.append(func.lower(c) if ci else c)
+        return tuple(cols)
+
+    tenant_col = _col(tenant_field) if tenant_field else None
+
+    # Helper: name like uq_<table>_<tenant?>_<ci/cs>_<joined-columns>
+    def _name(ci: bool, spec: Tuple[str, ...], null_bucket: Optional[str] = None):
+        parts = [name_prefix, model.__tablename__]
+        if tenant_field:
+            parts.append(tenant_field)
+        if null_bucket:
+            parts.append(null_bucket)
+        parts.append("ci" if ci else "cs")
+        parts.extend(spec)
+        return "_".join(parts)
+
+    # Build indexes for both CS and CI specs
+    for ci, spec_list in ((False, unique_cs), (True, unique_ci)):
+        for spec in spec_list:
+            spec_t = _as_tuple(spec)
+            cols = _to_sa_cols(spec_t, ci=ci)
+
+            if tenant_col is None:
+                # simple global unique (with or without lower())
+                idxs.append(Index(_name(ci, spec_t), *cols, unique=True))
+            else:
+                # two partial unique indexes to treat NULL tenant as its own bucket
+                # 1) global bucket (tenant IS NULL)
+                idxs.append(
+                    Index(
+                        _name(ci, spec_t, "null"),
+                        *cols,
+                        unique=True,
+                        postgresql_where=tenant_col.is_(None),
+                    )
+                )
+                # 2) per-tenant bucket (tenant IS NOT NULL)
+                idxs.append(
+                    Index(
+                        _name(ci, spec_t, "notnull"),
+                        tenant_col,
+                        *cols,
+                        unique=True,
+                        postgresql_where=tenant_col.isnot(None),
+                    )
+                )
+
+    return idxs

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

@@ -1,27 +0,0 @@
-from typing import Any, Dict
-from fastapi_users.password import PasswordHelper
-
-from svc_infra.api.fastapi.db.service_hooks import ServiceWithHooks
-from svc_infra.api.fastapi.db.repository import Repository
-
-_pwd = PasswordHelper()
-
-def _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:   # pydantic alias -> model column "metadata" (extra)
-        data["extra"] = data.pop("metadata")
-    data.setdefault("roles", [])
-    return data
-
-def _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
-
-def make_default_user_service(repo: Repository):
-    return ServiceWithHooks(repo, pre_create=_pre_create, pre_update=_pre_update)

svc_infra-0.1.181/src/svc_infra/db/templates/models_schemas/entity/models.py.tmpl

@@ -1,29 +0,0 @@
-from __future__ import annotations
-from datetime import datetime
-from typing import Optional
-import uuid
-
-from sqlalchemy import String, Boolean, DateTime, JSON, Text, func, UniqueConstraint, Index
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy.ext.mutable import MutableDict
-
-from svc_infra.db.base import ModelBase
-
-
-class ${Entity}(ModelBase):
-    __tablename__ = "${table_name}"
-
-    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    name: Mapped[str] = mapped_column(String(255), nullable=False)
-    description: Mapped[Optional[str]] = mapped_column(Text)
-
-${tenant_field}${soft_delete_field}    extra: Mapped[dict] = mapped_column(MutableDict.as_mutable(JSON), default=dict)
-
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
-    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
-
-${constraints}    def __repr__(self) -> str:
-        return f"<${Entity} id={self.id} name={self.name!r}>"
-
-${indexes}