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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_db
-Version: 0.0.38
+Version: 0.0.39
 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.39
+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.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.38"
+version = "0.0.39"
 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.39",
+    "sqlalchemy[asyncio]>=2.0,<3",
+    "sqlmodel>=0.0.22,<0.1",
 ]
 
 [project.urls]

simple_module_db-0.0.39/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.39}/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.39}/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.39/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.39}/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.39/simple_module_db/user_directory_sql.py

@@ -0,0 +1,41 @@
+"""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,
+) -> 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,
+    )

simple_module_db-0.0.39/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.39/tests/test_db_independent_checkpoint.py

@@ -0,0 +1,72 @@
+"""Independent checkpoints own their transaction and post-commit callbacks."""
+
+from types import SimpleNamespace
+
+import pytest
+from simple_module_db import independent_session
+from sqlalchemy import text
+
+
+@pytest.fixture
+async def checkpoint_db(db_state):
+    async with db_state.engine.begin() as connection:
+        await connection.execute(text("CREATE TABLE checkpoint_row (id integer primary key)"))
+    yield db_state
+    async with db_state.engine.begin() as connection:
+        await connection.execute(text("DROP TABLE checkpoint_row"))
+
+
+async def test_factory_checkpoint_runs_callbacks_after_durable_commit(checkpoint_db):
+    observed = []
+
+    async def observe():
+        async with checkpoint_db.session_factory() as reader:
+            observed.append((await reader.execute(text("SELECT id FROM checkpoint_row"))).scalar())
+
+    async with independent_session(checkpoint_db.session_factory) as session:
+        await session.execute(text("INSERT INTO checkpoint_row VALUES (1)"))
+        session.on_commit(observe)
+        session.on_commit(lambda: observed.append("second"))
+    assert observed == [1, "second"]
+
+
+async def test_app_checkpoint_discards_callbacks_on_failure(checkpoint_db):
+    app = SimpleNamespace(state=SimpleNamespace(sm=SimpleNamespace(db=checkpoint_db)))
+    observed = []
+    with pytest.raises(RuntimeError, match="abort"):
+        async with independent_session(app) as session:
+            await session.execute(text("INSERT INTO checkpoint_row VALUES (1)"))
+            session.on_commit(lambda: observed.append("committed"))
+            raise RuntimeError("abort")
+    assert observed == []
+    async with checkpoint_db.session_factory() as reader:
+        assert (await reader.execute(text("SELECT count(*) FROM checkpoint_row"))).scalar() == 0
+
+
+async def test_session_checkpoint_leaves_request_work_and_callbacks_uncommitted(tmp_path):
+    from simple_module_db import init_db
+    from sqlmodel import Field, SQLModel
+
+    class CheckpointRow(SQLModel, table=True):
+        __tablename__ = "db_checkpoint_isolation"
+        id: int = Field(primary_key=True)
+
+    state = init_db(f"sqlite+aiosqlite:///{tmp_path / 'checkpoint.db'}")
+    observed = []
+    try:
+        async with state.engine.begin() as connection:
+            await connection.run_sync(CheckpointRow.__table__.create)
+        async with state.session_factory() as request:
+            request.add(CheckpointRow(id=1))
+            request.on_commit(lambda: observed.append("request"))
+            async with independent_session(request) as checkpoint:
+                assert checkpoint is not request
+                checkpoint.add(CheckpointRow(id=2))
+                checkpoint.on_commit(lambda: observed.append("checkpoint"))
+            assert observed == ["checkpoint"]
+            await request.rollback()
+        async with state.session_factory() as reader:
+            rows = (await reader.execute(text("SELECT id FROM db_checkpoint_isolation"))).scalars()
+            assert list(rows) == [2]
+    finally:
+        await state.engine.dispose()

simple_module_db-0.0.39/tests/test_db_shape_matrix_dml.py

@@ -0,0 +1,35 @@
+"""Bulk DML scopes tenants but intentionally includes trashed targets (#597)."""
+
+import pytest
+from _db_shape_matrix import matrix_session, row, visible_ids
+from simple_module_db.query_filter import strict_configured
+from simple_module_db.tenancy import TenantIsolationError, no_tenant, tenant_context
+from sqlalchemy import delete, select, update
+
+__all__ = ["matrix_session"]
+
+
+@pytest.mark.parametrize("operation", ["update", "delete"])
+@pytest.mark.parametrize("tenant", ["A", "B", None])
+@pytest.mark.parametrize("include_deleted", [False, True])
+async def test_dml_matrix(matrix_session, operation, tenant, include_deleted):
+    stmt = update(row).values(name="changed") if operation == "update" else delete(row)
+    stmt = stmt.execution_options(include_deleted=include_deleted)
+    with no_tenant() if tenant is None else tenant_context(tenant):
+        if tenant is None and strict_configured(matrix_session.sync_session):
+            with pytest.raises(TenantIsolationError):
+                await matrix_session.execute(stmt)
+            affected = []
+        else:
+            result = await matrix_session.execute(stmt)
+            affected = visible_ids(tenant, True)
+            assert result.rowcount == len(affected)
+    # Bypass both filters to prove *which* rows changed, including foreign/deleted rows.
+    inspect = select(row.c.id, row.c.name).execution_options(all_tenants=True, include_deleted=True)
+    actual = sorted((await matrix_session.execute(inspect)).all())
+    expected = [
+        (i, "changed" if i in affected else "original")
+        for i in range(1, 5)
+        if operation == "update" or i not in affected
+    ]
+    assert actual == expected

simple_module_db-0.0.39/tests/test_db_shape_matrix_joins.py

@@ -0,0 +1,55 @@
+"""Join predicates must filter nullable rows without losing their anchors (#597)."""
+
+import pytest
+from _db_shape_matrix import anchor, matrix_session, row, visible_ids
+from simple_module_db._core_joins import scope_joins
+from simple_module_db.query_filter import strict_configured
+from simple_module_db.tenancy import TenantIsolationError, no_tenant, tenant_context
+from sqlalchemy import select
+
+__all__ = ["matrix_session"]
+
+
+@pytest.mark.parametrize("outer", [False, True], ids=["join", "outerjoin"])
+@pytest.mark.parametrize("setup", [False, True], ids=["explicit", "setup"])
+@pytest.mark.parametrize("tenant", ["A", "B", None])
+@pytest.mark.parametrize("include_deleted", [False, True])
+async def test_join_matrix(matrix_session, outer, setup, tenant, include_deleted):
+    on = row.c.id == anchor.c.id
+    stmt = select(anchor.c.id, row.c.id)
+    if setup:
+        stmt = stmt.select_from(anchor).join(row, on, isouter=outer)
+    else:
+        stmt = stmt.select_from(anchor.join(row, on, isouter=outer))
+    stmt = stmt.execution_options(include_deleted=include_deleted)
+    with no_tenant() if tenant is None else tenant_context(tenant):
+        if tenant is None and strict_configured(matrix_session.sync_session):
+            with pytest.raises(TenantIsolationError):
+                await matrix_session.execute(stmt)
+        else:
+            visible = visible_ids(tenant, include_deleted)
+            expected = (
+                [(i, i if i in visible else None) for i in range(1, 6)]
+                if outer
+                else [(i, i) for i in visible]
+            )
+            assert sorted((await matrix_session.execute(stmt)).all()) == expected
+
+
+@pytest.mark.parametrize("outer", [False, True])
+def test_scope_joins_places_nullable_predicate_in_on(outer):
+    stmt = select(anchor.c.id, row.c.id).select_from(
+        anchor.join(row, anchor.c.id == row.c.id, isouter=outer)
+    )
+    scoped = scope_joins(
+        stmt, lambda table: [table.c.is_deleted.is_(False)] if table is row else []
+    )
+    assert scoped.covered == [row]
+    assert bool(scoped.where) is (not outer)
+    rewritten = stmt._generate()
+    rewritten._from_obj = scoped.from_obj
+    rewritten = rewritten.where(*scoped.where)
+    sql = str(rewritten)
+    before_where, _, where = sql.partition("WHERE")
+    assert ("is_deleted" in before_where) is outer
+    assert ("is_deleted" in where) is (not outer)

simple_module_db-0.0.39/tests/test_db_shape_matrix_selects.py

@@ -0,0 +1,58 @@
+"""Select/walk matrix, using the same fixture on SQLite and Postgres (#597)."""
+
+import pytest
+from _db_shape_matrix import MatrixRow, anchor, matrix_session, row, visible_ids
+from simple_module_db._core_walk import references_plain
+from simple_module_db.query_filter import strict_configured
+from simple_module_db.tenancy import TenantIsolationError, no_tenant, tenant_context
+from sqlalchemy import delete, exists, select, union, update
+
+__all__ = ["matrix_session"]
+
+
+def statement(shape):
+    if shape == "orm":
+        return select(MatrixRow.id)
+    if shape == "core":
+        return select(row.c.id)
+    if shape == "select_from":
+        return select(anchor.c.id).select_from(anchor, row).where(anchor.c.id == row.c.id)
+    if shape == "subquery":
+        return select(select(row.c.id).subquery().c.id)
+    if shape == "cte":
+        return select(select(row.c.id).cte("scoped").c.id)
+    if shape == "union":
+        return union(select(row.c.id).where(row.c.id <= 2), select(row.c.id).where(row.c.id > 2))
+    if shape == "exists":
+        return select(anchor.c.id).where(exists().where(row.c.id == anchor.c.id))
+    raise AssertionError(shape)
+
+
+SHAPES = ["orm", "core", "select_from", "subquery", "cte", "union", "exists"]
+
+
+@pytest.mark.parametrize("shape", SHAPES)
+@pytest.mark.parametrize("tenant", ["A", "B", None], ids=["own", "other", "unbound"])
+@pytest.mark.parametrize("include_deleted", [False, True])
+async def test_select_matrix(matrix_session, shape, tenant, include_deleted):
+    stmt = statement(shape).execution_options(include_deleted=include_deleted)
+    with no_tenant() if tenant is None else tenant_context(tenant):
+        if tenant is None and strict_configured(matrix_session.sync_session):
+            with pytest.raises(TenantIsolationError):
+                await matrix_session.execute(stmt)
+        else:
+            ids = (await matrix_session.execute(stmt)).scalars().all()
+            assert sorted(ids) == visible_ids(tenant, include_deleted)
+
+
+@pytest.mark.parametrize("shape", [*SHAPES, "update", "delete"])
+def test_walk_detects_only_plain_scoped_references(shape):
+    stmt = (
+        update(row).values(name="changed")
+        if shape == "update"
+        else delete(row)
+        if shape == "delete"
+        else statement(shape)
+    )
+    assert references_plain(stmt, {row.name}) is (shape != "orm")
+    assert references_plain(stmt, {"unrelated_table"}) is False

simple_module_db-0.0.39/tests/test_db_tenant_cleanup.py

@@ -0,0 +1,58 @@
+"""Framework tenant settings teardown works independently of the UI plugin."""
+
+from unittest.mock import AsyncMock, patch
+
+from simple_module_core.durable_events import DurableContext
+from simple_module_core.events import EventBus
+from simple_module_core.tenant_events import TenantDeleted
+from simple_module_db.stored_settings import SCOPE_SYSTEM, SCOPE_TENANT, SCOPE_USER, Setting
+from simple_module_db.tenant_cleanup import register_tenant_cleanup
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlmodel import select
+
+_TENANT = "deleted-tenant"
+_OTHER = "retained-tenant"
+_KEY = "branding.logo_file_id"
+
+
+async def test_settings_cleanup_is_durable_scoped_and_idempotent():
+    bus = EventBus()
+    register_tenant_cleanup(bus)
+    names = bus.durable.handler_names(TenantDeleted)
+    assert len(names) == 1
+    from simple_module_core.durable_events import event_key
+
+    subscription = bus.durable.lookup(event_key(TenantDeleted), names[0])
+    assert subscription is not None
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Setting.metadata.create_all, tables=[Setting.__table__])
+        async with AsyncSession(engine) as session:
+            session.add_all(
+                [
+                    Setting(scope=scope, scope_id=scope_id, key=_KEY, value="file-id")
+                    for scope, scope_id in (
+                        (SCOPE_TENANT, _TENANT),
+                        (SCOPE_TENANT, _OTHER),
+                        (SCOPE_USER, _TENANT),
+                        (SCOPE_SYSTEM, ""),
+                    )
+                ]
+            )
+            await session.commit()
+            event = TenantDeleted(tenant_id=_TENANT, slug=_TENANT, name=_TENANT)
+            with patch.object(session, "commit", new_callable=AsyncMock) as commit:
+                await subscription.handler(event, DurableContext(db=session, attempt=1))
+                await subscription.handler(event, DurableContext(db=session, attempt=2))
+                commit.assert_not_awaited()
+            remaining = (await session.execute(select(Setting))).scalars().all()
+            assert {(row.scope, row.scope_id) for row in remaining} == {
+                (SCOPE_TENANT, _OTHER),
+                (SCOPE_USER, _TENANT),
+                (SCOPE_SYSTEM, ""),
+            }
+            await session.rollback()
+            assert len((await session.execute(select(Setting))).scalars().all()) == 4
+    finally:
+        await engine.dispose()

simple_module_db-0.0.39/tests/test_db_user_directory_sql.py

@@ -0,0 +1,29 @@
+"""Shared directory predicates treat SQL LIKE metacharacters as literal text."""
+
+from types import SimpleNamespace
+
+import pytest
+from simple_module_db.user_directory_sql import name_or_email_contains, to_directory_user
+from sqlalchemy import literal, select
+from sqlmodel import Session, create_engine
+
+
+@pytest.mark.parametrize("term", ["%", "_", "\\"])
+def test_name_or_email_contains_escapes_literal_metacharacters(term: str):
+    with Session(create_engine("sqlite://")) as db:
+        for full_name, email in [(f"Ada{term}Lovelace", "other"), (None, f"ada{term}@test")]:
+            predicate = name_or_email_contains(literal(full_name), literal(email), term)
+            assert db.exec(select(predicate)).scalar_one()
+        predicate = name_or_email_contains(literal("Ada Lovelace"), literal("ada@test"), term)
+        assert not db.exec(select(predicate)).scalar_one()
+
+
+@pytest.mark.parametrize("roles", [None, (), ("editor",)])
+def test_conversion_preserves_known_and_unknown_roles(roles: tuple[str, ...] | None):
+    row = SimpleNamespace(email="ada@test", full_name=None)
+    user = to_directory_user(row, "caller-id", roles=roles, is_active=False)
+    assert user.id == "caller-id"
+    assert user.email == row.email
+    assert user.full_name is None
+    assert user.roles == roles
+    assert not user.is_active

simple_module_db-0.0.39/tests/test_rollback_logging.py

@@ -0,0 +1,23 @@
+"""Only rollbacks that discard writes warrant a warning."""
+
+import logging
+
+import pytest
+from _models import _TxnThing
+from simple_module_db import mark_written
+from simple_module_db.transaction import rollback_session
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+@pytest.mark.parametrize("pending", ["none", "new", "written"])
+async def test_rollback_log_level_matches_pending_work(caplog, pending):
+    async with AsyncSession() as session:
+        if pending == "new":
+            session.add(_TxnThing(name="discarded"))
+        elif pending == "written":
+            mark_written(session)
+        with caplog.at_level(logging.DEBUG, logger="simple_module.db"):
+            await rollback_session(session)
+    records = [record for record in caplog.records if record.message == "db.session.rollback"]
+    assert len(records) == 1
+    assert records[0].levelno == (logging.DEBUG if pending == "none" else logging.WARNING)

simple_module_db-0.0.38/simple_module_db/independent.py

@@ -1,34 +0,0 @@
-"""A session opened outside the request, with the commit convention in one place."""
-
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-
-@asynccontextmanager
-async def independent_session(app: Any) -> AsyncGenerator[AsyncSession]:
-    """Open a session from ``app``'s factory, outside any request.
-
-    Commits when the block exits cleanly and rolls back (then re-raises) when it
-    raises, so startup hooks, background cleanups and out-of-band writes do not
-    each hand-roll the pair. The session is closed either way.
-
-    Request code must not use this: the request session (``get_db``) commits in
-    ``CommitBeforeResponseMiddleware``, and a second session cannot see its
-    uncommitted rows. Code that must commit mid-block, never commit, or run on a
-    different engine keeps using ``session_factory()`` directly.
-    """
-    async with app.state.sm.db.session_factory() as session:
-        try:
-            yield session
-            await session.commit()
-        except Exception:
-            await session.rollback()
-            raise
-        # Cancellation and other BaseExceptions skip the explicit rollback: awaiting
-        # it there could be cancelled too and mask the original error, and closing
-        # the session discards the open transaction anyway.