simple-module-hosting 0.0.36__tar.gz → 0.0.37__tar.gz

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/.gitignore

@@ -64,3 +64,4 @@ host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
 .verify/
+/openapi.json

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.36
+Version: 0.0.37
 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,9 +26,9 @@ 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.36
-Requires-Dist: simple-module-db==0.0.36
-Requires-Dist: simple-module-inertia==0.0.36
+Requires-Dist: simple-module-core==0.0.37
+Requires-Dist: simple-module-db==0.0.37
+Requires-Dist: simple-module-inertia==0.0.37
 Requires-Dist: starlette>=0.44
 Requires-Dist: tomlkit>=0.13
 Requires-Dist: uvicorn[standard]>=0.34

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.36"
+version = "0.0.37"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -29,9 +29,9 @@ dependencies = [
     # it directly — out-of-tree hosts have nothing else pulling it in.
     "itsdangerous>=2.0",
     "jinja2>=3.1",
-    "simple_module_core==0.0.36",
-    "simple_module_db==0.0.36",
-    "simple_module_inertia==0.0.36",
+    "simple_module_core==0.0.37",
+    "simple_module_db==0.0.37",
+    "simple_module_inertia==0.0.37",
     "starlette>=0.44",
     "tomlkit>=0.13",
     "uvicorn[standard]>=0.34",

simple_module_hosting-0.0.37/simple_module_hosting/_anonymous.py

@@ -0,0 +1,27 @@
+"""Demote a request's principal to the anonymous visitor, mid-request.
+
+Used when a credential authenticated but must not act as its account here: an
+API token on a public route (``token_guard``), or a token whose owner no
+longer holds the permission it requires (``permissions``). "Anonymous" means
+all of it — no user, no permissions, no audit identity, and the tenant an
+anonymous request would have resolved to rather than the one the credential
+pinned.
+"""
+
+from __future__ import annotations
+
+from simple_module_db.listeners import current_user_id
+from starlette.requests import HTTPConnection
+
+from simple_module_hosting._tenant import reresolve_tenant
+
+
+async def demote_to_anonymous(request: HTTPConnection) -> None:
+    """Drop the principal and re-run tenant resolution as anonymous."""
+    request.state.user = None
+    request.state.resolved_permissions = set()
+    current_user_id.set(None)
+    await reresolve_tenant(request)
+
+
+__all__ = ["demote_to_anonymous"]

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/_error_handlers.py

@@ -187,7 +187,7 @@ async def render_error_page(
             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
+        # (ui.error_page.not_found_title) and loses auth/menus, so a signed-in
         # user's 404 has no layout.
         shared = getattr(request.state, "inertia_shared", None)
         if shared:

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/_hydrate_step.py

@@ -28,7 +28,7 @@ async def hydrate_all(app: FastAPI, store: Any) -> None:
 
     for package, cls in settings_services.module_registry.items():
         try:
-            hydrated = await hydrate_settings(cls, store, package)
+            hydrated = await hydrate_settings(cls, store, package, lenient=True)
         except Exception:
             logger.exception("Hydrating %s failed; falling back to defaults", package)
             continue

simple_module_hosting-0.0.37/simple_module_hosting/_i18n_target.py

@@ -0,0 +1,40 @@
+"""Where generated i18n key files are written: monorepo checkout or published npm package."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+RESOURCE_KEY_RE = re.compile(r"^\s+'([^']+)': '',$", re.MULTILINE)
+
+_PUBLISHED_PKG = Path("node_modules") / "@simple-module-py" / "i18n" / "src"
+
+
+def resolve_i18n_types_dir(project_root: Path) -> tuple[Path | None, bool]:
+    """Where the generated key files go, and whether that is a published package.
+
+    The monorepo's ``packages/i18n/src`` wins. A scaffolded app has no such
+    checkout — ``@simple-module-py/i18n`` is an npm dependency — so walk up from
+    ``project_root`` to the nearest ``node_modules`` holding it (npm workspaces
+    hoist it to the workspace root, above the host; a flat host installs into
+    ``client_app/``). ``(None, False)`` when
+    neither exists, the normal shape of a wheel-installed prod app.
+    """
+    local = project_root / "packages" / "i18n" / "src"
+    if local.is_dir():
+        return local, False
+    root = project_root.resolve()
+    # A flat host (``smpy new --flat``) keeps its npm install in client_app/.
+    for base in (root, root / "client_app", *root.parents):
+        published = base / _PUBLISHED_PKG
+        if published.is_dir():
+            return published, True
+    return None, False
+
+
+def read_resource_keys(resources_path: Path) -> frozenset[str]:
+    """Keys listed in an existing ``generated-resources.ts`` (empty if unreadable)."""
+    try:
+        return frozenset(RESOURCE_KEY_RE.findall(resources_path.read_text(encoding="utf-8")))
+    except OSError:
+        return frozenset()

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/_module_routes.py

@@ -6,9 +6,12 @@ responsibility — and to keep both files under the 300-line cap.
 
 from __future__ import annotations
 
-from fastapi import APIRouter, FastAPI
+from fastapi import APIRouter, Depends, FastAPI
 from fastapi.routing import APIRoute
 
+from simple_module_hosting._openapi import make_unique_id_function
+from simple_module_hosting.token_guard import page_route
+
 __all__ = ["wire_module_routes"]
 
 
@@ -23,13 +26,26 @@ def wire_module_routes(app: FastAPI, module) -> bool:
     in ``simple_module_test`` stay in lockstep if ``ModuleBase`` ever gains
     a new router type.
     """
-    api_router = APIRouter(prefix=module.meta.route_prefix, tags=[module.meta.name])
-    view_router = APIRouter(prefix=module.meta.view_prefix, tags=[f"{module.meta.name} Views"])
+    api_router = APIRouter(
+        prefix=module.meta.route_prefix,
+        tags=[module.meta.name],
+        generate_unique_id_function=make_unique_id_function(),
+    )
+    # Views are Inertia pages, not part of the published JSON API (#456), and
+    # carry the page marker: an API token is refused on every page, gated or
+    # not (``token_guard``).
+    pages = [Depends(page_route)]
+    view_router = APIRouter(
+        prefix=module.meta.view_prefix,
+        tags=[f"{module.meta.name} Views"],
+        include_in_schema=False,
+        dependencies=pages,
+    )
     module.register_routes(api_router, view_router)
     _clone_bare_prefix_route(view_router, module.meta.view_prefix)
     has_views = bool(view_router.routes)
     app.include_router(api_router)
-    app.include_router(view_router)
+    app.include_router(view_router, include_in_schema=False)
 
     # Second view router for modules that serve both public and admin pages
     # and therefore cannot express both under a single view_prefix — see
@@ -39,10 +55,12 @@ def wire_module_routes(app: FastAPI, module) -> bool:
         admin_router = APIRouter(
             prefix=admin_prefix,
             tags=[f"{module.meta.name} Admin Views"],
+            include_in_schema=False,
+            dependencies=pages,
         )
         module.register_admin_routes(admin_router)
         _clone_bare_prefix_route(admin_router, admin_prefix)
-        app.include_router(admin_router)
+        app.include_router(admin_router, include_in_schema=False)
     return has_views
 
 

simple_module_hosting-0.0.37/simple_module_hosting/_openapi.py

@@ -0,0 +1,98 @@
+"""OpenAPI export plumbing (#456).
+
+Three small pieces, kept apart from ``create_app``:
+
+* ``make_unique_id_function`` — stable ``<module>_<function>`` operationIds, so
+  generated clients get method names like ``users_list_users`` instead of
+  ``list_users_api_users__get``.
+* ``install_openapi_filter`` — the published schema is the JSON API only. View
+  routes are already ``include_in_schema=False``; this also drops any other
+  non-``/api/`` path (host routes, health) so a client generator never sees them.
+* ``API_OPENAPI_URL`` / ``openapi_served`` — where and when it is served.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import warnings
+from collections.abc import Callable
+
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+
+__all__ = [
+    "API_OPENAPI_URL",
+    "dedupe_operation_ids",
+    "install_openapi_filter",
+    "make_unique_id_function",
+    "openapi_served",
+]
+
+logger = logging.getLogger(__name__)
+
+API_OPENAPI_URL = "/api/openapi.json"
+_API_PREFIX = "/api/"
+
+
+def openapi_served(*, is_development: bool, openapi_public: bool) -> bool:
+    """Always in development; elsewhere only when the operator opted in."""
+    return is_development or openapi_public
+
+
+def _snake(name: str) -> str:
+    spaced = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", name)
+    return re.sub(r"[^0-9a-zA-Z]+", "_", spaced).strip("_").lower()
+
+
+def make_unique_id_function() -> Callable[[APIRoute], str]:
+    """Build an operationId generator: ``<module>_<endpoint function name>``.
+
+    The module is the route's first tag (``wire_module_routes`` tags each API
+    router with the module name). Stateless on purpose: FastAPI calls it again
+    when a router is included, so any bookkeeping here would see every route
+    twice. Clashes are resolved on the finished schema by ``dedupe_operation_ids``.
+    """
+
+    def unique_id(route: APIRoute) -> str:
+        module = _snake(route.tags[0]) if route.tags and isinstance(route.tags[0], str) else ""
+        return f"{module}_{route.name}" if module else route.name
+
+    return unique_id
+
+
+def dedupe_operation_ids(schema: dict) -> None:
+    """Make every ``operationId`` unique, appending method and path on a clash."""
+    seen: set[str] = set()
+    for path, item in schema.get("paths", {}).items():
+        for method, op in item.items():
+            if not isinstance(op, dict) or "operationId" not in op:
+                continue
+            base = op["operationId"]
+            if base in seen:
+                op["operationId"] = f"{base}_{method}_{_snake(path)}"
+                logger.warning(
+                    "Duplicate OpenAPI operationId %r; using %r", base, op["operationId"]
+                )
+            seen.add(op["operationId"])
+
+
+def install_openapi_filter(app: FastAPI) -> None:
+    """Make ``app.openapi()`` list only ``/api/`` paths."""
+    original = app.openapi
+
+    def openapi() -> dict:
+        if app.openapi_schema is None:
+            # FastAPI warns about duplicate ids as it builds; they are resolved
+            # (and logged once) by dedupe_operation_ids below.
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", message="Duplicate Operation ID")
+                schema = original()
+            schema["paths"] = {
+                p: v for p, v in schema.get("paths", {}).items() if p.startswith(_API_PREFIX)
+            }
+            dedupe_operation_ids(schema)
+        assert app.openapi_schema is not None
+        return app.openapi_schema
+
+    app.openapi = openapi  # type: ignore[method-assign]

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/_tenant.py

@@ -17,6 +17,8 @@ TENANT_HEADER = "X-Tenant-ID"
 
 _CREDENTIAL_VARY = ("Cookie", "Authorization")
 
+_STATE_MIDDLEWARE = "_sm_tenant_middleware"
+
 
 @dataclass(frozen=True, slots=True)
 class TenantResolution:
@@ -123,37 +125,41 @@ class TenantMiddleware:
             return
 
         request = Request(scope)
+        # Kept so a principal dropped later in the request can be re-resolved
+        # (``reresolve_tenant``) with this middleware's own configuration.
+        scope.setdefault("state", {})[_STATE_MIDDLEWARE] = self
         resolution = await self._resolve(request, scope)
         tenant_id = resolution.tenant_id
         request.state.tenant_id = tenant_id
         request.state.tenant_source = resolution.source
         request.state.tenant_vary = resolution.vary
 
-        send = self._vary_sender(send, resolution.vary)
-        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)
+        send = self._vary_sender(scope, send, resolution.vary)
+        # Always bound and reset, even for ``None``: a principal demoted later in
+        # the request re-resolves the tenant (``reresolve_tenant``) and may set
+        # one this request did not start with, which must not outlive it.
+        token = current_tenant_id.set(tenant_id)
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            current_tenant_id.reset(token)
 
     @staticmethod
-    def _vary_sender(send: Send, vary: tuple[str, ...]) -> Send:
+    def _vary_sender(scope: Scope, send: Send, vary: tuple[str, ...]) -> Send:
         if not vary:
             return send
 
         async def wrapped(message: MutableMapping[str, Any]) -> None:
             if message["type"] == "http.response.start":
+                # Re-read: a re-resolution (``reresolve_tenant``) may add names.
+                names = (scope.get("state") or {}).get("tenant_vary") or vary
                 headers = MutableHeaders(scope=message)
                 lines = headers.getlist("vary")
                 # Every line, not just the first (#423): MutableHeaders.get
                 # reads one, and assigning drops the rest — including a
                 # ``Vary: *`` on a later line.
                 if not any("*" in _tokens(line) for line in lines):
-                    merged = merge_vary(", ".join(lines), vary)
+                    merged = merge_vary(", ".join(lines), tuple(names))
                     del headers["vary"]
                     headers["vary"] = merged
             await send(message)
@@ -188,10 +194,30 @@ class TenantMiddleware:
         return TenantResolution(None)
 
 
+async def reresolve_tenant(request: Request | Any) -> None:
+    """Resolve the tenant again for the request's *current* principal and rebind it.
+
+    For a principal dropped after ``TenantMiddleware`` ran: the tenant it
+    pinned must not outlive it. No-op without the middleware (single-tenant
+    hosts never bound one). The headers both answers depended on stay in
+    ``Vary``.
+    """
+    middleware = (request.scope.get("state") or {}).get(_STATE_MIDDLEWARE)
+    if not isinstance(middleware, TenantMiddleware):
+        return
+    resolution = await middleware._resolve(request, request.scope)
+    previous = tuple(getattr(request.state, "tenant_vary", None) or ())
+    request.state.tenant_id = resolution.tenant_id
+    request.state.tenant_source = resolution.source
+    request.state.tenant_vary = (*previous, *resolution.vary)
+    current_tenant_id.set(resolution.tenant_id)
+
+
 __all__ = [
     "TENANT_HEADER",
     "TenantMiddleware",
     "TenantResolution",
     "TenantResolver",
     "merge_vary",
+    "reresolve_tenant",
 ]

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/app_builder.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 
-from fastapi import FastAPI
+from fastapi import Depends, FastAPI
 from simple_module_core import BodyLimitRegistry, CspSourceRegistry
 from simple_module_core.audit_links import AuditLinkRegistry
 from simple_module_core.design_packs import DesignPackRegistry
@@ -27,6 +27,12 @@ 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._openapi import (
+    API_OPENAPI_URL,
+    install_openapi_filter,
+    make_unique_id_function,
+    openapi_served,
+)
 from simple_module_hosting._phase_helpers import (
     attach_public_routes,
     install_middleware,
@@ -44,16 +50,16 @@ from simple_module_hosting._settings_registration import (
 )
 from simple_module_hosting.health import router as health_router
 from simple_module_hosting.i18n_manifest import build_i18n_registry
+from simple_module_hosting.i18n_routes import router as i18n_router
 from simple_module_hosting.settings import Settings
 from simple_module_hosting.setup_gate import register_migration_step
 from simple_module_hosting.setup_wizard import mount_setup_wizard
 from simple_module_hosting.static_files import PrecompressedStaticFiles
 from simple_module_hosting.tenancy import mode_for
+from simple_module_hosting.token_guard import token_route_guard
 
 logger = logging.getLogger(__name__)
 
-_APP_TITLE = "SimpleModule"
-_APP_VERSION = "0.1.0"
 _DOCS_URL = "/api/docs"
 _REDOC_URL = "/api/redoc"
 _STATIC_MOUNT_PATH = "/static"
@@ -143,14 +149,27 @@ def create_app(settings: Settings | None = None) -> FastAPI:
 
     lifespan = build_lifespan(modules)
 
+    serve_openapi = openapi_served(
+        is_development=settings.is_development, openapi_public=settings.openapi_public
+    )
     app = FastAPI(
-        title=_APP_TITLE,
-        version=_APP_VERSION,
+        title=settings.api_title,
+        version=settings.api_version,
+        description=settings.api_description,
+        openapi_url=API_OPENAPI_URL if serve_openapi else None,
+        generate_unique_id_function=make_unique_id_function(),
         docs_url=_DOCS_URL if settings.is_development else None,
         redoc_url=_REDOC_URL if settings.is_development else None,
         lifespan=lifespan,
+        # API tokens reach only permission-gated, non-page routes (or ones
+        # marked ``TokenAllowed``); see ``token_guard``.
+        dependencies=[Depends(token_route_guard)],
     )
 
+    install_openapi_filter(app)
+    # Read by AuthMiddleware: the schema is anonymous exactly when it is served.
+    app.state.openapi_url = API_OPENAPI_URL if serve_openapi else None
+
     # ── Phase 4: Module settings ───────────────────────────
     for mod in modules:
         mod.register_settings(app)
@@ -240,6 +259,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
             view_prefixes[mod.meta.name] = mod.meta.view_prefix
 
     app.include_router(health_router)
+    app.include_router(i18n_router)  # /i18n/set-locale — LocaleSwitcher posts here
     mount_setup_wizard(app, setup_registry)  # /setup — what SetupMiddleware redirects to
 
     static_dir = _PROJECT_ROOT / "host" / _STATIC_DIR_NAME

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/host_cli.py

@@ -53,6 +53,47 @@ def gen_pages(
     )
 
 
+@app.command("gen-i18n")
+def gen_i18n(
+    allow_removals: Annotated[
+        bool,
+        typer.Option(
+            "--allow-removals",
+            help="Permit dropping key namespaces of modules not installed here.",
+        ),
+    ] = False,
+) -> None:
+    """Regenerate the typed i18n key files (keys.generated.ts) without booting the app.
+
+    Writes into packages/i18n/src in the monorepo, else into the installed
+    @simple-module-py/i18n package under node_modules. Fails loudly if neither
+    exists.
+    """
+    from simple_module_hosting._project_root import resolve_project_root
+    from simple_module_hosting.i18n_manifest import (
+        NamespaceRemovalError,
+        emit_frontend_types_for_modules,
+    )
+    from simple_module_hosting.settings import Settings
+
+    logging.basicConfig(level=logging.WARNING, format="%(message)s")
+    logging.getLogger("simple_module_hosting.i18n_manifest").setLevel(logging.INFO)
+    settings = Settings()
+    modules = discover_modules(enabled=settings.modules_enabled, strict=not settings.is_development)
+    try:
+        emit_frontend_types_for_modules(
+            settings,
+            modules,
+            resolve_project_root(),
+            strict=True,
+            allow_removals=allow_removals,
+        )
+    except (NamespaceRemovalError, FileNotFoundError) as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+    typer.echo("i18n key files up to date")
+
+
 @app.command("sync-js-deps")
 def sync_js_deps(
     host_client_app: Annotated[

{simple_module_hosting-0.0.36 → simple_module_hosting-0.0.37}/simple_module_hosting/host_settings.py

@@ -26,6 +26,42 @@ _RESTART_DB = {"requires_restart": True, "group": "Database"}
 
 _RESTART_GUARD = {"requires_restart": True, "group": "Request guards"}
 
+_RESTART_API = {"requires_restart": True, "group": "API"}
+
+
+def _default_api_version() -> str:
+    """The host project's version, else ``0.0.0``.
+
+    This repo's host is the installed ``simple-module-host`` distribution. A
+    scaffolded host is ``package = false`` (never installed), so there is no
+    distribution to ask: read ``[project].version`` from its ``pyproject.toml``
+    under ``SM_PROJECT_ROOT`` (or the cwd) instead.
+    """
+    import tomllib
+    from importlib.metadata import PackageNotFoundError, version
+
+    from simple_module_core.dotenv import find_env_file
+
+    try:
+        return version("simple-module-host")
+    except PackageNotFoundError:
+        pass
+    # Same project-root convention as .env (SM_PROJECT_ROOT, else a bounded walk
+    # up from the cwd), so a CLI run from host/ finds the same project as the app.
+    root = find_env_file().parent
+    for candidate in (root / "host" / "pyproject.toml", root / "pyproject.toml"):
+        try:
+            project = tomllib.loads(candidate.read_text(encoding="utf-8")).get("project")
+        except (OSError, ValueError):  # missing/unreadable, bad UTF-8, bad TOML
+            continue
+        if not isinstance(project, dict):
+            continue
+        # The first file declaring a [project] is the host's: a dynamic version
+        # must not fall through to an unrelated (workspace-root) project's.
+        found = project.get("version")
+        return found if isinstance(found, str) and found else "0.0.0"
+    return "0.0.0"
+
 
 class HostSettings(BaseSettings):
     """DB-backed host configuration — defaults live here, overrides in DB."""
@@ -113,6 +149,15 @@ class HostSettings(BaseSettings):
     """Opt-in per-IP limit for signed-in traffic, same syntax. Blank (default)
     leaves authenticated requests unlimited."""
 
+    api_title: str = Field(default="SimpleModule", json_schema_extra=_RESTART_API)
+    """``info.title`` of the OpenAPI document (built once at boot)."""
+    api_version: str = Field(default_factory=_default_api_version, json_schema_extra=_RESTART_API)
+    """``info.version`` of the OpenAPI document; defaults to the host distribution's version."""
+    api_description: str = Field(default="", json_schema_extra=_RESTART_API)
+    openapi_public: bool = Field(default=False, json_schema_extra=_RESTART_API)
+    """Serve ``/api/openapi.json`` outside development, anonymously. Off by default:
+    the schema lists every endpoint, so exposing it is an operator decision."""
+
     db_pool_size: int = Field(default=10, json_schema_extra=_RESTART_DB)
     db_max_overflow: int = Field(default=20, json_schema_extra=_RESTART_DB)
     db_pool_pre_ping: bool = Field(default=True, json_schema_extra=_RESTART_DB)