simple-module-hosting 0.0.19__tar.gz → 0.0.21__tar.gz

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/.gitignore

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

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_hosting
-Version: 0.0.19
+Version: 0.0.21
 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
@@ -26,8 +26,8 @@ Requires-Dist: fastapi-inertia>=1.0
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: jinja2>=3.1
-Requires-Dist: simple-module-core==0.0.19
-Requires-Dist: simple-module-db==0.0.19
+Requires-Dist: simple-module-core==0.0.21
+Requires-Dist: simple-module-db==0.0.21
 Requires-Dist: starlette>=0.44
 Requires-Dist: tomlkit>=0.13
 Requires-Dist: uvicorn[standard]>=0.34

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.19"
+version = "0.0.21"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -26,8 +26,8 @@ dependencies = [
     "fastapi-inertia>=1.0",
     "httpx>=0.27",
     "jinja2>=3.1",
-    "simple_module_core==0.0.19",
-    "simple_module_db==0.0.19",
+    "simple_module_core==0.0.21",
+    "simple_module_db==0.0.21",
     "starlette>=0.44",
     "tomlkit>=0.13",
     "uvicorn[standard]>=0.34",

simple_module_hosting-0.0.21/simple_module_hosting/__init__.py

@@ -0,0 +1,18 @@
+"""SimpleModule Hosting - App builder, module loader, middleware pipeline."""
+
+from simple_module_hosting.app_builder import create_app
+from simple_module_hosting.logging import correlation_id, setup_logging
+from simple_module_hosting.settings import Settings
+from simple_module_hosting.shared_props import (
+    SharedPropsProvider,
+    register_inertia_shared_provider,
+)
+
+__all__ = [
+    "Settings",
+    "SharedPropsProvider",
+    "correlation_id",
+    "create_app",
+    "register_inertia_shared_provider",
+    "setup_logging",
+]

simple_module_hosting-0.0.21/simple_module_hosting/_inertia_setup.py

@@ -0,0 +1,184 @@
+"""Configure fastapi-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 starlette.requests import Request
+
+from simple_module_hosting.settings import Settings
+
+logger = logging.getLogger(__name__)
+
+_INERTIA_VERSION = "1.0"
+_ROOT_TEMPLATE_FILENAME = "index.html"
+_ENTRYPOINT_FILENAME = "main.tsx"
+_ROOT_DIRECTORY = "."
+
+# Fallback app name when the (optional) branding module isn't installed. Mirrors
+# branding's own default so the unbranded title is identical everywhere.
+_DEFAULT_APP_NAME = "SimpleModule"
+
+
+def branding_head(request: Request) -> dict:
+    """Branding metadata for the root template's ``<head>``.
+
+    Reads the optional branding module's settings off ``app.state`` by name
+    (duck-typed, never imported) so the static ``<title>`` and ``theme-color``
+    are already branded *before* React hydrates. Degrades to the framework
+    default when branding isn't installed. Only plain settings strings are
+    surfaced here — the favicon is applied client-side by ``BrandingHead`` via
+    Inertia's ``<Head>``, keeping file_storage's download-route shape out of
+    framework code.
+    """
+    services = getattr(request.app.state, "branding", None)
+    settings = getattr(services, "settings", None)
+    if settings is None:
+        return {"app_name": _DEFAULT_APP_NAME, "theme_color": None}
+    return {
+        "app_name": getattr(settings, "app_name", "") or _DEFAULT_APP_NAME,
+        "theme_color": getattr(settings, "primary_color", "") or None,
+    }
+
+
+# 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.
+    """
+    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:
+        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 ""
+
+
+def setup_inertia(
+    app: FastAPI,
+    settings: Settings,
+    modules: list,
+    project_root: Path,
+) -> InertiaConfig | None:
+    """Configure fastapi-inertia 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
+    ``smpy new`` produces). The first one found wins so it can override
+    module-contributed templates.
+    """
+    from fastapi.templating import Jinja2Templates
+
+    candidate_dirs = [
+        project_root / "host" / "templates",
+        project_root / "templates",
+    ]
+    directories: list[Path] = []
+
+    host_templates = next((p for p in candidate_dirs if p.is_dir()), None)
+    if host_templates is not None:
+        directories.append(host_templates)
+    else:
+        logger.warning(
+            "Host templates directory not found (looked in %s)",
+            ", ".join(str(p) for p in candidate_dirs),
+        )
+
+    for mod in modules:
+        for path in mod.template_dirs():
+            if Path(path).is_dir():
+                directories.append(Path(path))
+            else:
+                logger.warning(
+                    "Module '%s' declared template dir %s but it does not exist",
+                    mod.meta.name,
+                    path,
+                )
+
+    if not directories:
+        logger.warning("No usable template directories — Inertia will fail to render views")
+        return None
+
+    templates = Jinja2Templates(directory=directories)
+    # 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.
+    from simple_module_core.environments import NON_PROD_ENVIRONMENTS
+
+    use_dev_server = settings.environment in NON_PROD_ENVIRONMENTS
+    inertia_environment = "development" if use_dev_server else "production"
+
+    inertia_config = InertiaConfig(
+        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,
+        root_template_filename=_ROOT_TEMPLATE_FILENAME,
+        entrypoint_filename=_ENTRYPOINT_FILENAME,
+        root_directory=_ROOT_DIRECTORY,
+        use_flash_errors=True,
+    )
+
+    inertia_dep = inertia_dependency_factory(inertia_config)
+    app.state.inertia_dependency = inertia_dep
+    return inertia_config

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/simple_module_hosting/_inertia_shared.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 from starlette.datastructures import Headers
 from starlette.requests import Request
@@ -59,3 +60,30 @@ def build_i18n_block(scope: Scope, request: Request) -> dict:
         "supportedLocales": registry.available_locales(),
         "messages": registry.messages_snapshot(locale) if send_messages else None,
     }
+
+
+def merge_shared_prop_providers(app: Any, request: Request, shared: dict) -> None:
+    """Merge module-registered Inertia shared-prop providers into ``shared`` in place.
+
+    Providers are read off ``app.state.inertia_shared_providers`` (never importing
+    the plugin — preserves SM009). A provider that raises is skipped and logged; a
+    provider may not clobber a framework-owned key (auth/menus/i18n) or an earlier
+    provider's key.
+    """
+    providers = getattr(app.state, "inertia_shared_providers", None) or ()
+    for provider in providers:
+        name = getattr(provider, "__name__", provider)
+        try:
+            extra = provider(request)
+        except Exception:  # a bad provider must not break the page render
+            logger.warning("shared-prop provider %r raised; skipping", name, exc_info=True)
+            continue
+        for key, value in (extra or {}).items():
+            if key in shared:
+                logger.warning(
+                    "provider %r tried to overwrite reserved shared-prop %r; ignoring",
+                    name,
+                    key,
+                )
+                continue
+            shared[key] = value

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/simple_module_hosting/_phase_helpers.py

@@ -23,6 +23,8 @@ from simple_module_core.diagnostics import Diagnostic, DiagnosticLevel
 from simple_module_core.exceptions import NotFoundError
 from starlette.exceptions import HTTPException
 from starlette.middleware.sessions import SessionMiddleware
+from starlette.responses import Response
+from starlette.types import Scope
 
 from simple_module_hosting._error_handlers import (
     http_exception_handler,
@@ -46,6 +48,28 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable"
+
+
+class ImmutableStaticFiles(StaticFiles):
+    """StaticFiles that marks Vite's content-hashed build assets immutable.
+
+    Vite emits files under ``dist/assets/`` with a content hash in the filename
+    (e.g. ``main-3YbShAJ4.js``), so the bytes for a given URL never change —
+    browsers can cache them indefinitely and skip even the revalidation
+    round-trip. The default StaticFiles only sets ETag/Last-Modified, forcing a
+    conditional GET per asset on every visit. Non-hashed paths (the manifest,
+    etc.) keep the default behaviour.
+    """
+
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        response = await super().get_response(path, scope)
+        # StaticFiles hands us an OS-separator path (backslashes on Windows), so
+        # normalize before matching the forward-slash asset prefix.
+        if response.status_code == 200 and path.replace("\\", "/").startswith("dist/assets/"):
+            response.headers["Cache-Control"] = _IMMUTABLE_CACHE_CONTROL
+        return response
+
 
 def register_exception_handlers(app: FastAPI, modules: list) -> None:
     """Install framework-level exception handlers, then per-module handlers."""

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/simple_module_hosting/app_builder.py

@@ -10,7 +10,6 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 
 from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
 from simple_module_core.diagnostics import DiagnosticLevel, print_diagnostics, run_diagnostics
 from simple_module_core.discovery import discover_modules, topological_sort
 from simple_module_core.events import EventBus
@@ -26,6 +25,7 @@ from simple_module_db.session import init_db
 from simple_module_hosting._host_services import _HostServices
 from simple_module_hosting._inertia_setup import setup_inertia
 from simple_module_hosting._phase_helpers import (
+    ImmutableStaticFiles,
     attach_public_routes,
     check_settings_registration,
     install_middleware,
@@ -277,7 +277,9 @@ def create_app(settings: Settings | None = None) -> FastAPI:
 
     static_dir = _PROJECT_ROOT / "host" / _STATIC_DIR_NAME
     if static_dir.is_dir():
-        app.mount(_STATIC_MOUNT_PATH, StaticFiles(directory=static_dir), name=_STATIC_DIR_NAME)
+        app.mount(
+            _STATIC_MOUNT_PATH, ImmutableStaticFiles(directory=static_dir), name=_STATIC_DIR_NAME
+        )
 
     mount_module_static_dirs(app, modules)
 

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/simple_module_hosting/middleware.py

@@ -18,7 +18,7 @@ from starlette.datastructures import Headers, MutableHeaders
 from starlette.requests import Request
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from simple_module_hosting._inertia_shared import build_i18n_block
+from simple_module_hosting._inertia_shared import build_i18n_block, merge_shared_prop_providers
 from simple_module_hosting._observability import (
     CorrelationIdMiddleware,
     RequestLoggingMiddleware,
@@ -277,6 +277,11 @@ class InertiaLayoutDataMiddleware:
             ),
             "i18n": i18n_block,
         }
+
+        # Merge module-registered shared-prop providers (e.g. branding) — read off
+        # app.state without importing the plugin (SM009), defensively.
+        merge_shared_prop_providers(scope["app"], request, shared)
+
         request.state.inertia_shared = shared
 
         await self.app(scope, receive, send)

simple_module_hosting-0.0.21/simple_module_hosting/shared_props.py

@@ -0,0 +1,42 @@
+"""Module-registered Inertia shared-prop providers.
+
+A generic extension point so plugin modules can contribute layout-wide Inertia
+shared props (e.g. branding) on every page, without the framework importing the
+plugin. This mirrors the ``principal_serializer`` precedent: the framework reads
+a registered callable off ``app.state`` rather than reaching into module code,
+keeping the ``SM009`` framework→plugin import ban intact.
+
+A provider is ``Callable[[Request], dict]``. It must be cheap and total — it runs
+for every request. :class:`InertiaLayoutDataMiddleware` merges each provider's
+returned dict into the ``shared`` payload after the built-in ``auth``/``menus``/
+``i18n`` blocks; a provider that raises is skipped and logged, never failing the
+request.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+    from starlette.requests import Request
+
+SharedPropsProvider = Callable[["Request"], dict]
+"""A function mapping a request to a dict merged into Inertia shared props."""
+
+_STATE_ATTR = "inertia_shared_providers"
+
+
+def register_inertia_shared_provider(app: FastAPI, provider: SharedPropsProvider) -> None:
+    """Register a shared-props provider on the app.
+
+    Idempotently initialises ``app.state.inertia_shared_providers`` (a list) and
+    appends ``provider``. Safe to call from a module lifecycle hook before the
+    framework has set up the list.
+    """
+    providers = getattr(app.state, _STATE_ATTR, None)
+    if providers is None:
+        providers = []
+        setattr(app.state, _STATE_ATTR, providers)
+    providers.append(provider)

{simple_module_hosting-0.0.19 → simple_module_hosting-0.0.21}/tests/test_app.py

@@ -27,12 +27,14 @@ class TestCreateApp:
 
     async def test_modules_enabled_limits_loaded_modules(self, settings: Settings):
         """Host respects settings.modules_enabled — only listed modules contribute routes."""
+        from simple_module_test import effective_route_paths
+
         # Only Auth should be loaded; Dashboard routes must be absent.
         restricted = settings.model_copy(update={"modules_enabled": ["Auth"]})
         app = create_app(restricted)
-        paths: set[str] = {str(r.path) for r in app.routes if hasattr(r, "path")}
+        paths = effective_route_paths(app)
         # Auth is now contracts-only, so it has no routes — only health remains.
-        assert "/dashboard" not in paths
+        assert not any(p.startswith("/dashboard") for p in paths)
 
     async def test_module_static_mounts_become_app_routes(
         self,
@@ -203,7 +205,9 @@ class TestResolveProjectRoot:
 class TestRouteRegistration:
     async def test_expected_routes_registered(self, app: FastAPI):
         """All modules should have their routes registered in the app."""
-        route_paths = [r.path for r in app.routes if hasattr(r, "path")]
+        from simple_module_test import effective_route_paths
+
+        route_paths = effective_route_paths(app)
 
         assert "/health" in route_paths
         assert "/health/live" in route_paths
@@ -216,8 +220,9 @@ class TestRouteRegistration:
         # landing page at "/" is owned by the host and added in host/main.py,
         # which the create_app fixture doesn't run.
         assert "/dashboard/" in route_paths
-        # Bare-prefix alias — see wire_module_routes for the X-Inertia rationale.
-        assert "/dashboard" in route_paths
+        # The bare-prefix Inertia alias ("/dashboard" without the slash) is
+        # registered with include_in_schema=False, so it isn't enumerable here;
+        # TestProtectedPages::test_dashboard_redirects_unauthenticated covers it.
 
 
 class TestProtectedPages:

simple_module_hosting-0.0.21/tests/test_branding_head.py

@@ -0,0 +1,32 @@
+"""Tests for the root-template branding head metadata helper."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from simple_module_hosting._inertia_setup import branding_head
+
+
+def _request(branding: object | None) -> SimpleNamespace:
+    state = SimpleNamespace()
+    if branding is not None:
+        state.branding = branding
+    return SimpleNamespace(app=SimpleNamespace(state=state))
+
+
+def test_defaults_when_branding_not_installed() -> None:
+    meta = branding_head(_request(None))
+    assert meta == {"app_name": "SimpleModule", "theme_color": None}
+
+
+def test_reads_app_name_and_theme_color() -> None:
+    settings = SimpleNamespace(app_name="Acme", primary_color="#1a7dd1")
+    meta = branding_head(_request(SimpleNamespace(settings=settings)))
+    assert meta["app_name"] == "Acme"
+    assert meta["theme_color"] == "#1a7dd1"
+
+
+def test_blank_values_fall_back() -> None:
+    settings = SimpleNamespace(app_name="", primary_color="")
+    meta = branding_head(_request(SimpleNamespace(settings=settings)))
+    assert meta == {"app_name": "SimpleModule", "theme_color": None}

simple_module_hosting-0.0.21/tests/test_inertia_manifest.py

@@ -0,0 +1,71 @@
+"""Tests for production Inertia manifest normalization (_prod_manifest_path).
+
+fastapi-inertia looks the entry up by ``f"{root_directory}/{entrypoint}"`` =
+``"./main.tsx"``, but Vite keys its manifest by the entry's source path
+(``"main.tsx"``). _prod_manifest_path bridges the two so production page
+rendering doesn't KeyError. Regression guard for that bug.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from simple_module_hosting._inertia_setup import _prod_manifest_path
+
+
+def _write_vite_manifest(project_root: Path) -> Path:
+    manifest_dir = project_root / "host" / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    manifest = {
+        "main.tsx": {
+            "file": "assets/main-ABC123.js",
+            "css": ["assets/main-DEF456.css"],
+            "isEntry": True,
+        },
+        "pages/Foo.tsx": {"file": "assets/Foo-XYZ.js"},
+    }
+    path = manifest_dir / "manifest.json"
+    path.write_text(json.dumps(manifest))
+    return path
+
+
+def test_rekeys_entry_for_fastapi_inertia(tmp_path: Path):
+    _write_vite_manifest(tmp_path)
+    result = _prod_manifest_path(tmp_path)
+
+    assert result, "expected a manifest path, got empty string"
+    data = json.loads(Path(result).read_text())
+    # fastapi-inertia will look up f"{root_directory}/{entrypoint}" == "./main.tsx"
+    assert "./main.tsx" in data
+    assert data["./main.tsx"]["file"] == "assets/main-ABC123.js"
+    assert data["./main.tsx"]["css"] == ["assets/main-DEF456.css"]
+    # original keys are preserved (other chunks still resolvable)
+    assert "pages/Foo.tsx" in data
+
+
+def test_returns_empty_when_no_built_manifest(tmp_path: Path):
+    # No host/static/dist/.vite/manifest.json present.
+    assert _prod_manifest_path(tmp_path) == ""
+
+
+def test_returns_empty_when_no_entry_chunk(tmp_path: Path):
+    # A manifest with no isEntry chunk must degrade to "" (not return a path
+    # that would KeyError at render) — same graceful path as no-manifest.
+    manifest_dir = tmp_path / "host" / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    (manifest_dir / "manifest.json").write_text(json.dumps({"pages/Foo.tsx": {"file": "f.js"}}))
+    assert _prod_manifest_path(tmp_path) == ""
+
+
+def test_scaffolded_layout_without_host_dir(tmp_path: Path):
+    # smpy-new apps keep static/ at the project root (no host/ subdir).
+    manifest_dir = tmp_path / "static" / "dist" / ".vite"
+    manifest_dir.mkdir(parents=True)
+    (manifest_dir / "manifest.json").write_text(
+        json.dumps({"main.tsx": {"file": "assets/main-A.js", "isEntry": True}})
+    )
+    result = _prod_manifest_path(tmp_path)
+    assert result
+    data = json.loads(Path(result).read_text())
+    assert data["./main.tsx"]["file"] == "assets/main-A.js"

simple_module_hosting-0.0.21/tests/test_inertia_shared_providers.py

@@ -0,0 +1,91 @@
+"""Verify InertiaLayoutDataMiddleware merges module-registered shared-prop providers.
+
+Modules contribute layout-wide Inertia shared props (e.g. branding) without the
+framework importing the plugin — mirroring the ``principal_serializer`` precedent.
+Providers are registered on ``app.state.inertia_shared_providers`` and merged into
+the ``shared`` dict for every request.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import FastAPI
+from simple_module_core.menu import MenuRegistry
+from simple_module_core.permissions import PermissionRegistry
+from simple_module_hosting.middleware import InertiaLayoutDataMiddleware
+from simple_module_hosting.shared_props import register_inertia_shared_provider
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.testclient import TestClient
+
+
+def _build_app() -> FastAPI:
+    app = FastAPI()
+
+    @app.get("/shared")
+    def shared(request: Request) -> JSONResponse:
+        return JSONResponse(request.state.inertia_shared)
+
+    app.add_middleware(
+        InertiaLayoutDataMiddleware,
+        menu_registry=MenuRegistry(),
+        permission_registry=PermissionRegistry(),
+    )
+    app.add_middleware(SessionMiddleware, secret_key="test-secret")
+    return app
+
+
+def test_registered_provider_dict_merged_into_shared() -> None:
+    app = _build_app()
+    register_inertia_shared_provider(app, lambda _req: {"branding": {"appName": "Acme"}})
+
+    body = TestClient(app).get("/shared").json()
+
+    assert body["branding"] == {"appName": "Acme"}
+    # Built-in blocks still present.
+    assert "auth" in body
+    assert "menus" in body
+
+
+def test_provider_that_raises_is_skipped_not_fatal(caplog) -> None:
+    app = _build_app()
+
+    def boom(_req: Request) -> dict:
+        raise RuntimeError("provider blew up")
+
+    register_inertia_shared_provider(app, boom)
+    register_inertia_shared_provider(app, lambda _req: {"branding": {"appName": "Acme"}})
+
+    with caplog.at_level(logging.WARNING, logger="simple_module_hosting.middleware"):
+        resp = TestClient(app).get("/shared")
+
+    assert resp.status_code == 200
+    body = resp.json()
+    # The good provider still applied; the failing one was skipped.
+    assert body["branding"] == {"appName": "Acme"}
+    assert "auth" in body
+    assert any("shared-prop" in rec.message.lower() for rec in caplog.records)
+
+
+def test_no_providers_leaves_shared_unchanged() -> None:
+    body = TestClient(_build_app()).get("/shared").json()
+    assert "branding" not in body
+    assert "auth" in body and "menus" in body
+
+
+def test_provider_cannot_clobber_framework_keys(caplog) -> None:
+    app = _build_app()
+    # A misbehaving provider tries to overwrite the framework-owned auth block.
+    register_inertia_shared_provider(
+        app, lambda _req: {"auth": "HIJACKED", "branding": {"ok": True}}
+    )
+
+    with caplog.at_level(logging.WARNING, logger="simple_module_hosting.middleware"):
+        body = TestClient(app).get("/shared").json()
+
+    # auth stays the framework's dict; only the non-reserved key is added.
+    assert isinstance(body["auth"], dict)
+    assert body["branding"] == {"ok": True}
+    assert any("reserved shared-prop" in rec.message for rec in caplog.records)

simple_module_hosting-0.0.21/tests/test_static_caching.py

@@ -0,0 +1,37 @@
+"""ImmutableStaticFiles marks Vite's content-hashed assets immutable.
+
+Hashed filenames (``main-3YbShAJ4.js``) are content-addressed, so browsers can
+cache them forever and skip the per-asset revalidation round-trip. Non-hashed
+paths keep StaticFiles' default (ETag/Last-Modified only).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from simple_module_hosting._phase_helpers import ImmutableStaticFiles
+
+_GET_SCOPE = {"type": "http", "method": "GET", "headers": []}
+
+
+def _make_tree(root: Path) -> None:
+    (root / "dist" / "assets").mkdir(parents=True)
+    (root / "dist" / "assets" / "main-ABC123.js").write_text("console.log(1)")
+    (root / "dist" / ".vite").mkdir(parents=True)
+    (root / "dist" / ".vite" / "manifest.json").write_text("{}")
+
+
+async def test_hashed_asset_is_immutable(tmp_path: Path):
+    _make_tree(tmp_path)
+    static = ImmutableStaticFiles(directory=tmp_path)
+    resp = await static.get_response("dist/assets/main-ABC123.js", _GET_SCOPE)
+    assert resp.status_code == 200
+    assert resp.headers["cache-control"] == "public, max-age=31536000, immutable"
+
+
+async def test_non_asset_keeps_default_caching(tmp_path: Path):
+    _make_tree(tmp_path)
+    static = ImmutableStaticFiles(directory=tmp_path)
+    resp = await static.get_response("dist/.vite/manifest.json", _GET_SCOPE)
+    assert resp.status_code == 200
+    assert "immutable" not in resp.headers.get("cache-control", "")

simple_module_hosting-0.0.19/simple_module_hosting/__init__.py

@@ -1,7 +0,0 @@
-"""SimpleModule Hosting - App builder, module loader, middleware pipeline."""
-
-from simple_module_hosting.app_builder import create_app
-from simple_module_hosting.logging import correlation_id, setup_logging
-from simple_module_hosting.settings import Settings
-
-__all__ = ["Settings", "correlation_id", "create_app", "setup_logging"]

simple_module_hosting-0.0.19/simple_module_hosting/_inertia_setup.py

@@ -1,94 +0,0 @@
-"""Configure fastapi-inertia with the Jinja2 template."""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-from fastapi import FastAPI
-from inertia import InertiaConfig, inertia_dependency_factory
-
-from simple_module_hosting.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-_INERTIA_VERSION = "1.0"
-_ROOT_TEMPLATE_FILENAME = "index.html"
-_ENTRYPOINT_FILENAME = "main.tsx"
-_ROOT_DIRECTORY = "."
-
-
-def setup_inertia(
-    app: FastAPI,
-    settings: Settings,
-    modules: list,
-    project_root: Path,
-) -> InertiaConfig | None:
-    """Configure fastapi-inertia 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
-    ``smpy new`` produces). The first one found wins so it can override
-    module-contributed templates.
-    """
-    from fastapi.templating import Jinja2Templates
-
-    candidate_dirs = [
-        project_root / "host" / "templates",
-        project_root / "templates",
-    ]
-    directories: list[Path] = []
-
-    host_templates = next((p for p in candidate_dirs if p.is_dir()), None)
-    if host_templates is not None:
-        directories.append(host_templates)
-    else:
-        logger.warning(
-            "Host templates directory not found (looked in %s)",
-            ", ".join(str(p) for p in candidate_dirs),
-        )
-
-    for mod in modules:
-        for path in mod.template_dirs():
-            if Path(path).is_dir():
-                directories.append(Path(path))
-            else:
-                logger.warning(
-                    "Module '%s' declared template dir %s but it does not exist",
-                    mod.meta.name,
-                    path,
-                )
-
-    if not directories:
-        logger.warning("No usable template directories — Inertia will fail to render views")
-        return None
-
-    templates = Jinja2Templates(directory=directories)
-
-    # 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.
-    from simple_module_core.environments import NON_PROD_ENVIRONMENTS
-
-    use_dev_server = settings.environment in NON_PROD_ENVIRONMENTS
-    inertia_environment = "development" if use_dev_server else "production"
-
-    inertia_config = InertiaConfig(
-        environment=inertia_environment,
-        version=_INERTIA_VERSION,
-        dev_url=settings.vite_dev_url if use_dev_server else "",
-        templates=templates,
-        root_template_filename=_ROOT_TEMPLATE_FILENAME,
-        entrypoint_filename=_ENTRYPOINT_FILENAME,
-        root_directory=_ROOT_DIRECTORY,
-        use_flash_errors=True,
-    )
-
-    inertia_dep = inertia_dependency_factory(inertia_config)
-    app.state.inertia_dependency = inertia_dep
-    return inertia_config