simple-module-db 0.0.2__tar.gz → 0.0.4__tar.gz

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/.gitignore

@@ -36,6 +36,10 @@ uploads/
 # Vite
 host/static/dist/
 
+# VitePress (docs)
+docs/.vitepress/cache/
+docs/.vitepress/dist/
+
 # Auto-generated frontend module manifest (regenerated by the host at boot
 # or via `make gen-pages`).
 host/client_app/modules.manifest.json

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_db
-Version: 0.0.2
+Version: 0.0.4
 Summary: Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -24,7 +24,7 @@ Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.20
 Requires-Dist: alembic>=1.14
 Requires-Dist: asyncpg>=0.30
-Requires-Dist: simple-module-core==0.0.2
+Requires-Dist: simple-module-core==0.0.4
 Requires-Dist: sqlalchemy[asyncio]>=2.0
 Requires-Dist: sqlmodel>=0.0.22
 Description-Content-Type: text/markdown

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.2"
+version = "0.0.4"
 description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -24,7 +24,7 @@ dependencies = [
     "aiosqlite>=0.20",
     "alembic>=1.14",
     "asyncpg>=0.30",
-    "simple_module_core==0.0.2",
+    "simple_module_core==0.0.4",
     "sqlalchemy[asyncio]>=2.0",
     "sqlmodel>=0.0.22",
 ]

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/simple_module_db/base.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 
+from simple_module_core.dotenv import env_bool
 from sqlalchemy import MetaData
 from sqlmodel import SQLModel
 
@@ -38,14 +39,35 @@ def _register_base(base: type[SQLModel]) -> None:
         all_module_bases.append(base)
 
 
-def _default_provider() -> DatabaseProvider:
-    """Resolve the active provider from ``SM_DATABASE_URL`` at import time.
+def _default_schema_policy() -> DatabaseProvider:
+    """Resolve the schema layout to register module tables under.
 
-    Falls back to SQLite when the variable is unset, keeping the common
-    dev-loop happy without requiring callers to plumb the provider through.
+    The :class:`DatabaseProvider` enum doubles as a *schema-layout*
+    selector here — ``POSTGRESQL`` means "give every module its own
+    schema (``orders.<table>``)", ``SQLITE`` means "shared public schema,
+    name-prefixed tables (``orders_<table>``)". The conflation is
+    deliberate so existing call sites keep working, but conceptually this
+    is "schema policy", not "what DB are we connecting to": you can run
+    Postgres with ``SM_SCHEMA_PER_MODULE=false`` to keep a flat layout.
+
+    Resolution order:
+      1. ``SM_SCHEMA_PER_MODULE`` (authoritative when set, decoupled from URL).
+      2. ``SM_DATABASE_URL`` (legacy fallback so deployments that haven't
+         migrated to the explicit knob keep working).
+      3. ``SQLITE`` (shared schema, the safe default).
     """
+    explicit = os.environ.get("SM_SCHEMA_PER_MODULE")
+    if explicit is not None:
+        return (
+            DatabaseProvider.POSTGRESQL
+            if env_bool("SM_SCHEMA_PER_MODULE")
+            else DatabaseProvider.SQLITE
+        )
+
     url = os.environ.get("SM_DATABASE_URL", "")
-    return detect_provider(url) if url else DatabaseProvider.SQLITE
+    if url:
+        return detect_provider(url)
+    return DatabaseProvider.SQLITE
 
 
 def create_module_base(
@@ -67,7 +89,7 @@ def create_module_base(
     concrete table classes declare ``table=True`` and inherit from it.
     """
     if provider is None:
-        provider = _default_provider()
+        provider = _default_schema_policy()
 
     cache_key = f"{module_name}:{provider}"
     if cache_key in _base_cache:

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/simple_module_db/migrations.py

@@ -17,8 +17,10 @@ from __future__ import annotations
 import importlib
 import logging
 from collections.abc import Callable, Sequence
+from enum import StrEnum
 from typing import Literal
 
+import sqlalchemy as sa
 from simple_module_core import ModuleBase
 from simple_module_core.discovery import discover_modules, get_module_package_name
 from sqlalchemy import MetaData
@@ -65,7 +67,11 @@ def build_module_metadata(modules: Sequence[ModuleBase] | None = None) -> MetaDa
     return combined
 
 
-def make_include_object(metadata: MetaData) -> IncludeObjectFn:
+def make_include_object(
+    metadata: MetaData,
+    *,
+    ignore_unmodeled_fks: bool = True,
+) -> IncludeObjectFn:
     """Return an Alembic ``include_object`` filter scoped to the module tables.
 
     Call as ``context.configure(..., include_object=make_include_object(meta))``.
@@ -73,6 +79,15 @@ def make_include_object(metadata: MetaData) -> IncludeObjectFn:
     autogenerate from diffing — and potentially dropping — tables that exist
     in the database but aren't owned by any installed module (e.g. a user
     table added by the host developer outside the module system).
+
+    :param ignore_unmodeled_fks: When ``True`` (default), foreign-key
+        constraints that exist in the live DB but are absent from the SQLModel
+        metadata are skipped instead of being emitted as ``op.drop_constraint``
+        in the autogenerated migration. The framework's recommended pattern
+        declares cross-module FKs at the migration level only (no Python-level
+        relationship between modules), so those constraints look "unmodeled" to
+        Alembic on every autogen run and would otherwise be silently dropped.
+        Set to ``False`` to recover the prior, drop-on-sight behaviour.
     """
     allowlist = {t.name for t in metadata.tables.values()}
 
@@ -85,6 +100,8 @@ def make_include_object(metadata: MetaData) -> IncludeObjectFn:
     ) -> bool:
         if type_ == "table":
             return name in allowlist
+        if ignore_unmodeled_fks and type_ == "foreign_key_constraint" and compare_to is None:
+            return False
         parent_table = getattr(object, "table", None)
         if parent_table is not None:
             return parent_table.name in allowlist
@@ -94,19 +111,45 @@ def make_include_object(metadata: MetaData) -> IncludeObjectFn:
 
 
 def render_item(type_, obj, autogen_context):
-    """Alembic ``render_item`` callback that collapses SQLModel's ``AutoString``.
-
-    Without this, autogenerate emits ``sqlmodel.sql.sqltypes.AutoString(...)``
-    in generated migrations but does not add the corresponding
-    ``import sqlmodel``, so the migration fails with ``NameError`` on apply.
-    ``AutoString`` is a thin wrapper over ``String``, so collapsing it here
-    keeps migrations self-contained without losing semantics.
+    """Alembic ``render_item`` callback for SQLModel + extension types.
+
+    * Collapses SQLModel's ``AutoString`` to ``sa.String`` so migrations don't
+      need to ``import sqlmodel``.
+    * Renders Python ``StrEnum`` columns with ``values_callable`` so the
+      Postgres enum labels match the lowercase ``StrEnum`` values rather than
+      SQLAlchemy's default of using uppercase attribute names. This means raw
+      SQL like ``WHERE status = 'ready'`` actually works against the live DB.
+    * Adds the necessary imports for ``fastapi_users_db_sqlalchemy.generics``
+      and ``geoalchemy2`` types (rendered by their own classes elsewhere) so
+      the generated migration is importable.
 
     Pass to :func:`alembic.context.configure` as ``render_item=render_item``.
     """
-    if type_ == "type" and type(obj).__name__ == "AutoString":
+    if type_ != "type":
+        return False
+    cls_name = type(obj).__name__
+    cls_module = type(obj).__module__ or ""
+    imports = autogen_context.imports if autogen_context is not None else None
+
+    if cls_name == "AutoString":
         length = getattr(obj, "length", None)
-        if length is not None:
-            return f"sa.String(length={length})"
-        return "sa.String()"
+        return f"sa.String(length={length})" if length is not None else "sa.String()"
+
+    if imports is not None and cls_module.startswith("fastapi_users_db_sqlalchemy"):
+        imports.add("import fastapi_users_db_sqlalchemy.generics")
+    if imports is not None and cls_module.startswith("geoalchemy2"):
+        imports.add("import geoalchemy2")
+
+    # Match by isinstance, not class-name string — a user-defined ``Enum``
+    # class elsewhere in the project would otherwise be matched here and
+    # render with ``values_callable`` against an unrelated ``enum_class``.
+    if isinstance(obj, sa.Enum):
+        python_type = getattr(obj, "enum_class", None)
+        if isinstance(python_type, type) and issubclass(python_type, StrEnum):
+            name = getattr(obj, "name", None) or python_type.__name__.lower()
+            members = ", ".join(repr(m.value) for m in python_type)
+            return (
+                f"sa.Enum({members}, name={name!r}, values_callable=lambda e: [m.value for m in e])"
+            )
+
     return False  # let alembic use its default rendering

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/simple_module_db/mixins.py

@@ -8,20 +8,30 @@ SQLModel constructs a fresh ``Column`` per concrete subclass; sharing a single
 
 from __future__ import annotations
 
-from datetime import datetime
+from datetime import UTC, datetime
 
 from sqlalchemy import DateTime, func
 from sqlmodel import Field, SQLModel
 
 
+def _utcnow() -> datetime:
+    """Timezone-aware UTC ``now`` for the Python-side default of ``created_at``."""
+    return datetime.now(UTC)
+
+
 class AuditMixin(SQLModel):
     """Adds created_at, updated_at, created_by, updated_by fields.
 
-    ``created_at`` gets a server-side default; ``updated_at`` is populated by
-    the audit listener in :mod:`simple_module_db.listeners`.
+    ``created_at`` is populated both Python-side (``default_factory``) and
+    server-side (``server_default``) so freshly-instantiated instances can
+    be serialized before flush — without the Python default, accessing
+    ``obj.created_at`` raised ``AttributeError`` until the row hit the DB.
+    ``updated_at`` is populated by the audit listener in
+    :mod:`simple_module_db.listeners`.
     """
 
     created_at: datetime = Field(
+        default_factory=_utcnow,
         sa_type=DateTime(timezone=True),
         sa_column_kwargs={"server_default": func.now()},
     )
@@ -51,9 +61,23 @@ class SoftDeleteMixin(SQLModel):
 
 
 class MultiTenantMixin(SQLModel):
-    """Adds a tenant_id column for data isolation in multi-tenant apps."""
+    """Adds a tenant_id column for data isolation in multi-tenant apps.
+
+    The Python-side type is optional so callers can construct an instance
+    inside a request scope without explicitly threading the tenant through —
+    the ``_before_flush_listener`` in :mod:`simple_module_db.listeners`
+    populates it from the ``current_tenant_id`` contextvar before the row
+    reaches the DB. The column itself is non-nullable, so a row inserted
+    outside any tenant context fails loudly at the DB rather than silently
+    leaking across tenants.
+    """
 
-    tenant_id: str = Field(max_length=50, index=True)
+    tenant_id: str | None = Field(
+        default=None,
+        max_length=50,
+        index=True,
+        sa_column_kwargs={"nullable": False},
+    )
 
 
 class VersionedMixin(SQLModel):

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/simple_module_db/session.py

@@ -33,12 +33,15 @@ def init_db(
     max_overflow: int = 20,
     pool_pre_ping: bool = True,
     pool_recycle: int = 1800,
+    poolclass: type | None = None,
 ) -> DatabaseState:
     """Create an async engine and session factory.
 
-    The pool options only take effect for server-side providers (Postgres).
-    SQLite uses SQLAlchemy's default pool (single-file, no network), so
-    passing ``pool_size``/etc. would raise ``TypeError`` — skipped below.
+    Pool tuning only applies to server-side providers (Postgres) — SQLite
+    rejects ``pool_size``/etc. Pass ``poolclass=NullPool`` from test
+    fixtures running against asyncpg/Postgres so pytest-asyncio's per-test
+    event loops don't outlive pooled connections; the pool-tuning kwargs
+    are ignored in that case.
 
     Returns a ``DatabaseState`` that should be stored on ``app.state.db``.
     """
@@ -46,9 +49,11 @@ def init_db(
 
     connect_args: dict = {}
     engine_kwargs: dict = {"echo": echo, "connect_args": connect_args}
+    if poolclass is not None:
+        engine_kwargs["poolclass"] = poolclass
     if provider == DatabaseProvider.SQLITE:
         connect_args["check_same_thread"] = False
-    else:
+    elif poolclass is None:
         engine_kwargs.update(
             pool_size=pool_size,
             max_overflow=max_overflow,

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/tests/test_db_logging.py

@@ -4,12 +4,10 @@ from __future__ import annotations
 
 import contextlib
 import logging
-from decimal import Decimal
 from unittest.mock import MagicMock
 
 from _models import _TenantBase, _TenantItem
 from simple_module_db.deps import get_db
-from sqlalchemy.ext.asyncio import AsyncSession
 
 
 async def _drive_get_db(db_state, populate=None):
@@ -82,47 +80,3 @@ class TestGetDbLogging:
         read_only = [r for r in records if r.message == "db.session.read_only"]
         assert len(read_only) == 1
         assert read_only[0].operation == "read_only_rollback"  # type: ignore[attr-defined]
-
-
-class TestEntityListenerLogging:
-    async def test_create_logs_entity_created(self, db_session: AsyncSession, caplog):
-        """Inserting a new entity should log db.entity.created."""
-        from products.models import Product
-
-        with caplog.at_level(logging.INFO, logger="simple_module.db"):
-            product = Product(name="Widget", price=Decimal("9.99"))
-            db_session.add(product)
-            await db_session.flush()
-
-        created_msgs = [
-            r
-            for r in caplog.records
-            if r.name == "simple_module.db" and r.message == "db.entity.created"
-        ]
-        assert len(created_msgs) == 1
-        assert created_msgs[0].entity == "Product"  # type: ignore[attr-defined]
-        assert created_msgs[0].operation == "create"  # type: ignore[attr-defined]
-
-    async def test_update_logs_entity_updated(self, db_session: AsyncSession, caplog):
-        """Modifying an entity should log db.entity.updated."""
-        from products.models import Product
-
-        product = Product(name="Widget", price=Decimal("9.99"))
-        db_session.add(product)
-        await db_session.flush()
-
-        caplog.clear()
-
-        product.name = "Updated Widget"
-        with caplog.at_level(logging.INFO, logger="simple_module.db"):
-            await db_session.flush()
-
-        updated_msgs = [
-            r
-            for r in caplog.records
-            if r.name == "simple_module.db" and r.message == "db.entity.updated"
-        ]
-        assert len(updated_msgs) == 1
-        assert updated_msgs[0].entity == "Product"  # type: ignore[attr-defined]
-        assert updated_msgs[0].operation == "update"  # type: ignore[attr-defined]
-        assert updated_msgs[0].entity_id is not None  # type: ignore[attr-defined]

{simple_module_db-0.0.2 → simple_module_db-0.0.4}/tests/test_migrations.py

@@ -17,10 +17,10 @@ class TestMigrationsHelper:
         metadata = build_module_metadata()
         table_names = set(metadata.tables.keys())
 
-        # Products ships models and must contribute at least one table.
+        # Users ships models and must contribute at least one table.
         # (Dashboard is event-driven with no models; Auth's tables are
         # currently not part of this workspace's ORM surface.)
-        assert any("product" in name.lower() for name in table_names)
+        assert any("user" in name.lower() for name in table_names)
         assert len(table_names) >= 1
 
     async def test_combined_metadata_only_returns_module_tables(self):
@@ -54,3 +54,42 @@ class TestMigrationsHelper:
             "unrelated_host_table", MetaData(), Column("id", Integer, primary_key=True)
         )
         assert include(stranger, "unrelated_host_table", "table", False, None) is False
+
+    async def test_include_object_skips_unmodeled_cross_module_fks_by_default(self):
+        """Cross-module FKs declared at the migration level only (no SQLModel
+        relationship) appear in the live DB but never in target metadata.
+        Alembic passes ``compare_to=None`` for live-only constraints and would
+        emit ``op.drop_constraint``; the default filter must drop those
+        constraint-level diffs to avoid destroying real FKs on every autogen.
+        """
+        from simple_module_db.migrations import build_module_metadata, make_include_object
+        from sqlalchemy import Column, ForeignKeyConstraint, Integer, MetaData, Table
+
+        metadata = build_module_metadata()
+        include = make_include_object(metadata)
+        strict = make_include_object(metadata, ignore_unmodeled_fks=False)
+
+        known = next(iter(metadata.tables.values()))
+        scratch = MetaData()
+        local = Table(known.name, scratch, Column("id", Integer, primary_key=True))
+        fk = ForeignKeyConstraint([local.c.id], ["other_module.other.id"], name="fk_xmod")
+        local.append_constraint(fk)
+
+        assert include(fk, "fk_xmod", "foreign_key_constraint", True, None) is False
+        assert strict(fk, "fk_xmod", "foreign_key_constraint", True, None) is True
+
+        stranger_meta = MetaData()
+        stranger = Table(
+            "totally_unknown_table",
+            stranger_meta,
+            Column("id", Integer, primary_key=True),
+            Column("ref", Integer),
+        )
+        stranger_fk = ForeignKeyConstraint(
+            [stranger.c.ref], ["something.else.id"], name="fk_stranger"
+        )
+        stranger.append_constraint(stranger_fk)
+        assert (
+            include(stranger_fk, "fk_stranger", "foreign_key_constraint", False, stranger_fk)
+            is False
+        )