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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.40
+Version: 0.0.42
 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.159,>=0.140
+Requires-Dist: fastapi<0.160,>=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.40
-Requires-Dist: simple-module-db==0.0.40
-Requires-Dist: simple-module-inertia==0.0.40
+Requires-Dist: simple-module-core==0.0.42
+Requires-Dist: simple-module-db==0.0.42
+Requires-Dist: simple-module-inertia==0.0.42
 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.40 → simple_module_hosting-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.40"
+version = "0.0.42"
 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.159",
+    "fastapi>=0.140,<0.160",
     "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.40",
-    "simple_module_db==0.0.40",
-    "simple_module_inertia==0.0.40",
+    "simple_module_core==0.0.42",
+    "simple_module_db==0.0.42",
+    "simple_module_inertia==0.0.42",
     "starlette>=0.44,<2",
     "tomlkit>=0.13,<0.16",
     "uvicorn[standard]>=0.34,<0.55",

{simple_module_hosting-0.0.40 → simple_module_hosting-0.0.42}/simple_module_hosting/__init__.py

@@ -2,6 +2,7 @@
 
 from simple_module_hosting._preapp_config import merge_host_settings
 from simple_module_hosting.app_builder import create_app
+from simple_module_hosting.errors import render_error_page
 from simple_module_hosting.logging import correlation_id, setup_logging
 from simple_module_hosting.settings import Settings
 from simple_module_hosting.shared_props import (
@@ -16,5 +17,6 @@ __all__ = [
     "create_app",
     "merge_host_settings",
     "register_inertia_shared_provider",
+    "render_error_page",
     "setup_logging",
 ]

{simple_module_hosting-0.0.40 → simple_module_hosting-0.0.42}/simple_module_hosting/_deferred_startup.py

@@ -11,6 +11,7 @@ from simple_module_core.module_settings import get_module_settings_registry
 from simple_module_db.stored_settings import SessionOverrideSource, settings_table_exists
 
 from simple_module_hosting._hydrate_step import hydrate_all
+from simple_module_hosting.data_compatibility import check_data_compatibility
 
 logger = logging.getLogger(__name__)
 
@@ -45,8 +46,13 @@ async def run_deferred_startup(app: FastAPI) -> None:
     operator's out-of-band ``make migrate``) still finishes starting its
     modules. Serialised per app; a hook that fails again is logged and dropped
     rather than raised, because this runs after the migrations have already
-    committed and a 500 there would help nobody.
+    committed. Compatibility checks run first and still raise: an incompatible
+    security state must keep the setup gate closed.
     """
+    pending_checks = getattr(app.state, "deferred_data_compatibility", None)
+    if pending_checks:
+        await check_data_compatibility(app, pending_checks)
+        app.state.deferred_data_compatibility = []
     deferred = get_deferred_startup(app)
     if not deferred:
         return

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

@@ -22,6 +22,7 @@ from simple_module_core.app_state import get_migration_status
 
 from simple_module_hosting._deferred_startup import hydrate_settings_from_db
 from simple_module_hosting._route_guard import guard_included_routers
+from simple_module_hosting.data_compatibility import check_data_compatibility
 from simple_module_hosting.migrations import migration_status
 from simple_module_hosting.setup_gate import STEP_MIGRATIONS
 
@@ -114,6 +115,16 @@ def build_lifespan(modules: Sequence) -> Callable:
                     f"{app.state.migration['head_revision']!r}). Run: make migrate"
                 )
 
+            # Only a schema at head can be judged: a first run that stopped part-way
+            # still has pre-upgrade columns, and refusing it would hide the wizard
+            # that finishes the migration. The setup gate runs deferred checks
+            # once the schema is current.
+            migration = app.state.migration
+            if migration["is_current"] and migration.get("current_revision") is not None:
+                await check_data_compatibility(app, modules)
+            else:
+                app.state.deferred_data_compatibility = list(modules)
+
             await hydrate_settings_from_db(app)
 
             # Behind head on a first run the tables a module's on_startup reads do

simple_module_hosting-0.0.42/simple_module_hosting/data_compatibility.py

@@ -0,0 +1,37 @@
+"""Enforce module data compatibility before hydrated settings and startup."""
+
+import logging
+from collections.abc import Sequence
+
+from fastapi import FastAPI
+from simple_module_core.data_compatibility import checking_modules, collect_data_compatibility
+from simple_module_core.module import ModuleBase
+
+logger = logging.getLogger(__name__)
+
+
+class DataCompatibilityError(RuntimeError):
+    """An incompatible security state must also keep the setup gate closed."""
+
+
+async def check_data_compatibility(app: FastAPI, modules: Sequence[ModuleBase]) -> None:
+    modules = checking_modules(modules)
+    if not modules:
+        return
+    try:
+        async with app.state.sm.db.session_factory() as db:
+            issues = await collect_data_compatibility(modules, db)
+    except Exception as exc:
+        # Log the cause here: callers such as the setup gate only see the verdict.
+        logger.exception("Module data compatibility check failed")
+        if app.state.sm.settings.environment == "development":
+            return
+        raise DataCompatibilityError("Could not check module data compatibility") from exc
+    errors = []
+    for issue in issues:
+        message = f"{issue.upgrade_id}: {issue.message} Prepare: {issue.remediation()}"
+        logger.warning(message)
+        if issue.severity == "error":
+            errors.append(message)
+    if errors and app.state.sm.settings.environment != "development":
+        raise DataCompatibilityError("Data compatibility upgrade required:\n" + "\n".join(errors))

simple_module_hosting-0.0.42/simple_module_hosting/errors.py

@@ -0,0 +1,28 @@
+"""Public error rendering for module exception handlers (#684)."""
+
+from collections.abc import Mapping
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+from simple_module_hosting._error_negotiation import _wants_json
+from simple_module_hosting._error_page import render_error_page as _render_error_page
+
+
+async def render_error_page(
+    request: Request,
+    status_code: int,
+    detail: str,
+    headers: Mapping[str, str] | None = None,
+    *,
+    required_permission: str | None = None,
+) -> Response:
+    """Return standard JSON for API clients or the Inertia Error page for browsers.
+
+    Uses the framework's content negotiation, shared layout props and rendering
+    fallback. Status and supplied headers survive either response format.
+    ``required_permission`` optionally identifies the permission a 403 lacked.
+    """
+    if _wants_json(request):
+        return JSONResponse(status_code=status_code, content={"detail": detail}, headers=headers)
+    return await _render_error_page(request, status_code, detail, headers, required_permission)

{simple_module_hosting-0.0.40 → simple_module_hosting-0.0.42}/simple_module_hosting/setup_gate.py

@@ -23,6 +23,7 @@ from starlette.types import ASGIApp, Receive, Scope, Send
 
 from simple_module_hosting import migrations
 from simple_module_hosting._deferred_startup import run_deferred_startup
+from simple_module_hosting.data_compatibility import DataCompatibilityError
 
 logger = logging.getLogger(__name__)
 _migration_failure_warned = False
@@ -74,6 +75,11 @@ async def _database_migrated(app) -> bool:
     if not status:
         return True
     if status.get("is_current", True):
+        if getattr(app.state, "deferred_data_compatibility", None):
+            try:
+                await run_deferred_startup(app)
+            except DataCompatibilityError:
+                return False
         return True
 
     try:
@@ -90,9 +96,12 @@ async def _database_migrated(app) -> bool:
     if status["is_current"]:
         # Finish starting the modules whose on_startup needed these tables —
         # this worker may not be the one that ran the migrations. Never lets
-        # a failure there change the verdict, which only reports the schema.
+        # an ordinary startup-hook failure change the schema verdict. A failed
+        # data compatibility check must keep the gate closed.
         try:
             await run_deferred_startup(app)
+        except DataCompatibilityError:
+            return False
         except Exception:
             logger.exception("Replaying deferred on_startup hooks failed")
     return bool(status["is_current"])

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

@@ -16,6 +16,7 @@ from collections.abc import Generator
 from fastapi import HTTPException, Request
 
 from simple_module_hosting._deferred_startup import run_deferred_startup
+from simple_module_hosting.data_compatibility import DataCompatibilityError
 from simple_module_hosting.setup_wizard._migration_lock import migration_lock
 
 logger = logging.getLogger(__name__)
@@ -87,6 +88,13 @@ async def apply_migrations(request: Request, _data: dict) -> dict:
 
     request.app.state.migration = await migration_status(request.app.state.sm.db.engine)
     # Modules whose on_startup could not run before the tables existed.
-    await run_deferred_startup(request.app)
+    try:
+        await run_deferred_startup(request.app)
+    except DataCompatibilityError as exc:
+        # The detail names upgrade ids and the remediation command, never data.
+        logger.error("Setup: %s", exc)
+        raise HTTPException(
+            status_code=409, detail="A module data upgrade is required; see the server log."
+        ) from exc
     logger.info("Setup: migrations applied")
     return {"migration": request.app.state.migration}

simple_module_hosting-0.0.42/tests/test_hosting_data_compatibility.py

@@ -0,0 +1,165 @@
+"""Compatibility errors gate established hosts before settings or startup (#711)."""
+
+from types import SimpleNamespace
+
+import pytest
+from fastapi import FastAPI
+from simple_module_core.module import ModuleBase, ModuleMeta
+from simple_module_hosting._lifespan import build_lifespan
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+
+@pytest.mark.parametrize(
+    ("environment", "severity", "never_migrated", "refuses"),
+    [
+        ("production", "error", False, True),
+        ("testing", "error", False, True),
+        ("development", "error", False, False),
+        ("production", "warning", False, False),
+        ("production", "error", True, False),
+    ],
+)
+async def test_hosting_compatibility_before_hydration(
+    monkeypatch, environment, severity, never_migrated, refuses
+):
+    from simple_module_core.data_compatibility import DataCompatibilityIssue
+
+    events = []
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            events.append("check")
+            return [
+                DataCompatibilityIssue(
+                    upgrade_id="example.v1", message="Upgrade", severity=severity
+                )
+            ]
+
+        async def on_startup(self, app):
+            events.append("startup")
+
+    async def status(engine):
+        return {"is_current": True, "current_revision": None if never_migrated else "local"}
+
+    async def hydrate(app):
+        events.append("hydrate")
+
+    monkeypatch.setattr("simple_module_hosting._lifespan.migration_status", status)
+    monkeypatch.setattr("simple_module_hosting._lifespan.hydrate_settings_from_db", hydrate)
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    app = FastAPI()
+    app.state.sm = SimpleNamespace(
+        db=SimpleNamespace(engine=engine, session_factory=async_sessionmaker(engine)),
+        settings=SimpleNamespace(environment=environment),
+    )
+    if refuses:
+        with pytest.raises(RuntimeError, match=r"example\.v1"):
+            async with build_lifespan([Module()])(app):
+                pass
+        assert events == ["check"]
+    else:
+        async with build_lifespan([Module()])(app):
+            assert events == (
+                ["hydrate", "startup"] if never_migrated else ["check", "hydrate", "startup"]
+            )
+
+
+async def test_partly_migrated_first_run_defers_the_check(monkeypatch):
+    # A first run that stopped part-way has a revision but pre-upgrade columns:
+    # judging it would refuse the boot and hide the wizard that finishes it.
+    events = []
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            events.append("check")
+            return []
+
+    async def status(engine):
+        return {"is_current": False, "current_revision": "partial", "pending_count": 3}
+
+    async def first_run(app):
+        return True
+
+    async def hydrate(app):
+        events.append("hydrate")
+
+    monkeypatch.setattr("simple_module_hosting._lifespan.migration_status", status)
+    monkeypatch.setattr("simple_module_hosting._lifespan._is_first_run", first_run)
+    monkeypatch.setattr("simple_module_hosting._lifespan.hydrate_settings_from_db", hydrate)
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    app = FastAPI()
+    app.state.sm = SimpleNamespace(
+        db=SimpleNamespace(engine=engine, session_factory=async_sessionmaker(engine)),
+        settings=SimpleNamespace(environment="production"),
+    )
+    async with build_lifespan([Module()])(app):
+        assert "check" not in events
+        assert app.state.deferred_data_compatibility
+
+
+async def test_hosting_deferred_checks_gate_replay_before_hydration(monkeypatch):
+    from simple_module_core.data_compatibility import DataCompatibilityIssue
+    from simple_module_hosting._deferred_startup import run_deferred_startup
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            return [
+                DataCompatibilityIssue(upgrade_id="example.v1", message="Upgrade", severity="error")
+            ]
+
+    app = FastAPI()
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    app.state.sm = SimpleNamespace(
+        db=SimpleNamespace(engine=engine, session_factory=async_sessionmaker(engine)),
+        settings=SimpleNamespace(environment="production"),
+    )
+    app.state.deferred_data_compatibility = [Module()]
+    app.state.deferred_startup = []
+    try:
+        with pytest.raises(RuntimeError, match=r"example\.v1"):
+            await run_deferred_startup(app)
+        assert app.state.deferred_data_compatibility
+    finally:
+        await engine.dispose()
+
+
+@pytest.mark.parametrize("check_raises", [False, True])
+async def test_hosting_setup_gate_keeps_incompatible_replay_closed(monkeypatch, check_raises):
+    from simple_module_core.data_compatibility import DataCompatibilityIssue
+    from simple_module_hosting.setup_gate import _database_migrated
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            if check_raises:
+                raise RuntimeError("database unavailable")
+            return [
+                DataCompatibilityIssue(upgrade_id="example.v1", message="Upgrade", severity="error")
+            ]
+
+    app = FastAPI()
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    app.state.sm = SimpleNamespace(
+        db=SimpleNamespace(engine=engine, session_factory=async_sessionmaker(engine)),
+        settings=SimpleNamespace(environment="production"),
+    )
+    app.state.migration = {"is_current": False, "current_revision": None}
+    app.state.deferred_data_compatibility = [Module()]
+    app.state.deferred_startup = []
+
+    async def status(engine):
+        return {"is_current": True, "current_revision": "local"}
+
+    monkeypatch.setattr("simple_module_hosting.setup_gate.migrations.migration_status", status)
+    try:
+        assert await _database_migrated(app) is False
+        assert await _database_migrated(app) is False
+    finally:
+        await engine.dispose()

simple_module_hosting-0.0.42/tests/test_hosting_public_error_page.py

@@ -0,0 +1,36 @@
+"""Modules can use the public renderer with standard content negotiation (#684)."""
+
+import pytest
+from fastapi import Request
+
+
+@pytest.mark.parametrize(
+    "headers, json_response",
+    [
+        ({"Accept": "application/json"}, True),
+        ({"Accept": "text/html"}, False),
+        ({"Accept": "application/json", "X-Inertia": "true"}, False),
+    ],
+)
+async def test_public_renderer_negotiates_and_preserves_status_and_headers(
+    app, authenticated_client, headers, json_response
+):
+    from simple_module_hosting import render_error_page
+
+    async def custom_error(request: Request):
+        return await render_error_page(
+            request, 429, detail="Try later", headers={"Retry-After": "30"}
+        )
+
+    app.add_api_route("/custom-error", custom_error)
+    response = await authenticated_client.get("/custom-error", headers=headers)
+    assert response.status_code == 429
+    assert response.headers["Retry-After"] == "30"
+    if json_response:
+        assert response.json() == {"detail": "Try later"}
+    elif "X-Inertia" in headers:
+        assert response.json()["component"] == "Error"
+        assert response.json()["props"]["message"] == "Try later"
+    else:
+        assert "data-page" in response.text
+        assert "Try later" in response.text

{simple_module_hosting-0.0.40 → simple_module_hosting-0.0.42}/tests/test_lifespan_deferred_startup.py

@@ -53,7 +53,10 @@ async def test_failing_hook_is_deferred_then_replayed_on_unmigrated_first_run():
     async def capture(app_):
         seen["deferred"] = [m.meta.name for m in app_.state.deferred_startup]
 
-    with patch("simple_module_hosting._deferred_startup.hydrate_settings_from_db", AsyncMock()):
+    with (
+        patch("simple_module_hosting._deferred_startup.hydrate_settings_from_db", AsyncMock()),
+        patch("simple_module_hosting._deferred_startup.check_data_compatibility", AsyncMock()),
+    ):
         status = {"is_current": False, "pending_count": 1}
         with (
             patch(