simple-module-db 0.0.38__tar.gz → 0.0.40__tar.gz

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_db
-Version: 0.0.38
+Version: 0.0.40
 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
@@ -21,13 +21,13 @@ Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: aiosqlite>=0.20
-Requires-Dist: alembic>=1.14
-Requires-Dist: asyncpg>=0.30
-Requires-Dist: psycopg2-binary>=2.9
-Requires-Dist: simple-module-core==0.0.38
-Requires-Dist: sqlalchemy[asyncio]>=2.0
-Requires-Dist: sqlmodel>=0.0.22
+Requires-Dist: aiosqlite<0.23,>=0.20
+Requires-Dist: alembic<2,>=1.14
+Requires-Dist: asyncpg<0.33,>=0.30
+Requires-Dist: psycopg2-binary<3,>=2.9
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: sqlalchemy[asyncio]<3,>=2.0
+Requires-Dist: sqlmodel<0.1,>=0.0.22
 Description-Content-Type: text/markdown
 
 # simple_module_db

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.38"
+version = "0.0.40"
 description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -21,16 +21,16 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "aiosqlite>=0.20",
-    "alembic>=1.14",
-    "asyncpg>=0.30",
+    "aiosqlite>=0.20,<0.23",
+    "alembic>=1.14,<2",
+    "asyncpg>=0.30,<0.33",
     # psycopg2 is the *sync* Postgres driver Alembic uses for migrations.
     # The async app code goes through asyncpg; migration env.py rewrites the
     # URL to +psycopg2 because Alembic's online migrations are sync-only.
-    "psycopg2-binary>=2.9",
-    "simple_module_core==0.0.38",
-    "sqlalchemy[asyncio]>=2.0",
-    "sqlmodel>=0.0.22",
+    "psycopg2-binary>=2.9,<3",
+    "simple_module_core==0.0.40",
+    "sqlalchemy[asyncio]>=2.0,<3",
+    "sqlmodel>=0.0.22,<0.1",
 ]
 
 [project.urls]

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/audit.py

@@ -116,6 +116,23 @@ def _serialize(value: Any) -> Any:
     return str(value)
 
 
+def _column_diffs(
+    obj: object, inspector: Any, excl: frozenset[str], pk_cols: set[str]
+) -> list[dict[str, Any]]:
+    """Old/new diffs for the changed, non-excluded, non-PK columns of *obj*."""
+    changes: list[dict[str, Any]] = []
+    for col_name in _column_names(obj):
+        if col_name in excl or col_name in pk_cols:
+            continue
+        hist = inspector.attrs[col_name].history
+        if not hist.has_changes():
+            continue
+        old_val = hist.deleted[0] if hist.deleted else None
+        new_val = hist.added[0] if hist.added else None
+        changes.append({"field": col_name, "old": _serialize(old_val), "new": _serialize(new_val)})
+    return changes
+
+
 # ---------------------------------------------------------------------------
 # Two-phase capture
 # ---------------------------------------------------------------------------
@@ -155,21 +172,6 @@ def snapshot_changes(
         if _is_excluded(obj):
             continue
 
-        # Soft-delete listener moves objects from session.deleted → session.new
-        # with is_deleted=True.  Classify them as "soft_deleted", not "created".
-        if isinstance(obj, SoftDeleteMixin) and getattr(obj, "is_deleted", False):
-            pending.append(
-                _PendingChange(
-                    obj_ref=obj,
-                    entity_type=type(obj).__name__,
-                    action="soft_deleted",
-                    changes=[],
-                    user_id=user_id,
-                    correlation_id=correlation_id,
-                )
-            )
-            continue
-
         excl = _get_excluded(obj)
         pk_cols = _get_pk_cols(obj)
         changes: list[dict[str, Any]] = []
@@ -194,21 +196,26 @@ def snapshot_changes(
             continue
         if _is_excluded(obj):
             continue
-        excl = _get_excluded(obj)
-        pk_cols = _get_pk_cols(obj)
         inspector = sa_inspect(obj)
-        changes = []
-        for col_name in _column_names(obj):
-            if col_name in excl or col_name in pk_cols:
-                continue
-            hist = inspector.attrs[col_name].history
-            if not hist.has_changes():
-                continue
-            old_val = hist.deleted[0] if hist.deleted else None
-            new_val = hist.added[0] if hist.added else None
-            changes.append(
-                {"field": col_name, "old": _serialize(old_val), "new": _serialize(new_val)}
+        changes = _column_diffs(obj, inspector, _get_excluded(obj), _get_pk_cols(obj))
+        # The soft-delete listener re-adds persistent objects as dirty. Edits made in
+        # the same flush stay on the soft_deleted record.
+        if (
+            isinstance(obj, SoftDeleteMixin)
+            and obj.is_deleted
+            and inspector.attrs.is_deleted.history.has_changes()
+        ):
+            pending.append(
+                _PendingChange(
+                    obj_ref=obj,
+                    entity_type=type(obj).__name__,
+                    action="soft_deleted",
+                    changes=changes,
+                    user_id=user_id,
+                    correlation_id=correlation_id,
+                )
             )
+            continue
         if changes:
             pending.append(
                 _PendingChange(

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/callbacks.py

@@ -6,9 +6,12 @@ import inspect
 import logging
 from collections.abc import Awaitable, Callable
 
+from sqlalchemy import event
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session, SessionTransaction
 
 type OnCommitCallback = Callable[[], Awaitable[None] | None]
+type _CallbackEntry = tuple[set[SessionTransaction], OnCommitCallback]
 
 _CALLBACKS_KEY = "sm_db_on_commit_callbacks"
 logger = logging.getLogger("simple_module.db")
@@ -18,8 +21,27 @@ def register_on_commit(session: AsyncSession, callback: OnCommitCallback) -> Non
     """Queue ``callback`` for this session's next successful finalization."""
     if not callable(callback):
         raise TypeError("on_commit callback must be callable")
+    sync_session = session.sync_session
+    if not event.contains(sync_session, "after_soft_rollback", _discard_rolled_back_callbacks):
+        event.listen(sync_session, "after_soft_rollback", _discard_rolled_back_callbacks)
+    savepoints: set[SessionTransaction] = set()
+    transaction = sync_session.get_nested_transaction()
+    # Keep ancestors too: a released child still belongs to its parent's rollback.
+    while transaction is not None:
+        if transaction.nested:
+            savepoints.add(transaction)
+        transaction = transaction.parent
     callbacks = session.info.setdefault(_CALLBACKS_KEY, [])
-    callbacks.append(callback)
+    callbacks.append((savepoints, callback))
+
+
+def _discard_rolled_back_callbacks(session: Session, transaction: SessionTransaction) -> None:
+    if transaction.parent is None:
+        session.info.pop(_CALLBACKS_KEY, None)
+    elif transaction.nested and _CALLBACKS_KEY in session.info:
+        session.info[_CALLBACKS_KEY] = [
+            entry for entry in session.info[_CALLBACKS_KEY] if transaction not in entry[0]
+        ]
 
 
 def discard_on_commit_callbacks(session: AsyncSession) -> None:
@@ -34,8 +56,8 @@ async def run_on_commit_callbacks(session: AsyncSession) -> None:
     not turn a successful database mutation into a misleading failed response.
     Remaining callbacks still run.
     """
-    callbacks: list[OnCommitCallback] = session.info.pop(_CALLBACKS_KEY, [])
-    for callback in callbacks:
+    callbacks: list[_CallbackEntry] = session.info.pop(_CALLBACKS_KEY, [])
+    for _, callback in callbacks:
         try:
             result = callback()
             if inspect.isawaitable(result):

simple_module_db-0.0.40/simple_module_db/independent.py

@@ -0,0 +1,52 @@
+"""Short-lived durable transactions, independent of the request unit of work."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from simple_module_db.callbacks import discard_on_commit_callbacks, run_on_commit_callbacks
+from simple_module_db.session import SESSION_FACTORY_KEY, RequestSession
+
+
+@asynccontextmanager
+async def independent_session(source: Any) -> AsyncGenerator[RequestSession]:
+    """Commit an independent session on success; roll back and re-raise on error.
+
+    Accept an app or session factory. An existing session can also supply its
+    framework session factory; its pending work is never transferred.
+    Request code may use this for a deliberate durable checkpoint, whose writes
+    must survive a later request failure. The new session cannot see pending
+    request writes. Keep checkpoints short and avoid holding a write transaction
+    on the same database while opening one (especially on SQLite).
+
+    Post-commit callbacks run in registration order after the commit succeeds.
+    The session closes on every exit, including cancellation.
+    """
+    if isinstance(source, async_sessionmaker):
+        factory = source
+    elif isinstance(source, AsyncSession):
+        try:
+            factory = source.info[SESSION_FACTORY_KEY]
+        except KeyError:
+            raise TypeError(
+                "independent_session(session) needs a session opened by the framework's "
+                "session factory; pass the app or the async_sessionmaker instead"
+            ) from None
+    else:
+        factory = source.state.sm.db.session_factory
+    async with factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except BaseException as exc:
+            discard_on_commit_callbacks(session)
+            # Closing the session handles cancellation without masking it with
+            # another cancellable await; ordinary failures roll back explicitly.
+            if isinstance(exc, Exception):
+                await session.rollback()
+            raise
+        await run_on_commit_callbacks(session)

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/listeners.py

@@ -42,6 +42,7 @@ __all__ = [
 from simple_module_db.tenancy import TenantIsolationError, current_tenant_id
 
 logger = logging.getLogger(__name__)
+_entity_pk_failure_warned = False
 _db_logger = logging.getLogger("simple_module.db")
 
 # Set by auth middleware on each request
@@ -82,6 +83,10 @@ def _entity_pk(obj: object) -> object:
             return identity[0]
         return identity
     except Exception:
+        global _entity_pk_failure_warned
+        if not _entity_pk_failure_warned:
+            _entity_pk_failure_warned = True
+            logger.warning("Audit identity inspection failed; omitting primary key", exc_info=True)
         return None
 
 

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/query_filter.py

@@ -16,7 +16,7 @@ from collections.abc import Callable
 from typing import Any
 from weakref import WeakKeyDictionary
 
-from sqlalchemy.engine import Engine
+from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.orm import ORMExecuteState, Session, with_loader_criteria
 
 from simple_module_db import model_registry as registry
@@ -73,6 +73,8 @@ def bind_engine_policy(engine: Engine, policy: Any) -> None:
 def engine_policy(session: Session) -> Any:
     """The policy bound to this session's engine, or ``None``."""
     bind = session.bind
+    if isinstance(bind, Connection):
+        bind = bind.engine
     return _engine_policy.get(bind) if isinstance(bind, Engine) else None
 
 

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/session.py

@@ -19,6 +19,8 @@ from simple_module_db.engine_options import connect_args as timeout_connect_args
 from simple_module_db.provider import DatabaseProvider, detect_provider
 from simple_module_db.tenancy import DEFAULT_TENANT_ID
 
+SESSION_FACTORY_KEY = "sm_session_factory"
+
 
 class RequestSession(AsyncSession):
     """Async session with hooks for the request-owned transaction."""
@@ -135,6 +137,8 @@ def init_db(
         sync_session_class=scoped_session_class,
     )
 
+    session_factory.configure(info={SESSION_FACTORY_KEY: session_factory})
+
     return DatabaseState(
         engine=engine,
         session_factory=session_factory,

simple_module_db-0.0.40/simple_module_db/tenant_cleanup.py

@@ -0,0 +1,22 @@
+"""Durable teardown of framework-owned tenant settings, including branding."""
+
+from simple_module_core.durable_events import DurableContext
+from simple_module_core.events import EventBus
+from simple_module_core.tenant_events import TenantDeleted
+from sqlmodel import col, delete
+
+from simple_module_db.stored_settings import SCOPE_TENANT, Setting
+
+
+def register_tenant_cleanup(bus: EventBus) -> None:
+    """Register in both the host and workers, even without the settings plugin."""
+    bus.subscribe_durable(TenantDeleted, delete_tenant_settings)
+
+
+async def delete_tenant_settings(event: TenantDeleted, ctx: DurableContext) -> None:
+    """Hard-delete only this tenant's explicit overrides; safe on replay."""
+    await ctx.db.execute(
+        delete(Setting).where(
+            col(Setting.scope) == SCOPE_TENANT, col(Setting.scope_id) == event.tenant_id
+        )
+    )

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/simple_module_db/transaction.py

@@ -130,11 +130,13 @@ async def finalize_session(session: AsyncSession) -> None:
 async def rollback_session(session: AsyncSession) -> None:
     """Roll ``session`` back and drop its pending work. Idempotent."""
     discard_on_commit_callbacks(session)
-    if session.info.get(_FINALIZED_KEY) and not _has_pending(session):
+    has_pending = _has_pending(session)
+    if session.info.get(_FINALIZED_KEY) and not has_pending:
         return
     _settle(session)
     await session.rollback()
-    logger.warning(
+    logger.log(
+        logging.WARNING if has_pending else logging.DEBUG,
         "db.session.rollback",
         extra={"operation": "rollback", "db_duration_ms": _elapsed_ms(session)},
     )

simple_module_db-0.0.40/simple_module_db/user_directory_sql.py

@@ -0,0 +1,43 @@
+"""SQL-backed user directory helpers shared by account providers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from simple_module_core.user_directory import DirectoryUser
+from sqlalchemy import or_
+from sqlalchemy.sql.elements import ColumnElement
+
+from simple_module_db.search import LIKE_ESCAPE_CHAR, like_contains_pattern
+
+
+def name_or_email_contains(full_name: Any, email: Any, term: str) -> ColumnElement[bool]:
+    """Match a literal substring in either provider column, ignoring case."""
+    pattern = like_contains_pattern(term)
+    return or_(
+        full_name.ilike(pattern, escape=LIKE_ESCAPE_CHAR),
+        email.ilike(pattern, escape=LIKE_ESCAPE_CHAR),
+    )
+
+
+def to_directory_user(
+    row: Any,
+    key: str,
+    *,
+    roles: tuple[str, ...] | None = None,
+    is_active: bool = True,
+    email_verified: bool | None = None,
+) -> DirectoryUser:
+    """Convert identity columns, preserving unknown versus empty roles.
+
+    Providers supply account availability and roles when known. ``None`` means
+    unknown roles; an empty tuple means no assigned roles.
+    """
+    return DirectoryUser(
+        id=key,
+        email=row.email,
+        full_name=row.full_name,
+        is_active=is_active,
+        roles=roles,
+        email_verified=email_verified,
+    )

simple_module_db-0.0.40/tests/_db_shape_matrix.py

@@ -0,0 +1,44 @@
+"""Combined tenant/soft-delete probes shared by the statement families (#597)."""
+
+import pytest
+from _models import _tenant_session
+from simple_module_db.base import create_module_base
+from simple_module_db.mixins import MultiTenantMixin, SoftDeleteMixin
+from simple_module_db.tenancy import tenant_context
+from sqlmodel import Field
+
+Base = create_module_base("shape_matrix")
+
+
+class MatrixRow(Base, MultiTenantMixin, SoftDeleteMixin, table=True):  # ty: ignore[unsupported-base]
+    __tablename__ = "shape_matrix_row"
+    id: int = Field(primary_key=True)
+    name: str = "original"
+
+
+class MatrixAnchor(Base, table=True):  # ty: ignore[unsupported-base]
+    __tablename__ = "shape_matrix_anchor"
+    id: int = Field(primary_key=True)
+
+
+row, anchor = MatrixRow.__table__, MatrixAnchor.__table__
+
+
+async def seed(session):
+    session.add_all([MatrixAnchor(id=i) for i in range(1, 6)])
+    for tenant, ids in (("A", (1, 2)), ("B", (3, 4))):
+        with tenant_context(tenant):
+            session.add_all([MatrixRow(id=ids[0]), MatrixRow(id=ids[1], is_deleted=True)])
+            await session.flush()
+    await session.commit()
+
+
+@pytest.fixture(params=[False, True], ids=["tenant-off", "tenant-on"])
+async def matrix_session(request):
+    async for session in _tenant_session(Base.metadata, strict=request.param, seed=seed):
+        yield session
+
+
+def visible_ids(tenant, include_deleted):
+    ids = {"A": [1, 2], "B": [3, 4], None: [1, 2, 3, 4]}[tenant]
+    return ids if include_deleted else [i for i in ids if i % 2]

{simple_module_db-0.0.38 → simple_module_db-0.0.40}/tests/test_audit.py

@@ -18,21 +18,28 @@ from _audit_models import (
     PartialExcludeModel,
     SoftDeleteItem,
 )
+from simple_module_core.correlation import correlation_id
 from simple_module_db.audit import (
     AuditRecord,
     collect_audit_records,
     finalize_records,
     snapshot_changes,
 )
-from simple_module_db.listeners import register_listeners
+from simple_module_db.listeners import current_user_id, register_listeners
 from simple_module_db.session import init_db
 from sqlalchemy.ext.asyncio import AsyncSession
 
 
 @pytest.fixture
-async def audit_session() -> AsyncGenerator[AsyncSession, None]:
+def audit_records() -> list[AuditRecord]:
+    return []
+
+
+@pytest.fixture
+async def audit_session(audit_records: list[AuditRecord]) -> AsyncGenerator[AsyncSession, None]:
     """Session backed by in-memory SQLite with listeners registered."""
     db_state = init_db("sqlite+aiosqlite:///:memory:")
+    db_state.audit_callback = lambda session, records: audit_records.extend(records)
     try:
         register_listeners(db_state)
         async with db_state.engine.begin() as conn:
@@ -191,48 +198,48 @@ async def test_collect_records_for_update(audit_session: AsyncSession):
 # ── collect_audit_records: soft-deleted entity ────────────────────────────
 
 
+@pytest.mark.parametrize("change_title", [False, True])
 async def test_soft_deleted_entity_produces_soft_deleted_record(
     audit_session: AsyncSession,
+    audit_records: list[AuditRecord],
+    change_title: bool,
 ):
-    """A SoftDeleteMixin object re-added to session.new with is_deleted=True
-    should produce action='soft_deleted', not action='created'."""
+    """Deleting a persistent row emits one soft_deleted record, even with edits."""
     item = SoftDeleteItem(title="doomed")
     audit_session.add(item)
     await audit_session.commit()
     await audit_session.refresh(item)
 
-    # Simulate what the soft-delete listener does: expunge from deleted,
-    # set is_deleted=True, re-add to session.new.  We use make_transient
-    # so SQLAlchemy treats the re-added object as new (matching the
-    # session state that triggers Bug 1).
-    await audit_session.delete(item)
-
-    def _simulate_soft_delete(session):
-        from sqlalchemy.orm import make_transient
-
-        session.expunge(item)
-        item.is_deleted = True
-        make_transient(item)
-        session.add(item)
-
-    await audit_session.run_sync(_simulate_soft_delete)
-
-    records: list[AuditRecord] = []
-
-    def _collect(session):
-        records.extend(collect_audit_records(session, user_id="admin", correlation_id="req-sd"))
-
-    await audit_session.run_sync(_collect)
+    audit_records.clear()
+    if change_title:
+        item.title = "edited before deletion"
+    user_token = current_user_id.set("admin")
+    correlation_token = correlation_id.set("req-sd")
+    try:
+        await audit_session.delete(item)
+        await audit_session.flush()
+    finally:
+        current_user_id.reset(user_token)
+        correlation_id.reset(correlation_token)
 
-    assert len(records) == 1
-    rec = records[0]
+    assert item.is_deleted is True
+    [rec] = audit_records
     assert rec.action == "soft_deleted"
     assert rec.entity_type == "SoftDeleteItem"
     assert rec.entity_id == str(item.id)
-    assert rec.changes == []
+    if change_title:
+        assert rec.changes == [{"field": "title", "old": "doomed", "new": "edited before deletion"}]
+    else:
+        assert rec.changes == []
     assert rec.user_id == "admin"
     assert rec.correlation_id == "req-sd"
 
+    audit_records.clear()
+    item.title = "edited after deletion"
+    await audit_session.flush()
+    [rec] = audit_records
+    assert rec.action == "updated"
+
 
 # ── collect_audit_records: soft-delete fields excluded from diffs ─────────
 

simple_module_db-0.0.40/tests/test_db_connection_policy.py

@@ -0,0 +1,67 @@
+"""Connection-bound sessions retain their engine's tenancy and audit policy (#630)."""
+
+from collections.abc import Iterator
+
+import pytest
+from _audit_models import AuditTestItem
+from _models import _TenantItem
+from simple_module_db.audit import AuditRecord
+from simple_module_db.listeners import attach_session_listeners
+from simple_module_db.query_filter import EngineTenancy, bind_engine_policy
+from simple_module_db.tenancy import TenantIsolationError
+from sqlalchemy import create_engine, select
+from sqlalchemy.orm import Session
+
+
+@pytest.fixture
+def connection_session() -> Iterator[tuple[Session, list[AuditRecord]]]:
+    engine = create_engine("sqlite://")
+    records: list[AuditRecord] = []
+
+    def capture(session: Session, changes: list[AuditRecord]) -> None:
+        records.extend(changes)
+
+    class ConnectionSession(Session):
+        pass
+
+    attach_session_listeners(ConnectionSession)
+    bind_engine_policy(engine, EngineTenancy(tenant_strict=True, audit_callback=capture))
+    try:
+        _TenantItem.__table__.create(engine)
+        AuditTestItem.__table__.create(engine)
+        with engine.begin() as connection:
+            connection.execute(
+                _TenantItem.__table__.insert(),
+                [{"name": "row-a", "tenant_id": "a"}, {"name": "row-b", "tenant_id": "b"}],
+            )
+        with engine.connect() as connection, ConnectionSession(bind=connection) as session:
+            yield session, records
+    finally:
+        engine.dispose()
+
+
+def test_connection_bound_select_without_tenant_fails_closed(connection_session):
+    session, _records = connection_session
+    with pytest.raises(TenantIsolationError):
+        session.execute(select(_TenantItem)).all()
+
+
+def test_connection_bound_flush_without_tenant_fails_closed(connection_session):
+    session, _records = connection_session
+    session.add(_TenantItem(name="missing-tenant"))
+    with pytest.raises(TenantIsolationError):
+        session.flush()
+
+
+def test_connection_bound_flush_delivers_audit_records(connection_session):
+    session, records = connection_session
+    item = AuditTestItem(name="audited")
+    session.add(item)
+    session.flush()
+
+    [record] = records
+    assert (record.entity_type, record.action, record.entity_id) == (
+        "AuditTestItem",
+        "created",
+        str(item.id),
+    )