simple-module-db 0.0.29__tar.gz → 0.0.31__tar.gz

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/.gitignore

@@ -63,3 +63,4 @@ Thumbs.db
 host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
+.verify/

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: simple_module_db
-Version: 0.0.29
+Version: 0.0.31
 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
@@ -25,7 +25,7 @@ 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.29
+Requires-Dist: simple-module-core==0.0.31
 Requires-Dist: sqlalchemy[asyncio]>=2.0
 Requires-Dist: sqlmodel>=0.0.22
 Description-Content-Type: text/markdown

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.29"
+version = "0.0.31"
 description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -28,7 +28,7 @@ dependencies = [
     # 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.29",
+    "simple_module_core==0.0.31",
     "sqlalchemy[asyncio]>=2.0",
     "sqlmodel>=0.0.22",
 ]

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/simple_module_db/__init__.py

@@ -13,10 +13,12 @@ from simple_module_db.migrations import (
 from simple_module_db.mixins import AuditMixin, MultiTenantMixin, SoftDeleteMixin, VersionedMixin
 from simple_module_db.provider import DatabaseProvider, detect_provider
 from simple_module_db.session import DatabaseState, init_db
+from simple_module_db.transaction import CommitBeforeResponseMiddleware, finalize_session
 
 __all__ = [
     "AuditMixin",
     "AuditRecord",
+    "CommitBeforeResponseMiddleware",
     "DatabaseProvider",
     "DatabaseState",
     "MultiTenantMixin",
@@ -27,6 +29,7 @@ __all__ = [
     "create_module_base",
     "current_tenant_id",
     "detect_provider",
+    "finalize_session",
     "get_db",
     "init_db",
     "make_include_object",

simple_module_db-0.0.31/simple_module_db/deps.py

@@ -0,0 +1,49 @@
+"""FastAPI dependencies for database access."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import AsyncGenerator
+
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from simple_module_db.transaction import (
+    SESSION_START_KEY,
+    finalize_session,
+    register_request_session,
+    rollback_session,
+)
+
+
+async def get_db(request: Request) -> AsyncGenerator[AsyncSession, None]:
+    """Yield an async database session, auto-closing on exit.
+
+    Commits only when the session has pending writes (``new``, ``dirty``,
+    or ``deleted`` objects); read-only handlers exit via ``rollback``.
+
+    The commit itself normally happens in
+    :class:`~simple_module_db.transaction.CommitBeforeResponseMiddleware`,
+    which fires while the response is still in the server's hands. The
+    finalize below is the fallback for when that middleware isn't in the
+    stack, and a no-op when it already ran — FastAPI runs this exit code
+    *after* the response has been delivered, so a client that immediately
+    reads back what it just wrote would otherwise race the commit and lose
+    (GH #257).
+
+    Usage in FastAPI endpoints::
+
+        @router.get("/items")
+        async def list_items(db: AsyncSession = Depends(get_db)):
+            ...
+    """
+    factory = request.app.state.sm.db.session_factory
+    async with factory() as session:
+        session.info[SESSION_START_KEY] = time.perf_counter()
+        register_request_session(request.scope, session)
+        try:
+            yield session
+            await finalize_session(session)
+        except Exception:
+            await rollback_session(session)
+            raise

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/simple_module_db/migrations.py

@@ -132,6 +132,13 @@ def make_process_revision_directives(
     not strictly required (dropping the table drops the index) but it keeps
     autogen output readable.
 
+    The injection is idempotent, and has to be: a dialect that *can* reflect
+    expression-based indexes (PostgreSQL) already emits the index itself, so
+    re-adding it unconditionally produced a migration with two identical
+    ``create_index`` calls that failed on first run with ``DuplicateTable``.
+    Any index already named in the op tree — at any nesting depth — is left
+    alone, which keeps this dialect-agnostic rather than special-casing SQLite.
+
     Call as::
 
         context.configure(
@@ -164,10 +171,34 @@ def _index_is_expression_based(index: Index) -> bool:
     return any(not isinstance(expr, Column) for expr in index.expressions)
 
 
-def _inject_create_index_after_create_table(upgrade_ops, expression_indexes) -> None:
-    existing_index_names = {
-        getattr(op, "index_name", None) for op in upgrade_ops.ops if isinstance(op, CreateIndexOp)
+def _iter_ops_recursive(container):
+    """Yield every op under ``container``, descending into nested op groups.
+
+    Autogenerate does not emit a flat op list: index operations for a table are
+    grouped inside a ``ModifyTableOps`` container alongside the top-level
+    ``CreateTableOp``/``DropTableOp``. A dedup check that only looks at
+    ``container.ops`` therefore sees no ``CreateIndexOp`` at all and re-injects
+    an index the dialect already emitted — which is exactly how a dialect that
+    *can* reflect expression-based indexes (PostgreSQL) ended up with a
+    duplicate ``CREATE INDEX`` in its initial migration.
+    """
+    for op in container.ops:
+        yield op
+        if hasattr(op, "ops"):
+            yield from _iter_ops_recursive(op)
+
+
+def _existing_index_names(container, op_type) -> set[str | None]:
+    """Names of every ``op_type`` index op already present anywhere under ``container``."""
+    return {
+        getattr(op, "index_name", None)
+        for op in _iter_ops_recursive(container)
+        if isinstance(op, op_type)
     }
+
+
+def _inject_create_index_after_create_table(upgrade_ops, expression_indexes) -> None:
+    existing_index_names = _existing_index_names(upgrade_ops, CreateIndexOp)
     new_ops: list = []
     for op in upgrade_ops.ops:
         new_ops.append(op)
@@ -188,9 +219,7 @@ def _inject_create_index_after_create_table(upgrade_ops, expression_indexes) ->
 
 
 def _inject_drop_index_before_drop_table(downgrade_ops, expression_indexes) -> None:
-    existing_drop_names = {
-        getattr(op, "index_name", None) for op in downgrade_ops.ops if isinstance(op, DropIndexOp)
-    }
+    existing_drop_names = _existing_index_names(downgrade_ops, DropIndexOp)
     new_ops: list = []
     for op in downgrade_ops.ops:
         if isinstance(op, DropTableOp):

simple_module_db-0.0.31/simple_module_db/transaction.py

@@ -0,0 +1,215 @@
+"""Commit the request's unit of work before the response leaves the server.
+
+``get_db`` is a FastAPI ``yield`` dependency, and FastAPI runs a yield
+dependency's exit code *after* the response has been delivered. Committing
+there means a client that creates a row and immediately references it by id in
+a second request loses the race: the create's ``201`` reaches the client before
+the create's commit runs, so the follow-up request opens a fresh session, finds
+nothing, and 404s. It is deterministic rather than flaky — the follow-up
+request reliably beats the post-response commit — which is why a seed script
+publishes 0 pages on its first pass and all of them on a second, identical one.
+See GH #257.
+
+This module moves the commit to the last point that is still *inside* the
+request: the ASGI ``http.response.start`` message. Nothing has reached the
+client yet, so a failure there can still become a 500, and every caller —
+seeds, provisioning scripts, integration tests, single-run k8s jobs — gets the
+guarantee without changing a line of endpoint code.
+
+A session is finalized exactly once. Whichever runs first wins and the other
+becomes a no-op, so the framework stays correct when the middleware is absent
+(a bare ``get_db``, a WebSocket, a test calling the dependency directly) and on
+the error path, where FastAPI unwinds the dependency — rolling it back —
+*before* the error response is sent.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from simple_module_db.listeners import SESSION_HAS_WRITES_KEY
+
+logger = logging.getLogger("simple_module.db")
+
+REQUEST_SESSIONS_KEY = "sm_db_sessions"
+"""Key under ASGI ``scope["state"]`` holding the sessions opened this request."""
+
+SESSION_START_KEY = "sm_db_started_at"
+"""``session.info`` key carrying the perf-counter reading taken at open."""
+
+_FINALIZED_KEY = "sm_db_finalized"
+
+_INTERNAL_ERROR_BODY = json.dumps({"detail": "Internal Server Error"}).encode()
+
+
+def _elapsed_ms(session: AsyncSession) -> float:
+    start = session.info.get(SESSION_START_KEY)
+    return round((time.perf_counter() - start) * 1000, 2) if start else 0.0
+
+
+def _has_pending(session: AsyncSession) -> bool:
+    """Whether ``session`` holds work that still needs committing.
+
+    ``has_writes`` is stamped by the after_flush listener and survives the flush
+    emptying ``session.new``/``.dirty``/``.deleted`` — the raw collections alone
+    would report a flushed-but-uncommitted write as read-only.
+    """
+    return bool(
+        session.info.get(SESSION_HAS_WRITES_KEY) or session.new or session.dirty or session.deleted
+    )
+
+
+def _settle(session: AsyncSession) -> None:
+    """Mark the session finalized and clear the pending-write marker.
+
+    Clearing matters: the marker is sticky, so without this a later finalize
+    would try to re-commit a session whose work has already landed.
+    """
+    session.info[_FINALIZED_KEY] = True
+    session.info.pop(SESSION_HAS_WRITES_KEY, None)
+
+
+async def finalize_session(session: AsyncSession) -> None:
+    """Commit ``session`` if it has pending writes, else roll it back.
+
+    Safe to call more than once, and deliberately **re-armable** rather than
+    one-shot. Work can still be done after the response has started — Starlette
+    runs ``BackgroundTasks`` once the body is sent, and a ``StreamingResponse``
+    writes its body after ``http.response.start`` — and both share this request's
+    session. A one-shot claim would let the middleware's commit consume the
+    session and then silently drop those later writes: they would flush and
+    never commit. So each call commits whatever is pending *at that moment*, and
+    ``get_db``'s exit code still runs afterwards to catch the rest.
+
+    Read-only handlers exit via ``rollback`` — one round-trip cheaper than
+    ``commit``, and it keeps read-only queries from showing up as writes in
+    query logs / ``pg_stat_statements``. A repeat call with nothing new pending
+    returns immediately rather than paying for a second rollback.
+
+    On commit failure the session is rolled back before the error propagates,
+    so the caller never has to reason about a half-finalized session.
+    """
+    if not _has_pending(session):
+        if session.info.get(_FINALIZED_KEY):
+            return
+        _settle(session)
+        await session.rollback()
+        logger.debug(
+            "db.session.read_only",
+            extra={"operation": "read_only_rollback", "db_duration_ms": _elapsed_ms(session)},
+        )
+        return
+    try:
+        await session.commit()
+    except Exception:
+        await session.rollback()
+        raise
+    finally:
+        # Settled either way: a failed commit must not be retried by the
+        # fallback finalize in get_db's exit code.
+        _settle(session)
+    logger.info(
+        "db.session.commit",
+        extra={"operation": "commit", "db_duration_ms": _elapsed_ms(session)},
+    )
+
+
+async def rollback_session(session: AsyncSession) -> None:
+    """Roll ``session`` back and drop its pending work. Idempotent."""
+    if session.info.get(_FINALIZED_KEY) and not _has_pending(session):
+        return
+    _settle(session)
+    await session.rollback()
+    logger.warning(
+        "db.session.rollback",
+        extra={"operation": "rollback", "db_duration_ms": _elapsed_ms(session)},
+    )
+
+
+def register_request_session(scope: dict, session: AsyncSession) -> None:
+    """Enlist ``session`` for commit-before-response, if the middleware is installed.
+
+    A no-op when it isn't: ``get_db`` still commits in its own exit code, just
+    later. That keeps the dependency usable on its own — in a WebSocket handler,
+    a background task, or a test that never builds the middleware stack.
+    """
+    sessions = scope.get("state", {}).get(REQUEST_SESSIONS_KEY)
+    if sessions is None:
+        return
+    sessions.append(session)
+
+
+class CommitBeforeResponseMiddleware:
+    """Finalize this request's DB sessions before the response is transmitted.
+
+    Pure ASGI rather than ``BaseHTTPMiddleware`` because the hook point is the
+    ``send`` channel, not the response object: intercepting
+    ``http.response.start`` is what lets the commit land before any byte is
+    written, and lets a commit failure still be turned into a 500.
+
+    Install this **innermost** (add it first — Starlette's ``add_middleware`` is
+    LIFO) so its wrapper is the first to see the response and the commit happens
+    as early as possible.
+    """
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        sessions: list[AsyncSession] = []
+        scope.setdefault("state", {})[REQUEST_SESSIONS_KEY] = sessions
+        aborted = False
+
+        async def send_wrapper(message) -> None:
+            nonlocal aborted
+            if aborted:
+                # The response we replaced is still streaming its body into a
+                # channel we've already closed off. Drop it.
+                return
+            if message["type"] == "http.response.start" and sessions:
+                try:
+                    # A request normally has exactly one session (FastAPI caches
+                    # the dependency). With several — Depends(get_db,
+                    # use_cache=False) — a failure part-way leaves the earlier
+                    # commits durable while the client sees a 500. There is no
+                    # cross-session atomicity to recover here short of two-phase
+                    # commit; the log line below is what makes it diagnosable.
+                    for session in sessions:
+                        await finalize_session(session)
+                except Exception:
+                    aborted = True
+                    logger.exception(
+                        "db.session.commit_failed", extra={"operation": "commit_failed"}
+                    )
+                    await _send_internal_error(send)
+                    return
+            await send(message)
+
+        await self.app(scope, receive, send_wrapper)
+
+
+async def _send_internal_error(send) -> None:
+    """Replace the not-yet-sent response with a 500.
+
+    Reachable only from ``http.response.start``, so nothing has been written
+    and this cannot collide with a partially-sent response.
+    """
+    await send(
+        {
+            "type": "http.response.start",
+            "status": 500,
+            "headers": [
+                (b"content-type", b"application/json"),
+                (b"content-length", str(len(_INTERNAL_ERROR_BODY)).encode()),
+            ],
+        }
+    )
+    await send({"type": "http.response.body", "body": _INTERNAL_ERROR_BODY})

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/tests/_models.py

@@ -27,3 +27,14 @@ class _TenantSoftItem(_TenantBase, MultiTenantMixin, SoftDeleteMixin, table=True
     __tablename__ = "mt_test_soft_item"
     id: int | None = Field(default=None, primary_key=True)
     name: str = Field(max_length=100)
+
+
+_TxnBase = create_module_base("txn_test")
+
+
+class _TxnThing(_TxnBase, table=True):  # ty: ignore[unsupported-base]
+    """Plain table for exercising when the request's unit of work commits."""
+
+    __tablename__ = "txn_test_thing"
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(max_length=100)

{simple_module_db-0.0.29 → simple_module_db-0.0.31}/tests/test_migrations.py

@@ -188,6 +188,49 @@ class TestProcessRevisionDirectives:
         index_ops = [op for op in directives[0].upgrade_ops.ops if isinstance(op, CreateIndexOp)]
         assert len(index_ops) == 1
 
+    def test_does_not_double_inject_when_nested_in_modify_table_ops(self):
+        """Autogenerate does not hand us a flat op list: index ops for a table
+        arrive inside a ``ModifyTableOps`` group next to the ``CreateTableOp``.
+        A dedup check that only scans the top level sees no ``CreateIndexOp``
+        there and re-injects the index PostgreSQL already emitted, producing a
+        migration that dies with ``DuplicateTable`` on its first run."""
+        from alembic.operations.ops import CreateIndexOp, ModifyTableOps
+        from simple_module_db.migrations import make_process_revision_directives
+
+        meta = self._build_meta()
+        idx = next(iter(meta.tables["things"].indexes))
+        nested = ModifyTableOps("things", ops=[CreateIndexOp.from_index(idx)])
+        directives = self._build_directives("things", nested)
+        make_process_revision_directives(meta)(None, None, directives)
+
+        assert self._count_index_ops(directives[0].upgrade_ops, CreateIndexOp) == 1
+
+    def test_does_not_double_inject_drop_nested_in_modify_table_ops(self):
+        """Same nesting applies to the downgrade: the reflected ``DropIndexOp``
+        sits inside a ``ModifyTableOps`` group before the ``DropTableOp``."""
+        from alembic.operations.ops import DropIndexOp, ModifyTableOps
+        from simple_module_db.migrations import make_process_revision_directives
+
+        meta = self._build_meta()
+        directives = self._build_directives("things")
+        directives[0].downgrade_ops.ops.insert(
+            0, ModifyTableOps("things", ops=[DropIndexOp("ix_things_email_lower", "things")])
+        )
+        make_process_revision_directives(meta)(None, None, directives)
+
+        assert self._count_index_ops(directives[0].downgrade_ops, DropIndexOp) == 1
+
+    @staticmethod
+    def _count_index_ops(container, op_type) -> int:
+        """Count ``op_type`` ops anywhere under ``container``, nesting included."""
+        total = 0
+        for op in container.ops:
+            if isinstance(op, op_type):
+                total += 1
+            if hasattr(op, "ops"):
+                total += TestProcessRevisionDirectives._count_index_ops(op, op_type)
+        return total
+
     def test_ignores_column_based_indexes(self):
         """Plain column indexes are already handled correctly by autogenerate;
         the hook must not touch them."""

simple_module_db-0.0.31/tests/test_transaction.py

@@ -0,0 +1,231 @@
+"""Tests for commit-before-response (GH #257).
+
+A client that creates a row and immediately references it by id used to get a
+deterministic 404: FastAPI runs a ``yield`` dependency's exit code *after* the
+response is delivered, so the create's ``201`` beat the create's commit and the
+follow-up request opened a fresh session that saw nothing.
+
+These use a **file-backed** SQLite database on purpose. An in-memory SQLite URL
+shares one connection across every session, which makes uncommitted writes
+visible to the "second request" and hides the very race under test.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from types import SimpleNamespace
+
+import httpx
+import pytest
+from _models import _TxnBase, _TxnThing
+from fastapi import BackgroundTasks, Depends, FastAPI
+from fastapi.responses import StreamingResponse
+from simple_module_db.deps import get_db
+from simple_module_db.listeners import register_listeners
+from simple_module_db.session import init_db
+from simple_module_db.transaction import CommitBeforeResponseMiddleware
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+
+def _build_app(db_state, *, with_middleware: bool = True) -> FastAPI:
+    """A miniature host: create flushes only, read opens its own session."""
+    app = FastAPI()
+    if with_middleware:
+        app.add_middleware(CommitBeforeResponseMiddleware)
+    app.state.sm = SimpleNamespace(db=db_state)
+
+    @app.post("/things", status_code=201)
+    async def create(name: str, db: AsyncSession = Depends(get_db)):
+        # Deliberately no commit() — get_db owns the unit of work, which is
+        # exactly the pattern the framework documents for service code.
+        thing = _TxnThing(name=name)
+        db.add(thing)
+        await db.flush()
+        return {"id": thing.id}
+
+    @app.get("/things/{thing_id}")
+    async def read(thing_id: int, db: AsyncSession = Depends(get_db)):
+        found = (
+            await db.execute(select(_TxnThing).where(_TxnThing.id == thing_id))
+        ).scalar_one_or_none()
+        if found is None:
+            return {"found": False}
+        return {"found": True, "name": found.name}
+
+    @app.post("/boom", status_code=201)
+    async def boom(db: AsyncSession = Depends(get_db)):
+        db.add(_TxnThing(name="doomed"))
+        await db.flush()
+        raise RuntimeError("endpoint blew up after writing")
+
+    return app
+
+
+@pytest.fixture
+async def db_state(tmp_path) -> AsyncGenerator[object, None]:
+    state = init_db(f"sqlite+aiosqlite:///{tmp_path / 'txn.db'}")
+    try:
+        # The after_flush listener is what marks a session as having writes
+        # once flush() has emptied new/dirty/deleted — create_app registers it,
+        # so the fixture must too or every request looks read-only.
+        register_listeners(state)
+        async with state.engine.begin() as conn:
+            await conn.run_sync(_TxnBase.metadata.create_all)
+        yield state
+    finally:
+        await state.engine.dispose()
+
+
+async def _client(app) -> httpx.AsyncClient:
+    return httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app, raise_app_exceptions=False),
+        base_url="http://test",
+    )
+
+
+class TestCommitBeforeResponse:
+    async def test_created_row_is_readable_on_the_very_next_request(self, db_state):
+        """The client-visible contract: no second pass, no retry loop.
+
+        Note this one does *not* fail without the fix — httpx's in-process ASGI
+        transport awaits the whole request, teardown included, before issuing
+        the next one, so the follow-up can never beat the commit here. It
+        documents the intended behaviour; the ordering guarantee is pinned by
+        ``test_write_is_durable_before_the_response_is_delivered`` below, which
+        does fail without the middleware.
+        """
+        async with await _client(_build_app(db_state)) as client:
+            created = await client.post("/things", params={"name": "page-1"})
+            assert created.status_code == 201
+            thing_id = created.json()["id"]
+
+            found = await client.get(f"/things/{thing_id}")
+
+        assert found.json() == {"found": True, "name": "page-1"}
+
+    async def test_write_is_durable_before_the_response_is_delivered(self, db_state):
+        """Stronger than the round-trip above: assert against a connection that
+        the request never touched, at the moment the response is emitted."""
+        app = _build_app(db_state)
+        visible_at_response_start: list[bool] = []
+
+        class Probe:
+            def __init__(self, inner):
+                self.inner = inner
+
+            async def __call__(self, scope, receive, send):
+                async def spy(message):
+                    if message["type"] == "http.response.start":
+                        async with db_state.session_factory() as other:
+                            rows = (await other.execute(select(_TxnThing))).scalars().all()
+                            visible_at_response_start.append(bool(rows))
+                    await send(message)
+
+                await self.inner(scope, receive, spy)
+
+        async with await _client(Probe(app)) as client:
+            assert (await client.post("/things", params={"name": "durable"})).status_code == 201
+
+        assert visible_at_response_start == [True], (
+            "row was not committed by the time the response left the server"
+        )
+
+    async def test_endpoint_exception_still_rolls_back(self, db_state):
+        """The middleware must not turn a failed request's writes into a commit."""
+        async with await _client(_build_app(db_state)) as client:
+            assert (await client.post("/boom")).status_code == 500
+
+        async with db_state.session_factory() as session:
+            assert (await session.execute(select(_TxnThing))).scalars().all() == []
+
+    async def test_commit_failure_becomes_a_500_and_persists_nothing(self, db_state, monkeypatch):
+        """A commit that blows up at response.start replaces the response rather
+        than shipping a 201 for work that never landed.
+
+        The failure is injected at ``AsyncSession.commit`` rather than at
+        ``finalize_session``: stubbing the finalizer would bypass its bookkeeping,
+        leaving get_db's fallback free to commit the row the test claims was
+        lost — the assertion would pass while the guarantee was broken.
+        """
+
+        async def explode(self, *args, **kwargs):
+            raise RuntimeError("commit failed")
+
+        monkeypatch.setattr(AsyncSession, "commit", explode)
+
+        async with await _client(_build_app(db_state)) as client:
+            response = await client.post("/things", params={"name": "nope"})
+
+        assert response.status_code == 500
+        assert response.json() == {"detail": "Internal Server Error"}
+
+        monkeypatch.undo()
+        async with db_state.session_factory() as session:
+            assert (await session.execute(select(_TxnThing))).scalars().all() == []
+
+    async def test_background_task_writes_still_commit(self, db_state):
+        """Starlette runs BackgroundTasks after the body is sent, on this same
+        session. Finalizing at response.start must not consume the session and
+        strand them — they flushed but never committed, losing writes silently."""
+        app = _build_app(db_state)
+
+        @app.post("/with-task", status_code=202)
+        async def with_task(bg: BackgroundTasks, db: AsyncSession = Depends(get_db)):
+            db.add(_TxnThing(name="before-response"))
+            await db.flush()
+
+            async def task():
+                db.add(_TxnThing(name="from-background-task"))
+                await db.flush()
+
+            bg.add_task(task)
+            return {"ok": True}
+
+        async with await _client(app) as client:
+            assert (await client.post("/with-task")).status_code == 202
+
+        async with db_state.session_factory() as session:
+            names = sorted(t.name for t in (await session.execute(select(_TxnThing))).scalars())
+        assert names == ["before-response", "from-background-task"]
+
+    async def test_streaming_response_body_writes_still_commit(self, db_state):
+        """A StreamingResponse writes its body *after* response.start, so work
+        done while streaming lands after the middleware's commit."""
+        app = _build_app(db_state)
+
+        @app.get("/stream")
+        async def stream(db: AsyncSession = Depends(get_db)):
+            db.add(_TxnThing(name="before-stream"))
+            await db.flush()
+
+            async def body():
+                yield b"chunk"
+                db.add(_TxnThing(name="during-stream"))
+                await db.flush()
+
+            return StreamingResponse(body())
+
+        async with await _client(app) as client:
+            assert (await client.get("/stream")).status_code == 200
+
+        async with db_state.session_factory() as session:
+            names = sorted(t.name for t in (await session.execute(select(_TxnThing))).scalars())
+        assert names == ["before-stream", "during-stream"]
+
+    async def test_still_commits_without_the_middleware(self, db_state):
+        """get_db keeps its own fallback finalize, so the dependency works
+        standalone — in a WebSocket handler, or a test that builds no stack."""
+        app = _build_app(db_state, with_middleware=False)
+        async with await _client(app) as client:
+            assert (await client.post("/things", params={"name": "solo"})).status_code == 201
+
+        async with db_state.session_factory() as session:
+            names = [t.name for t in (await session.execute(select(_TxnThing))).scalars().all()]
+        assert names == ["solo"]
+
+    async def test_read_only_request_is_not_committed(self, db_state):
+        """Read-only handlers still exit via rollback — one round-trip cheaper."""
+        app = _build_app(db_state)
+        async with await _client(app) as client:
+            assert (await client.get("/things/999")).json() == {"found": False}

simple_module_db-0.0.29/simple_module_db/deps.py

@@ -1,62 +0,0 @@
-"""FastAPI dependencies for database access."""
-
-from __future__ import annotations
-
-import logging
-import time
-from collections.abc import AsyncGenerator
-
-from fastapi import Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from simple_module_db.listeners import SESSION_HAS_WRITES_KEY
-
-_db_logger = logging.getLogger("simple_module.db")
-
-
-async def get_db(request: Request) -> AsyncGenerator[AsyncSession, None]:
-    """Yield an async database session, auto-closing on exit.
-
-    Commits only when the session has pending writes (``new``, ``dirty``,
-    or ``deleted`` objects). Read-only handlers still open an implicit
-    transaction but exit via ``rollback`` — that's one round-trip
-    cheaper than ``commit`` and keeps read-only queries from showing up
-    as writes in query logs / ``pg_stat_statements``.
-
-    Usage in FastAPI endpoints::
-
-        @router.get("/items")
-        async def list_items(db: AsyncSession = Depends(get_db)):
-            ...
-    """
-    factory = request.app.state.sm.db.session_factory
-    start = time.perf_counter()
-    async with factory() as session:
-        try:
-            yield session
-            # ``has_writes`` is set by the after_flush listener and
-            # survives the flush emptying session.new/.dirty/.deleted.
-            has_pending = bool(
-                session.info.get(SESSION_HAS_WRITES_KEY)
-                or session.new
-                or session.dirty
-                or session.deleted
-            )
-            if has_pending:
-                await session.commit()
-                op, log_message = "commit", "db.session.commit"
-                log = _db_logger.info
-            else:
-                await session.rollback()
-                op, log_message = "read_only_rollback", "db.session.read_only"
-                log = _db_logger.debug
-            duration_ms = round((time.perf_counter() - start) * 1000, 2)
-            log(log_message, extra={"operation": op, "db_duration_ms": duration_ms})
-        except Exception:
-            await session.rollback()
-            duration_ms = round((time.perf_counter() - start) * 1000, 2)
-            _db_logger.warning(
-                "db.session.rollback",
-                extra={"operation": "rollback", "db_duration_ms": duration_ms},
-            )
-            raise