simple-module-hosting 0.0.34__tar.gz → 0.0.35__tar.gz

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.34
+Version: 0.0.35
 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>=8.1
-Requires-Dist: fastapi-inertia>=1.0
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: itsdangerous>=2.0
 Requires-Dist: jinja2>=3.1
-Requires-Dist: simple-module-core==0.0.34
-Requires-Dist: simple-module-db==0.0.34
+Requires-Dist: simple-module-core==0.0.35
+Requires-Dist: simple-module-db==0.0.35
+Requires-Dist: simple-module-inertia==0.0.35
 Requires-Dist: starlette>=0.44
 Requires-Dist: tomlkit>=0.13
 Requires-Dist: uvicorn[standard]>=0.34

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.34"
+version = "0.0.35"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -23,15 +23,15 @@ classifiers = [
 dependencies = [
     "click>=8.1",
     "fastapi>=0.115",
-    "fastapi-inertia>=1.0",
     "httpx>=0.27",
     # 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",
     "jinja2>=3.1",
-    "simple_module_core==0.0.34",
-    "simple_module_db==0.0.34",
+    "simple_module_core==0.0.35",
+    "simple_module_db==0.0.35",
+    "simple_module_inertia==0.0.35",
     "starlette>=0.44",
     "tomlkit>=0.13",
     "uvicorn[standard]>=0.34",
@@ -59,3 +59,4 @@ packages = ["simple_module_hosting"]
 [tool.uv.sources]
 simple_module_core = { workspace = true }
 simple_module_db = { workspace = true }
+simple_module_inertia = { workspace = true }

simple_module_hosting-0.0.35/simple_module_hosting/_dev_boot.py

@@ -0,0 +1,83 @@
+"""Development-only boot work: the diagnostics run and the frontend artifacts.
+
+Extracted from ``app_builder`` so that file reads as the phase sequence and
+nothing else. Everything here is gated on ``settings.is_development`` at the one
+call site, and everything here reads or writes the *source tree* — a deployed
+wheel has no ``host/client_app`` to write a manifest into and no module sources
+for the AST checks to walk, which is why none of it belongs on a production boot
+path.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from simple_module_core.diagnostics import DiagnosticLevel, print_diagnostics, run_diagnostics
+
+from simple_module_hosting.i18n_manifest import emit_frontend_types_for_modules
+
+if TYPE_CHECKING:
+    from simple_module_core import ModuleBase
+    from simple_module_core.services import DiagnosticsState
+
+    from simple_module_hosting.settings import Settings
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["run_dev_boot"]
+
+
+def run_dev_boot(
+    settings: Settings,
+    modules: list[ModuleBase],
+    installed_modules: list[ModuleBase],
+    *,
+    i18n_extra,
+    diagnostics_state: DiagnosticsState,
+    project_root: Path,
+) -> None:
+    """Run the module diagnostics and emit the frontend's generated files.
+
+    ``diagnostics_state.runner`` is left behind on purpose, not just used: the
+    in-app Doctor screen re-invokes this exact call through ``rerun()``, and
+    re-deriving the arguments from a request would mean re-discovering modules.
+
+    An ERROR-level diagnostic ends the process. A developer whose module has a
+    duplicate name or a framework→plugin import gets one clear message here
+    instead of an inexplicable failure several phases later — and the same
+    checks run at production boot, where the app would refuse to start anyway.
+    """
+    diagnostics_state.runner = lambda: run_diagnostics(
+        modules,
+        i18n_supported_locales=settings.i18n_supported_locales,
+        i18n_default_locale=settings.i18n_default_locale,
+        i18n_extra_sources=i18n_extra,
+    )
+    diagnostics = diagnostics_state.rerun()
+    errors = [d for d in diagnostics if d.level == DiagnosticLevel.ERROR]
+    if diagnostics:
+        print_diagnostics(diagnostics)
+    if errors:
+        raise SystemExit(f"Module diagnostics: {len(errors)} error(s). Fix before continuing.")
+
+    _write_pages_manifest(modules, project_root)
+    emit_frontend_types_for_modules(settings, installed_modules, project_root)
+
+
+def _write_pages_manifest(modules: list[ModuleBase], project_root: Path) -> None:
+    """Tell Vite where pages shipped inside pip-installed wheels live.
+
+    Swallows its own failure: a missing or unwritable ``client_app`` must not
+    stop the API from booting, and the symptom — pages the frontend cannot find
+    — is loud enough on its own. See ``scaffolding.py``.
+    """
+    try:
+        from simple_module_hosting.manifest import write_module_pages_manifest
+
+        client_app = project_root / "host" / "client_app"
+        if client_app.is_dir():
+            write_module_pages_manifest(modules, client_app)
+    except Exception:
+        logger.exception("Failed to write module pages manifest — frontend may miss pages")

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/_error_handlers.py

@@ -9,19 +9,18 @@ from http import HTTPStatus
 from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
-from inertia import (
+from simple_module_core.exceptions import NotFoundError
+from simple_module_inertia import (
     Inertia,
     InertiaConfig,
     InertiaVersionConflictException,
     inertia_version_conflict_exception_handler,
 )
-from simple_module_core.exceptions import NotFoundError
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.responses import Response
 
 from simple_module_hosting._inertia_shared import _INERTIA_HEADER
-from simple_module_hosting._inertia_url import patch_relative_page_url
 from simple_module_hosting.permissions import PERMISSION_DENIED_PREFIX
 
 logger = logging.getLogger(__name__)
@@ -174,20 +173,17 @@ async def render_error_page(
         # that raises while reporting an error leaves the caller with nothing.
         config: InertiaConfig = request.app.state.sm.inertia_config
         # Prefer the app's configured dependency over constructing Inertia
-        # directly: it carries the framework's wraps, and an error page built
-        # around them is an error page rendered differently from every other
-        # page. That is how the 404 kept throwing the cross-scheme `pushState`
-        # SecurityError after the page url was made relative everywhere else.
-        # The raw construction stays as the fallback for a half-built app —
-        # the case this whole handler exists to survive — but still goes
-        # through the same url-relativizing patch directly: a fallback that
-        # skipped it would reintroduce the exact bug this module exists to
-        # fix, just for the one request that hit it before setup finished.
+        # directly, so the error page is built the same way as every other
+        # page. The raw construction is the fallback for a half-built app —
+        # the case this whole handler exists to survive. Both paths emit a
+        # root-relative page url: the adapter does that by construction now,
+        # so the fallback no longer needs a separate patch to avoid the
+        # cross-scheme `pushState` SecurityError behind a TLS proxy.
         inertia_dep = getattr(request.app.state, "inertia_dependency", None)
         if inertia_dep is not None:
             inertia = inertia_dep(request, None)
         else:
-            inertia = patch_relative_page_url(Inertia(request, config))
+            inertia = Inertia(request, config)
         # This does not go through get_inertia, so the share step has to be
         # repeated here. Without it the error page renders raw translation keys
         # (host.error.not_found_title) and loses auth/menus, so a signed-in

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/_inertia_setup.py

@@ -1,20 +1,15 @@
-"""Configure fastapi-inertia with the Jinja2 template."""
+"""Configure simple_module_inertia with the Jinja2 template."""
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
-import tempfile
 from pathlib import Path
 
 from fastapi import FastAPI
-from inertia import InertiaConfig, inertia_dependency_factory
+from simple_module_inertia import InertiaConfig, inertia_dependency_factory
 from starlette.requests import Request
 
 from simple_module_hosting._favicon import default_favicon_data_uri
-from simple_module_hosting._inertia_json import json_safe_inertia_dependency
-from simple_module_hosting._inertia_url import relative_page_url_dependency
 from simple_module_hosting.settings import Settings
 
 logger = logging.getLogger(__name__)
@@ -28,6 +23,12 @@ _ROOT_DIRECTORY = "."
 # branding's own default so the unbranded title is identical everywhere.
 _DEFAULT_APP_NAME = "SimpleModule"
 
+# Built assets are served from the "/static" mount under "dist/", so production
+# asset URLs are prefixed with "static/dist". The manifest is read where Vite
+# writes it; the adapter looks the entry up by Vite's own key.
+_ASSETS_PREFIX = "static/dist"
+_VITE_MANIFEST_RELPATH = Path("static") / "dist" / ".vite" / "manifest.json"
+
 
 def branding_head(request: Request) -> dict:
     """Branding metadata for the root template's ``<head>``.
@@ -61,59 +62,19 @@ def branding_head(request: Request) -> dict:
     }
 
 
-# Built assets are served from the "/static" mount under "dist/", so production
-# asset URLs are prefixed with "static/dist".
-_ASSETS_PREFIX = "static/dist"
-_VITE_MANIFEST_RELPATH = Path("static") / "dist" / ".vite" / "manifest.json"
-
-
 def _prod_manifest_path(project_root: Path) -> str:
-    """Return a manifest path fastapi-inertia can read in production.
-
-    fastapi-inertia looks the entry up by ``f"{root_directory}/{entrypoint}"``
-    (here ``"./main.tsx"``), but Vite keys its manifest by the entry's path
-    relative to the Vite root (``"main.tsx"``) — so the raw Vite manifest would
-    ``KeyError``. Read it, re-key the ``isEntry`` chunk under the key
-    fastapi-inertia expects, and write the normalized copy beside the build
-    output (falling back to a temp file if that dir is read-only). Returns ``""``
-    when no built manifest exists, leaving production assets unconfigured rather
-    than crashing at import time.
-    """
+    """The Vite manifest to read in production, or ``""`` when none is built."""
     candidates = [
         project_root / "host" / _VITE_MANIFEST_RELPATH,
         project_root / _VITE_MANIFEST_RELPATH,
     ]
-    vite_manifest = next((p for p in candidates if p.is_file()), None)
-    if vite_manifest is None:
+    found = next((p for p in candidates if p.is_file()), None)
+    if found is None:
         logger.warning(
             "Production Vite manifest not found (looked in %s)", [str(c) for c in candidates]
         )
         return ""
-    try:
-        data = json.loads(vite_manifest.read_text())
-        expected_key = f"{_ROOT_DIRECTORY}/{_ENTRYPOINT_FILENAME}"
-        if expected_key not in data:
-            entry = next((v for v in data.values() if v.get("isEntry")), None)
-            if entry is None:
-                # No entry to re-key: degrade gracefully (same as no-manifest)
-                # rather than returning a path that KeyErrors at render time.
-                logger.warning("No isEntry chunk in Vite manifest %s", vite_manifest)
-                return ""
-            data = {**data, expected_key: entry}
-        out = vite_manifest.parent / "inertia-manifest.json"
-        try:
-            out.write_text(json.dumps(data))
-        except OSError:
-            # Build dir read-only (e.g. immutable container layer): fall back to
-            # a temp file keyed by the source manifest path so multiple apps on
-            # one host don't clobber each other's normalized manifests.
-            digest = hashlib.sha1(str(vite_manifest).encode()).hexdigest()[:12]
-            out = Path(tempfile.gettempdir()) / f"sm-inertia-manifest-{digest}.json"
-            out.write_text(json.dumps(data))
-        return str(out)
-    except Exception:
-        logger.exception("Failed to prepare production Inertia manifest from %s", vite_manifest)
-        return ""
+    return str(found)
 
 
 def setup_inertia(
@@ -122,7 +83,7 @@ def setup_inertia(
     modules: list,
     project_root: Path,
 ) -> InertiaConfig | None:
-    """Configure fastapi-inertia and attach the dependency factory to app.state.
+    """Configure the Inertia adapter and attach the dependency factory to app.state.
 
     Two host layouts are supported: ``host/templates`` (the framework's
     own host package) and ``templates`` at the project root (what
@@ -165,14 +126,9 @@ def setup_inertia(
     # Expose branding metadata to the root template (pre-hydration head tags).
     templates.env.globals["branding_head"] = branding_head
 
-    # fastapi-inertia only switches to the asset manifest when environment
-    # equals the literal string "production". Anything else (staging, qa,
-    # ...) would render a /main.tsx <script> tag served by the SPA fallback
-    # as text/html, breaking module loading. Normalize:
-    #   * `development`/`testing` → keep the dev-server path (Vite serves
-    #     /main.tsx directly).
-    #   * Anything else (staging, production, qa, ...) → use the production
-    #     manifest so built assets are referenced.
+    # The adapter only switches to the asset manifest when environment equals
+    # the literal "production"; normalise anything non-dev (staging, qa, ...)
+    # to that so built assets are referenced rather than a Vite dev url.
     from simple_module_core.environments import NON_PROD_ENVIRONMENTS
 
     use_dev_server = settings.environment in NON_PROD_ENVIRONMENTS
@@ -182,8 +138,6 @@ def setup_inertia(
         environment=inertia_environment,
         version=_INERTIA_VERSION,
         dev_url=settings.vite_dev_url if use_dev_server else "",
-        # Production reads built assets from the Vite manifest; dev serves them
-        # from the Vite dev server, so these only matter when not use_dev_server.
         manifest_json_path="" if use_dev_server else _prod_manifest_path(project_root),
         assets_prefix="" if use_dev_server else _ASSETS_PREFIX,
         templates=templates,
@@ -192,16 +146,5 @@ def setup_inertia(
         root_directory=_ROOT_DIRECTORY,
         use_flash_errors=True,
     )
-
-    # Two wraps over the stock dependency, each closing a gap in upstream:
-    #   * JSON branch builds a Starlette JSONResponse directly, so the encoder
-    #     configured above only ever applies to full page loads — wrap it so a
-    #     client-side visit encodes the same props the same way.
-    #   * The page url is absolute, which the browser rejects for pushState
-    #     behind a TLS-terminating proxy — wrap it back to the root-relative
-    #     path the Inertia protocol specifies.
-    inertia_dep = relative_page_url_dependency(
-        json_safe_inertia_dependency(inertia_dependency_factory(inertia_config))
-    )
-    app.state.inertia_dependency = inertia_dep
+    app.state.inertia_dependency = inertia_dependency_factory(inertia_config)
     return inertia_config

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/_phase_helpers.py

@@ -14,13 +14,13 @@ from typing import TYPE_CHECKING
 from fastapi import FastAPI
 from fastapi.exceptions import RequestValidationError
 from fastapi.staticfiles import StaticFiles
-from inertia import (
-    InertiaVersionConflictException,
-    inertia_version_conflict_exception_handler,
-)
 from simple_module_core.diagnostics import Diagnostic, DiagnosticLevel
 from simple_module_core.exceptions import NotFoundError
 from simple_module_db import CommitBeforeResponseMiddleware
+from simple_module_inertia import (
+    InertiaVersionConflictException,
+    inertia_version_conflict_exception_handler,
+)
 from starlette.exceptions import HTTPException
 from starlette.middleware.gzip import GZipMiddleware
 from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
@@ -145,6 +145,10 @@ def install_middleware(
     )
     if settings.multi_tenant:
         app.add_middleware(TenantMiddleware, header=settings.tenant_header or None)
+    elif settings.default_tenant:
+        # Single-tenant host with tenant-scoped tables: every request is the
+        # one tenant (#359). Never used with multi_tenant — no shared fallback.
+        app.add_middleware(TenantMiddleware, fixed=settings.default_tenant)
     for mod in modules:
         mod.register_middleware(app)
     app.add_middleware(SessionMiddleware, secret_key=settings.secret_key)

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/_registrations.py

@@ -19,6 +19,7 @@ def run_module_registrations(
     *,
     app: FastAPI,
     event_bus,
+    invalidation_bus,
     menu_registry,
     perm_registry,
     ff_registry,
@@ -42,6 +43,7 @@ def run_module_registrations(
         mod.register_permissions(perm_registry)
         mod.register_feature_flags(ff_registry)
         dispatch_event_handlers(mod, event_bus, app)
+        mod.register_invalidations(invalidation_bus, app)
         health_registry.set_owner(mod.meta.name)
         mod.register_health_checks(health_registry)
         mod.register_public_routes(public_route_registry)

simple_module_hosting-0.0.35/simple_module_hosting/_tenant.py

@@ -0,0 +1,97 @@
+"""Tenant-context middleware: which tenant a request acts for."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+
+from simple_module_db import current_tenant_id, is_valid_tenant_id
+from starlette.datastructures import Headers
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+_SCOPE_HTTP = "http"
+
+TENANT_HEADER = "X-Tenant-ID"
+
+
+TenantResolver = Callable[[Request], Awaitable[str | None]]
+"""Module-owned tenant resolution, registered as ``app.state.tenant_resolver``.
+
+Returns the tenant the request acts for, or ``None``. It owns *every* source —
+membership, session, subdomain, header — so it is also where each is
+validated. Without one the middleware falls back to the principal's
+``tenant_id`` claim."""
+
+
+class TenantMiddleware:
+    """Establish the request's tenant context.
+
+    Sets the ``current_tenant_id`` context var so that DB queries on
+    :class:`~simple_module_db.mixins.MultiTenantMixin` models are
+    automatically filtered, and new objects get ``tenant_id`` populated.
+
+    Also stores the resolved value on ``request.state.tenant_id``.
+
+    Resolution:
+
+    1. If a module registered ``app.state.tenant_resolver`` (the ``tenants``
+       module does), its answer is final — including ``None``.
+    2. Otherwise the authenticated user's ``tenant_id`` attribute (from the
+       auth token claims).
+    3. Otherwise, for **anonymous** requests only, the configured header —
+       useful for API clients and tests. Pass ``header=None`` (the default)
+       to disable it. An authenticated user is never allowed to pick a tenant
+       by header: a user with no tenant of their own would otherwise be able
+       to name anyone's.
+    """
+
+    def __init__(
+        self, app: ASGIApp, *, header: str | None = None, fixed: str | None = None
+    ) -> None:
+        self.app = app
+        self.header = header
+        # Single-tenant hosts: one tenant for every request, nothing resolved.
+        self.fixed = fixed
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != _SCOPE_HTTP:
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        tenant_id = await self._resolve(request, scope)
+        request.state.tenant_id = tenant_id
+
+        if tenant_id is not None:
+            token = current_tenant_id.set(tenant_id)
+            try:
+                await self.app(scope, receive, send)
+            finally:
+                current_tenant_id.reset(token)
+            return
+
+        await self.app(scope, receive, send)
+
+    async def _resolve(self, request: Request, scope: Scope) -> str | None:
+        if self.fixed is not None:
+            return self.fixed
+        app = scope.get("app")
+        resolver: TenantResolver | None = getattr(
+            getattr(app, "state", None), "tenant_resolver", None
+        )
+        if resolver is not None:
+            return await resolver(request)
+
+        user = getattr(request.state, "user", None)
+        if user is not None:
+            return getattr(user, "tenant_id", None)
+
+        if self.header:
+            value = Headers(scope=scope).get(self.header)
+            # Unvalidated, an over-long value is a 500 on the first stamped
+            # write (VARCHAR(50)) and any junk becomes a tenant name (#366).
+            return value if is_valid_tenant_id(value) else None
+        return None
+
+
+__all__ = ["TENANT_HEADER", "TenantMiddleware", "TenantResolver"]

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/app_builder.py

@@ -10,11 +10,12 @@ from fastapi import FastAPI
 from simple_module_core import CspSourceRegistry
 from simple_module_core.audit_links import AuditLinkRegistry
 from simple_module_core.design_packs import DesignPackRegistry
-from simple_module_core.diagnostics import DiagnosticLevel, print_diagnostics, run_diagnostics
+from simple_module_core.diagnostics import print_diagnostics
 from simple_module_core.discovery import discover_modules, select_auth_provider, topological_sort
 from simple_module_core.events import EventBus
 from simple_module_core.feature_flags import FeatureFlagRegistry
 from simple_module_core.health import HealthRegistry
+from simple_module_core.invalidation import InvalidationBus
 from simple_module_core.menu import MenuRegistry
 from simple_module_core.permissions import PermissionRegistry
 from simple_module_core.public_routes import PublicRouteRegistry
@@ -24,6 +25,7 @@ from simple_module_db.listeners import register_listeners
 from simple_module_db.session import init_db
 
 from simple_module_hosting._db_health import register_database_check
+from simple_module_hosting._dev_boot import run_dev_boot
 from simple_module_hosting._inertia_setup import setup_inertia
 from simple_module_hosting._lifespan import build_lifespan
 from simple_module_hosting._phase_helpers import (
@@ -39,7 +41,7 @@ from simple_module_hosting._preapp_config import merge_host_settings
 from simple_module_hosting._registrations import run_module_registrations
 from simple_module_hosting._secret_key import assert_not_placeholder
 from simple_module_hosting.health import router as health_router
-from simple_module_hosting.i18n_manifest import build_i18n_registry, emit_frontend_types_for_modules
+from simple_module_hosting.i18n_manifest import build_i18n_registry
 from simple_module_hosting.settings import Settings
 from simple_module_hosting.setup_gate import register_migration_step
 from simple_module_hosting.static_files import PrecompressedStaticFiles
@@ -146,37 +148,21 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     # renders this exact result and its "Re-run checks" calls ``rerun()``.
     diagnostics_state = DiagnosticsState()
     if settings.is_development:
-        diagnostics_state.runner = lambda: run_diagnostics(
+        run_dev_boot(
+            settings,
             modules,
-            i18n_supported_locales=settings.i18n_supported_locales,
-            i18n_default_locale=settings.i18n_default_locale,
-            i18n_extra_sources=i18n_extra,
+            installed_modules,
+            i18n_extra=i18n_extra,
+            diagnostics_state=diagnostics_state,
+            project_root=_PROJECT_ROOT,
         )
-        diagnostics = diagnostics_state.rerun()
-        errors = [d for d in diagnostics if d.level == DiagnosticLevel.ERROR]
-        if diagnostics:
-            print_diagnostics(diagnostics)
-        if errors:
-            raise SystemExit(f"Module diagnostics: {len(errors)} error(s). Fix before continuing.")
-
-        # Emit frontend module-pages manifest so Vite can find pages shipped
-        # inside pip-installed module wheels. See scaffolding.py.
-        try:
-            from simple_module_hosting.manifest import write_module_pages_manifest
-
-            client_app = _PROJECT_ROOT / "host" / "client_app"
-            if client_app.is_dir():
-                write_module_pages_manifest(modules, client_app)
-        except Exception:
-            logger.exception("Failed to write module pages manifest — frontend may miss pages")
-
-        emit_frontend_types_for_modules(settings, installed_modules, _PROJECT_ROOT)
 
     # ── Phase 3: Create FastAPI app ────────────────────────
     menu_registry = MenuRegistry()
     perm_registry = PermissionRegistry()
     ff_registry = FeatureFlagRegistry()
     event_bus = EventBus()
+    invalidation_bus = InvalidationBus()
     health_registry = HealthRegistry()
     public_route_registry = PublicRouteRegistry()
     setup_registry = SetupRegistry()
@@ -211,6 +197,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         modules,
         app=app,
         event_bus=event_bus,
+        invalidation_bus=invalidation_bus,
         menu_registry=menu_registry,
         perm_registry=perm_registry,
         ff_registry=ff_registry,
@@ -248,6 +235,9 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         pool_pre_ping=settings.db_pool_pre_ping,
         pool_recycle=settings.db_pool_recycle,
     )
+    # Multi-tenant installs fail closed: a tenant-scoped query with no tenant
+    # context raises instead of reading every tenant's rows.
+    db_state.tenant_strict = settings.multi_tenant
     register_listeners(db_state)
     # The host's own readiness signal, and the only probe-safe check in a
     # default install — module checks reach third parties and are on-demand.
@@ -292,6 +282,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         i18n_registry=i18n_registry,
         inertia_config=inertia_config,
         modules=tuple(modules),
+        invalidation=invalidation_bus,
         diagnostics=diagnostics_state,
     )
 

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/host_settings.py

@@ -35,6 +35,12 @@ class HostSettings(BaseSettings):
 
     multi_tenant: bool = False
     tenant_header: str = ""
+    default_tenant: str = ""
+    """Single-tenant hosts (``multi_tenant`` off): the tenant every request acts
+    as, so a module's ``MultiTenantMixin`` tables work without a tenant
+    resolver. Ignored when ``multi_tenant`` is on — a multi-tenant install
+    never falls back to a shared tenant. Jobs and CLI commands use
+    ``tenant_context(settings.default_tenant)``."""
 
     maintenance_mode: bool = False
     """Serve everyone but admins a 503 page.
@@ -123,6 +129,16 @@ class HostSettings(BaseSettings):
             return None
         return value.strip() or None
 
+    @field_validator("default_tenant", mode="after")
+    @classmethod
+    def _check_default_tenant(cls, value: str) -> str:
+        from simple_module_db import is_valid_tenant_id
+
+        value = value.strip()
+        if value and not is_valid_tenant_id(value):
+            raise ValueError(f"default_tenant {value!r} is not a valid tenant id")
+        return value
+
     @model_validator(mode="after")
     def _check_default_locale_supported(self) -> HostSettings:
         if self.i18n_default_locale not in self.i18n_supported_locales:

{simple_module_hosting-0.0.34 → simple_module_hosting-0.0.35}/simple_module_hosting/inertia_deps.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import Annotated
 
 from fastapi import Depends, Request
-from inertia import Inertia
+from simple_module_inertia import Inertia
 
 
 async def get_inertia(request: Request) -> Inertia: