simple-module-hosting 0.0.39__tar.gz → 0.0.40__tar.gz

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.39
+Version: 0.0.40
 Summary: FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -22,13 +22,13 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: click<9,>=8.1
-Requires-Dist: fastapi<0.157,>=0.140
+Requires-Dist: fastapi<0.159,>=0.140
 Requires-Dist: httpx<0.29,>=0.27
 Requires-Dist: itsdangerous<3,>=2.0
 Requires-Dist: jinja2<4,>=3.1
-Requires-Dist: simple-module-core==0.0.39
-Requires-Dist: simple-module-db==0.0.39
-Requires-Dist: simple-module-inertia==0.0.39
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-inertia==0.0.40
 Requires-Dist: starlette<2,>=0.44
 Requires-Dist: tomlkit<0.16,>=0.13
 Requires-Dist: uvicorn[standard]<0.55,>=0.34

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.39"
+version = "0.0.40"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -22,16 +22,16 @@ classifiers = [
 ]
 dependencies = [
     "click>=8.1,<9",
-    "fastapi>=0.140,<0.157",
+    "fastapi>=0.140,<0.159",
     "httpx>=0.27,<0.29",
     # SessionMiddleware (starlette.middleware.sessions) imports itsdangerous at
     # module import time; starlette treats it as an optional extra, so declare
     # it directly — out-of-tree hosts have nothing else pulling it in.
     "itsdangerous>=2.0,<3",
     "jinja2>=3.1,<4",
-    "simple_module_core==0.0.39",
-    "simple_module_db==0.0.39",
-    "simple_module_inertia==0.0.39",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_inertia==0.0.40",
     "starlette>=0.44,<2",
     "tomlkit>=0.13,<0.16",
     "uvicorn[standard]>=0.34,<0.55",

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/simple_module_hosting/_inertia_setup.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import logging
 from pathlib import Path
 
@@ -145,12 +146,18 @@ def setup_inertia(
 
     use_dev_server = settings.environment in NON_PROD_ENVIRONMENTS
     inertia_environment = "development" if use_dev_server else "production"
+    manifest_path = "" if use_dev_server else _prod_manifest_path(project_root)
+    version = (
+        hashlib.sha256(Path(manifest_path).read_bytes()).hexdigest()
+        if manifest_path
+        else _INERTIA_VERSION
+    )
 
     inertia_config = InertiaConfig(
         environment=inertia_environment,
-        version=_INERTIA_VERSION,
+        version=version,
         dev_url=settings.vite_dev_url if use_dev_server else "",
-        manifest_json_path="" if use_dev_server else _prod_manifest_path(project_root),
+        manifest_json_path=manifest_path,
         assets_prefix="" if use_dev_server else _ASSETS_PREFIX,
         templates=templates,
         root_template_filename=_ROOT_TEMPLATE_FILENAME,

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/simple_module_hosting/_lifespan.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 import logging
 from collections.abc import AsyncGenerator, Callable, Sequence
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 
 from fastapi import FastAPI
 from simple_module_core.app_state import get_migration_status
@@ -97,49 +97,49 @@ def build_lifespan(modules: Sequence) -> Callable:
 
     @asynccontextmanager
     async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-        # Report first, decide second. On a genuinely fresh install a
-        # behind-head database must still boot far enough to serve the wizard —
-        # running the migrations is one of the things that wizard does, and
-        # check_migrations' RuntimeError would make it unreachable. Anywhere
-        # else the original behaviour stands: a schema the code does not match
-        # fails the boot. See _is_first_run for why those two cases cannot be
-        # told apart by "is setup complete".
-        app.state.migration = await migration_status(app.state.sm.db.engine)
-        if not app.state.migration["is_current"] and not await _is_first_run(app):
-            raise RuntimeError(
-                f"Database is {app.state.migration['pending_count']} revision(s) behind "
-                f"(at {app.state.migration['current_revision']!r}, head is "
-                f"{app.state.migration['head_revision']!r}). Run: make migrate"
-            )
-
-        await hydrate_settings_from_db(app)
-
-        # Behind head on a first run the tables a module's on_startup reads do
-        # not exist yet. Boot must still reach the wizard, so a hook that fails
-        # here is deferred and replayed once the wizard has applied the
-        # migrations (run_deferred_startup) rather than aborting the process.
-        app.state.deferred_startup = []
-        tolerate = not app.state.migration["is_current"]
-        for mod in modules:
-            try:
-                await mod.on_startup(app)
-            except Exception:
-                if not tolerate:
-                    raise
-                logger.warning(
-                    "on_startup of %s failed on an unmigrated database; "
-                    "deferring it until the setup wizard has run the migrations",
-                    mod.meta.name,
-                    exc_info=True,
+        async with AsyncExitStack() as cleanup:
+            cleanup.push_async_callback(app.state.sm.db.engine.dispose)
+            # Report first, decide second. On a genuinely fresh install a
+            # behind-head database must still boot far enough to serve the wizard —
+            # running the migrations is one of the things that wizard does, and
+            # check_migrations' RuntimeError would make it unreachable. Anywhere
+            # else the original behaviour stands: a schema the code does not match
+            # fails the boot. See _is_first_run for why those two cases cannot be
+            # told apart by "is setup complete".
+            app.state.migration = await migration_status(app.state.sm.db.engine)
+            if not app.state.migration["is_current"] and not await _is_first_run(app):
+                raise RuntimeError(
+                    f"Database is {app.state.migration['pending_count']} revision(s) behind "
+                    f"(at {app.state.migration['current_revision']!r}, head is "
+                    f"{app.state.migration['head_revision']!r}). Run: make migrate"
                 )
-                app.state.deferred_startup.append(mod)
-        # Here rather than in create_app: the host includes its own routers
-        # after create_app returns, and those should be guarded too.
-        settings = getattr(app.state.sm, "settings", None)
-        guard_included_routers(app, warm=getattr(settings, "environment", None) != "testing")
-        yield
-        for mod in reversed(modules):
-            await mod.on_shutdown(app)
-        await app.state.sm.db.engine.dispose()
+
+            await hydrate_settings_from_db(app)
+
+            # Behind head on a first run the tables a module's on_startup reads do
+            # not exist yet. Boot must still reach the wizard, so a hook that fails
+            # here is deferred and replayed once the wizard has applied the
+            # migrations (run_deferred_startup) rather than aborting the process.
+            app.state.deferred_startup = []
+            tolerate = not app.state.migration["is_current"]
+            for mod in modules:
+                try:
+                    await mod.on_startup(app)
+                except Exception:
+                    if not tolerate:
+                        raise
+                    logger.warning(
+                        "on_startup of %s failed on an unmigrated database; "
+                        "deferring it until the setup wizard has run the migrations",
+                        mod.meta.name,
+                        exc_info=True,
+                    )
+                    app.state.deferred_startup.append(mod)
+                cleanup.push_async_callback(mod.on_shutdown, app)
+            # Here rather than in create_app: the host includes its own routers
+            # after create_app returns, and those should be guarded too.
+            settings = getattr(app.state.sm, "settings", None)
+            guard_included_routers(app, warm=getattr(settings, "environment", None) != "testing")
+            yield
 
     return lifespan

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/simple_module_hosting/csrf.py

@@ -19,7 +19,9 @@ bind a token to.
 
 This lifts the design the pagebuilder module shipped first
 (``pagebuilder/security.py``) into the framework, so every module shares
-one header name and one token-discovery convention.
+one header name and one token-discovery convention. Sign-in clears the users
+session, rotating its token; principal changes that retain the session must
+call ``rotate_csrf_token`` before rendering the next page.
 """
 
 from __future__ import annotations
@@ -28,7 +30,7 @@ import secrets
 
 from fastapi import HTTPException, Request
 
-__all__ = ["CSRF_HEADER", "RequiresCsrf", "get_csrf_token"]
+__all__ = ["CSRF_HEADER", "RequiresCsrf", "get_csrf_token", "rotate_csrf_token"]
 
 CSRF_HEADER = "X-CSRF-Token"
 _SESSION_KEY = "sm_csrf_token"
@@ -61,6 +63,17 @@ def get_csrf_token(request: Request) -> str:
     return token
 
 
+def rotate_csrf_token(request: Request) -> None:
+    """Discard the old token; the next page render mints a fresh one.
+
+    Use when changing the principal while deliberately retaining the session.
+    Clearing the whole session already discards the token. No session is a no-op.
+    """
+    session = request.scope.get("session")
+    if session is not None:
+        session.pop(_SESSION_KEY, None)
+
+
 class RequiresCsrf:
     """FastAPI dependency enforcing the CSRF header on unsafe methods.
 

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/simple_module_hosting/session.py

@@ -72,6 +72,28 @@ which would sign the entire user base out on deploy — or accepting it forever,
 which would leave the hole this key was added to close.
 """
 
+_SIGN_IN_SURVIVORS_ATTR = "sign_in_preserved_session_keys"
+
+
+def preserve_across_sign_in(app: Any, key: str) -> None:
+    """Keep ``key`` when sign-in replaces the session (it is not user-bound state).
+
+    For gate state that belongs to the browser rather than the principal, such
+    as the site-lock unlock marker: clearing it at sign-in would re-prompt the
+    visitor who just passed the gate. Call from ``register_settings``.
+    """
+    keys = getattr(app.state, _SIGN_IN_SURVIVORS_ATTR, None)
+    if keys is None:
+        keys = set()
+        setattr(app.state, _SIGN_IN_SURVIVORS_ATTR, keys)
+    keys.add(key)
+
+
+def sign_in_preserved_keys(app: Any) -> frozenset[str]:
+    """Keys this app registered through :func:`preserve_across_sign_in`."""
+    return frozenset(getattr(app.state, _SIGN_IN_SURVIVORS_ATTR, ()))
+
+
 SESSION_COOKIE_NAME = "session"
 """The session cookie's name (Starlette's default, pinned so the OpenAPI export can cite it)."""
 

simple_module_hosting-0.0.40/simple_module_hosting/setup_wizard/_migration_lock.py

@@ -0,0 +1,53 @@
+"""Database advisory locks that also work before the first migration (#634)."""
+
+import logging
+from collections.abc import Generator
+from contextlib import closing, contextmanager
+from pathlib import Path
+
+from sqlalchemy import create_engine
+from sqlalchemy.engine import URL
+from sqlalchemy.pool import NullPool
+
+logger = logging.getLogger(__name__)
+
+_POSTGRES_LOCK = 634539
+
+
+@contextmanager
+def migration_lock(url: URL) -> Generator[None]:
+    """Hold until the migration thread exits; no TTL or request cancellation gap."""
+    if url.get_backend_name() == "sqlite":
+        if not url.database or url.database == ":memory:":
+            # An in-memory database cannot be shared by different workers.
+            yield
+            return
+        import sqlite3
+
+        # A separate SQLite database supplies the advisory lock without locking
+        # the application database against Alembic's own connections.
+        path = str(Path(url.database).resolve()) + ".migrate-lock.db"
+        with closing(sqlite3.connect(path, timeout=300)) as connection:
+            try:
+                connection.execute("BEGIN EXCLUSIVE")
+                yield
+            finally:
+                connection.rollback()
+        return
+    if url.get_backend_name() != "postgresql":
+        logger.warning(
+            "No cross-worker migration lock for %s; relying on the per-process lock",
+            url.get_backend_name(),
+        )
+        yield
+        return
+    engine = create_engine(url.set(drivername="postgresql+psycopg2"), poolclass=NullPool)
+    try:
+        with engine.connect() as connection:
+            connection.exec_driver_sql("SELECT pg_advisory_lock(%s)", (_POSTGRES_LOCK,))
+            try:
+                yield
+            finally:
+                connection.exec_driver_sql("SELECT pg_advisory_unlock(%s)", (_POSTGRES_LOCK,))
+    finally:
+        engine.dispose()

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/simple_module_hosting/setup_wizard/migrate.py

@@ -16,12 +16,12 @@ from collections.abc import Generator
 from fastapi import HTTPException, Request
 
 from simple_module_hosting._deferred_startup import run_deferred_startup
+from simple_module_hosting.setup_wizard._migration_lock import migration_lock
 
 logger = logging.getLogger(__name__)
 
-# The endpoint is anonymous, so nothing stops two requests (a double click, a
-# second tab) from starting two Alembic runs against one database at once.
-# Serialized here; the second run then finds the schema at head and is a no-op.
+# Alembic and logging have process-global state, even for different databases.
+# Cross-worker serialization is provided by migration_lock inside the thread.
 _MIGRATION_LOCK = asyncio.Lock()
 
 
@@ -68,7 +68,7 @@ async def apply_migrations(request: Request, _data: dict) -> dict:
         # branch_labels, so the history legitimately has several heads and
         # "head" raises CommandError("Multiple head revisions are present").
         # This is what `make migrate` runs.
-        with _preserve_logging():
+        with migration_lock(request.app.state.sm.db.engine.url), _preserve_logging():
             command.upgrade(AlembicConfig(ini_path), "heads")
 
     try:

simple_module_hosting-0.0.40/tests/test_hosting_asset_version.py

@@ -0,0 +1,71 @@
+"""Hosting versions built assets by manifest content, so stale visits reload."""
+
+import json
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from simple_module_hosting._inertia_setup import setup_inertia
+from simple_module_hosting.settings import Settings
+from simple_module_inertia import (
+    InertiaVersionConflictException,
+    inertia_version_conflict_exception_handler,
+)
+from simple_module_inertia.config import resolved_version
+from starlette.requests import Request
+
+
+def _setup(root: Path, environment: str):
+    (root / "templates").mkdir(exist_ok=True)
+    app = FastAPI()
+    config = setup_inertia(app, Settings(environment=environment), [], root)
+    assert config is not None
+    return app, config
+
+
+@pytest.mark.parametrize("layout", ["host", "."])
+@pytest.mark.parametrize("environment", ["production", "staging"])
+async def test_new_manifest_reloads_visits_from_previous_build(tmp_path, layout, environment):
+    manifest = tmp_path / layout / "static" / "dist" / ".vite" / "manifest.json"
+    manifest.parent.mkdir(parents=True)
+    manifest.write_text(json.dumps({"main.tsx": {"file": "assets/old.js"}}))
+    _, old_config = _setup(tmp_path, environment)
+    old_version = resolved_version(old_config)
+    _, same_config = _setup(tmp_path, environment)
+    assert resolved_version(same_config) == old_version
+
+    manifest.write_text(json.dumps({"main.tsx": {"file": "assets/new.js"}}))
+    app, new_config = _setup(tmp_path, environment)
+    new_version = resolved_version(new_config)
+    assert new_version != old_version
+    request = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "scheme": "http",
+            "server": ("test", 80),
+            "path": "/page",
+            "query_string": b"",
+            "headers": [(b"x-inertia", b"true"), (b"x-inertia-version", old_version.encode())],
+            "session": {},
+        }
+    )
+    with pytest.raises(InertiaVersionConflictException) as exc:
+        app.state.inertia_dependency(request)
+    stale = await inertia_version_conflict_exception_handler(request, exc.value)
+    assert stale.status_code == 409
+    assert stale.headers["X-Inertia-Location"] == "http://test/page"
+    request.scope["headers"] = [
+        (b"x-inertia", b"true"),
+        (b"x-inertia-version", new_version.encode()),
+    ]
+    current = await app.state.inertia_dependency(Request(request.scope)).render("Page")
+    assert current.status_code == 200
+    assert json.loads(current.body)["version"] == new_version
+
+
+@pytest.mark.parametrize("environment", ["development", "testing", "production"])
+def test_setup_without_built_assets_preserves_fallback(tmp_path, environment):
+    _, config = _setup(tmp_path, environment)
+    assert resolved_version(config) == "1.0"
+    assert config.manifest_json_path == ""

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/tests/test_hosting_csrf.py

@@ -96,3 +96,32 @@ class TestWithoutSessionMiddleware:
         async with httpx.AsyncClient(transport=transport, base_url="http://test") as c:
             assert (await c.get("/token")).json()["token"] == ""
             assert (await c.post("/things")).status_code == 200
+
+
+@pytest.mark.parametrize("with_session", [False, True])
+def test_rotation_discards_only_csrf_state(with_session):
+    from simple_module_hosting.csrf import rotate_csrf_token
+
+    scope = {"type": "http"}
+    if with_session:
+        scope["session"] = {"user_id": "keep"}
+    request = Request(scope)
+    old = get_csrf_token(request)
+    rotate_csrf_token(request)
+    rotate_csrf_token(request)  # safe even before another token has been minted
+    if with_session:
+        assert request.session == {"user_id": "keep"}
+        assert get_csrf_token(request) != old
+    else:
+        assert get_csrf_token(request) == ""
+
+
+def test_sign_in_survivors_registry():
+    from types import SimpleNamespace
+
+    from simple_module_hosting.session import preserve_across_sign_in, sign_in_preserved_keys
+
+    app = SimpleNamespace(state=SimpleNamespace())
+    assert sign_in_preserved_keys(app) == frozenset()
+    preserve_across_sign_in(app, "gate_marker")
+    assert sign_in_preserved_keys(app) == {"gate_marker"}

simple_module_hosting-0.0.40/tests/test_hosting_lifespan_cleanup.py

@@ -0,0 +1,53 @@
+"""Lifecycle failures must still unwind modules and dispose the engine (#634)."""
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+from fastapi import FastAPI
+from simple_module_hosting import _lifespan
+
+
+@pytest.mark.parametrize("failure", ["startup", "shutdown", "body", "migration"])
+async def test_lifespan_unwinds_after_failure(monkeypatch, failure):
+    calls = []
+    app = FastAPI()
+
+    async def dispose():
+        calls.append("dispose")
+
+    app.state.sm = SimpleNamespace(db=SimpleNamespace(engine=SimpleNamespace(dispose=dispose)))
+    status = AsyncMock(return_value={"is_current": True})
+    if failure == "migration":
+        status.side_effect = RuntimeError("migration")
+    monkeypatch.setattr(_lifespan, "migration_status", status)
+    monkeypatch.setattr(_lifespan, "hydrate_settings_from_db", AsyncMock())
+    modules = []
+    for name in ["a", "b", "c"]:
+
+        async def start(app, name=name):
+            calls.append(f"start:{name}")
+            if failure == "startup" and name == "b":
+                raise RuntimeError("startup")
+
+        async def stop(app, name=name):
+            calls.append(f"stop:{name}")
+            if failure in {"startup", "shutdown"} and name == "a":
+                raise ValueError("cleanup")
+            if failure == "shutdown" and name == "c":
+                raise RuntimeError("shutdown")
+
+        modules.append(SimpleNamespace(on_startup=start, on_shutdown=stop))
+
+    with pytest.raises((RuntimeError, ValueError)):
+        async with _lifespan.build_lifespan(modules)(app):
+            if failure == "body":
+                raise RuntimeError("body")
+
+    expected = {
+        "startup": ["start:a", "start:b", "stop:a", "dispose"],
+        "shutdown": ["start:a", "start:b", "start:c", "stop:c", "stop:b", "stop:a", "dispose"],
+        "body": ["start:a", "start:b", "start:c", "stop:c", "stop:b", "stop:a", "dispose"],
+        "migration": ["dispose"],
+    }
+    assert calls == expected[failure]

{simple_module_hosting-0.0.39 → simple_module_hosting-0.0.40}/tests/test_setup_migrate_error_redaction.py

@@ -8,6 +8,18 @@ import pytest
 from alembic import command
 from fastapi import HTTPException
 from simple_module_hosting.setup_wizard.migrate import apply_migrations
+from sqlalchemy.engine import make_url
+
+
+def _request(correlation_id):
+    engine = SimpleNamespace(url=make_url("sqlite+aiosqlite:///:memory:"))
+    return SimpleNamespace(
+        state=SimpleNamespace(correlation_id=correlation_id),
+        app=SimpleNamespace(
+            state=SimpleNamespace(sm=SimpleNamespace(db=SimpleNamespace(engine=engine)))
+        ),
+    )
+
 
 _SECRET = "postgresql://admin:hunter2@db.internal/prod"
 
@@ -17,7 +29,7 @@ async def test_migration_failure_detail_is_redacted(monkeypatch, caplog) -> None
         raise RuntimeError(f"could not connect to {_SECRET}")
 
     monkeypatch.setattr(command, "upgrade", _boom)
-    request = SimpleNamespace(state=SimpleNamespace(correlation_id="cid-123"))
+    request = _request("cid-123")
 
     with pytest.raises(HTTPException) as info:
         await apply_migrations(request, {})
@@ -45,7 +57,7 @@ async def test_in_process_migration_keeps_app_logging(monkeypatch) -> None:
         raise RuntimeError("stop after clobbering")
 
     monkeypatch.setattr(command, "upgrade", _clobber)
-    request = SimpleNamespace(state=SimpleNamespace(correlation_id=""))
+    request = _request("")
     try:
         with pytest.raises(HTTPException):
             await apply_migrations(request, {})

simple_module_hosting-0.0.40/tests/test_setup_migrate_worker_lock.py

@@ -0,0 +1,74 @@
+"""Independent wizard workers must serialize even on a fresh database (#634)."""
+
+import asyncio
+import importlib.util
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+from alembic import command
+from simple_module_hosting.setup_wizard import migrate
+from simple_module_hosting.setup_wizard._migration_lock import migration_lock
+from sqlalchemy.engine import make_url
+
+
+def test_independent_workers_serialize_migrations(monkeypatch, tmp_path):
+    # Separate module globals reproduce workers with distinct asyncio locks.
+    spec = importlib.util.spec_from_file_location("other_worker", migrate.__file__)
+    other = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(other)
+    active = maximum = 0
+    guard = threading.Lock()
+    ready = threading.Barrier(2)
+
+    def upgrade(config, target):
+        nonlocal active, maximum
+        assert target == "heads"
+        with guard:
+            active += 1
+            maximum = max(maximum, active)
+        time.sleep(0.1)  # intentional-sleep: hold the lock so an overlap would show
+        with guard:
+            active -= 1
+
+    async def inline_thread(func):
+        ready.wait(timeout=5)
+        return func()
+
+    monkeypatch.setattr(asyncio, "to_thread", inline_thread)
+    monkeypatch.setattr(command, "upgrade", upgrade)
+    monkeypatch.setattr("simple_module_hosting.migrations.migration_status", AsyncMock())
+    monkeypatch.setattr(migrate, "run_deferred_startup", AsyncMock())
+    monkeypatch.setattr(other, "run_deferred_startup", AsyncMock())
+    url = make_url(f"sqlite+aiosqlite:///{tmp_path / 'fresh.db'}")
+
+    def request():
+        return SimpleNamespace(
+            app=SimpleNamespace(
+                state=SimpleNamespace(
+                    sm=SimpleNamespace(db=SimpleNamespace(engine=SimpleNamespace(url=url)))
+                )
+            ),
+            state=SimpleNamespace(),
+        )
+
+    with ThreadPoolExecutor(max_workers=2) as workers:
+        futures = [
+            workers.submit(asyncio.run, worker.apply_migrations(request(), {}))
+            for worker in [migrate, other]
+        ]
+        for future in futures:
+            future.result(timeout=5)
+    assert maximum == 1
+
+
+def test_sqlite_migration_lock_released_on_failure(tmp_path):
+    url = make_url(f"sqlite+aiosqlite:///{tmp_path / 'fresh.db'}")
+    with pytest.raises(RuntimeError, match="migration failed"), migration_lock(url):
+        raise RuntimeError("migration failed")
+    # Reacquiring on another connection must work after an exception.
+    with migration_lock(url):
+        pass