simple-module-hosting 0.0.32__tar.gz → 0.0.33__tar.gz

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.32
+Version: 0.0.33
 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
@@ -27,8 +27,8 @@ 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.32
-Requires-Dist: simple-module-db==0.0.32
+Requires-Dist: simple-module-core==0.0.33
+Requires-Dist: simple-module-db==0.0.33
 Requires-Dist: starlette>=0.44
 Requires-Dist: tomlkit>=0.13
 Requires-Dist: uvicorn[standard]>=0.34

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/pyproject.toml

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

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/simple_module_hosting/__init__.py

@@ -1,5 +1,6 @@
 """SimpleModule Hosting - App builder, module loader, middleware pipeline."""
 
+from simple_module_hosting._preapp_config import merge_host_settings
 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
@@ -13,6 +14,7 @@ __all__ = [
     "SharedPropsProvider",
     "correlation_id",
     "create_app",
+    "merge_host_settings",
     "register_inertia_shared_provider",
     "setup_logging",
 ]

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/simple_module_hosting/_error_handlers.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Mapping
+from http import HTTPStatus
 
 from fastapi.encoders import jsonable_encoder
 from fastapi.exceptions import RequestValidationError
@@ -19,10 +21,76 @@ from starlette.requests import Request
 from starlette.responses import Response
 
 from simple_module_hosting._inertia_shared import _INERTIA_HEADER
+from simple_module_hosting.permissions import PERMISSION_DENIED_PREFIX
 
 logger = logging.getLogger(__name__)
 
-_INERTIA_ERROR_STATUSES = frozenset({403, 404, 500})
+_INERTIA_ERROR_STATUSES = frozenset({401, 403, 404, 419, 422, 429, 500, 503})
+
+# Statuses whose remedy is "sign in", so the page offers that as its primary
+# action rather than sending the visitor to the landing page.
+_SIGN_IN_STATUSES = frozenset({401, 419})
+
+
+def _specific_detail(status_code: int, message: str) -> str:
+    """The detail, unless it only restates the status.
+
+    Starlette defaults ``HTTPException.detail`` to ``HTTPStatus(code).phrase``,
+    so a plain ``HTTPException(404)`` reaches the page carrying "Not Found" and
+    a bare ``HTTPException(403)`` carrying "Forbidden". The page prefers a
+    server message over its own catalog description — right when the message
+    says something ("Administrator access required"), useless when it is the
+    title again in Title Case, and it made the page's own 404/403 sentences
+    unreachable on the very paths that produce them.
+
+    Only an exact, case-insensitive match is dropped: anything a caller
+    actually wrote survives, including a sentence that merely starts with the
+    phrase. Non-standard codes (419) have no phrase to collide with.
+    """
+    try:
+        phrase = HTTPStatus(status_code).phrase
+    except ValueError:
+        return message
+    return "" if message.strip().casefold() == phrase.casefold() else message
+
+
+def _required_permission(message: str) -> str | None:
+    """The permission named by a ``RequiresPermission`` denial, if this is one.
+
+    The 403 page says "Your role doesn't include ``<perm>``. Ask an admin to
+    grant it." — it needs the bare permission name, not the sentence the guard
+    wrote for logs and API clients. Reading it back off the detail (using the
+    guard's own exported prefix) keeps ``RequiresPermission`` as the single
+    place that knows the name; the alternative, stashing it on
+    ``request.state``, only works when the exception travels the one code path
+    that set it, and 403s are also raised by hand.
+
+    Anything else — a role-gated ``/admin`` 403, a hand-raised
+    ``HTTPException(403, "Administrator access required")`` — yields ``None``,
+    and the page falls back to copy that names no permission.
+    """
+    if not message.startswith(PERMISSION_DENIED_PREFIX):
+        return None
+    return message[len(PERMISSION_DENIED_PREFIX) :].strip() or None
+
+
+def _login_url(request: Request) -> str | None:
+    """Best-effort login URL for the sign-in statuses.
+
+    Read off ``app.state`` rather than imported: the auth provider is a plugin
+    concern and ``SM009`` forbids framework code importing ``modules/*``. An
+    app with no auth provider installed simply gets no sign-in button.
+    """
+    auth_state = getattr(request.app.state, "auth", None)
+    provider = getattr(auth_state, "auth_provider", None)
+    if provider is None:
+        return None
+    try:
+        return provider.get_login_url(request)
+    except Exception:
+        # A broken provider must not turn an error page into a second error.
+        logger.exception("Auth provider failed to supply a login URL")
+        return None
 
 
 def _explicit_accept_q(accept: str, media_type: str) -> float | None:
@@ -85,9 +153,25 @@ def _wants_json(request: Request) -> bool:
     return is_api or bool(json_q)
 
 
-async def render_error_page(request: Request, status_code: int, message: str) -> Response:
-    config: InertiaConfig = request.app.state.sm.inertia_config
+async def render_error_page(
+    request: Request,
+    status_code: int,
+    message: str,
+    headers: Mapping[str, str] | None = None,
+) -> Response:
+    """Render the Inertia error page for *status_code*.
+
+    ``headers`` carries an ``HTTPException``'s own headers through to the
+    response. A rendered page is still the same status as the JSON body it
+    replaces, so ``WWW-Authenticate`` on a 401 and ``Retry-After`` on a
+    429/503 have to survive the switch — widening the set of statuses that
+    render a page must not quietly narrow what those responses carry.
+    """
     try:
+        # Inside the try, not above it: this lookup is exactly the kind of
+        # thing that is missing when the app is half-built, and an error page
+        # that raises while reporting an error leaves the caller with nothing.
+        config: InertiaConfig = request.app.state.sm.inertia_config
         inertia = Inertia(request, config)
         # This builds its own Inertia instead of going through get_inertia, so
         # the share step has to be repeated here. Without it the error page
@@ -104,11 +188,23 @@ async def render_error_page(request: Request, status_code: int, message: str) ->
             "Error",
             {
                 "status": status_code,
-                "message": message,
+                # Not the raw detail: a default one is just the status phrase,
+                # and the page renders any message it is given ahead of its own
+                # copy. See `_specific_detail`.
+                "message": _specific_detail(status_code, message),
                 "correlation_id": getattr(request.state, "correlation_id", "") or "",
+                # Always present, null when no permission is involved: the page
+                # branches on it, and an absent prop is indistinguishable there
+                # from one that was never wired.
+                "required_permission": _required_permission(message),
+                "login_url": (_login_url(request) if status_code in _SIGN_IN_STATUSES else None),
+                # Set by MaintenanceMiddleware. A planned outage reads very
+                # differently from the same status code arriving unbidden.
+                "maintenance": bool(getattr(request.state, "maintenance", False)),
             },
         )
         response.status_code = status_code
+        _apply_headers(response, headers)
         return response
     except InertiaVersionConflictException as exc:
         return await inertia_version_conflict_exception_handler(request, exc)
@@ -116,20 +212,36 @@ async def render_error_page(request: Request, status_code: int, message: str) ->
         # Fallback if Inertia rendering itself fails (e.g. missing session)
         logger.exception("Error page rendering failed, falling back to JSON")
         return JSONResponse(
-            status_code=status_code, content={"detail": message or "Internal Server Error"}
+            status_code=status_code,
+            content={"detail": message or "Internal Server Error"},
+            headers=dict(headers) if headers else None,
         )
 
 
+def _apply_headers(response: Response, headers: Mapping[str, str] | None) -> None:
+    """Copy exception headers onto an already-built response.
+
+    Set rather than appended: these are single-valued response headers, and
+    a duplicate ``Retry-After`` is worse than none.
+    """
+    if not headers:
+        return
+    for key, value in headers.items():
+        response.headers[key] = value
+
+
 async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
+    # Preserve exception headers (WWW-Authenticate, Retry-After, ...) the way
+    # FastAPI's stock handler does — on the rendered page as well as the JSON
+    # body, since both answer with the same status.
+    headers = getattr(exc, "headers", None)
     if exc.status_code in _INERTIA_ERROR_STATUSES and not _wants_json(request):
         detail = str(exc.detail) if exc.detail else ""
-        return await render_error_page(request, exc.status_code, detail)
-    # Preserve exception headers (WWW-Authenticate, Retry-After, ...) the way
-    # FastAPI's stock handler does.
+        return await render_error_page(request, exc.status_code, detail, headers)
     return JSONResponse(
         status_code=exc.status_code,
         content={"detail": exc.detail},
-        headers=getattr(exc, "headers", None),
+        headers=headers,
     )
 
 

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/simple_module_hosting/_inertia_shared.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from typing import Any
 
+from simple_module_core.i18n import Translator
 from starlette.datastructures import Headers
 from starlette.requests import Request
 from starlette.types import Scope
@@ -77,6 +79,30 @@ def build_i18n_block(scope: Scope, request: Request, *, is_authenticated: bool =
     }
 
 
+def build_menu_translator(request: Request) -> Callable[[str], str] | None:
+    """Return a locale-bound translator for menu labels, or None if unavailable.
+
+    Menu labels are translated on the server rather than in the client: the
+    payload then carries finished text, so the sidebar, topbar and command
+    palette all keep rendering ``item.label`` unchanged. It also sidesteps the
+    catalog audience split — an admin-audience module's labels never have to be
+    present in the anonymous snapshot to be readable.
+
+    Mirrors ``build_i18n_block``'s defensive lookups: test fixtures build apps
+    with a partial ``app.state.sm``, and a missing registry must degrade to the
+    literal labels rather than raise on every request.
+    """
+    sm = getattr(request.app.state, "sm", None)
+    registry = getattr(sm, "i18n_registry", None) if sm is not None else None
+    locale = getattr(request.state, "locale", None)
+    if registry is None or locale is None:
+        return None
+    settings = getattr(sm, "settings", None)
+    default_locale = getattr(settings, "i18n_default_locale", "en") if settings else "en"
+    translator = Translator(registry, locale=locale, default_locale=default_locale)
+    return translator.t
+
+
 def merge_shared_prop_providers(app: Any, request: Request, shared: dict) -> None:
     """Merge module-registered Inertia shared-prop providers into ``shared`` in place.
 

simple_module_hosting-0.0.33/simple_module_hosting/_lifespan.py

@@ -0,0 +1,130 @@
+"""The app's startup and shutdown sequence.
+
+Split out of ``app_builder`` so that file stays focused on *wiring* — which
+modules load, what middleware is installed, where routes mount — while this
+one owns *when things happen* at run time.
+
+Ordering here is load-bearing. Settings hydrate from the database before any
+module's ``on_startup`` runs, so startup code reads DB-backed values rather
+than pydantic defaults. Shutdown runs in reverse module order, mirroring
+dependency direction, and disposes the engine last so a module's shutdown hook
+can still reach the database.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator, Callable, Sequence
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from simple_module_hosting.migrations import migration_status
+from simple_module_hosting.setup_gate import STEP_MIGRATIONS
+
+
+async def hydrate_settings_from_db(app: FastAPI) -> None:
+    """Merge DB-stored overrides into every registered settings object.
+
+    Resolved through ``importlib`` rather than a static import because the
+    SM009 coupling check is AST-based and forbids ``framework/*`` from naming
+    a plugin package. No-ops when the settings module isn't installed.
+
+    Note this is the *second* settings read of a boot. The first happens in
+    ``_preapp_config`` before ``create_app`` builds anything, because the
+    module list, i18n registry and middleware stack are all constructed from
+    settings and cannot be rebuilt from here.
+    """
+    if not hasattr(app.state, "settings"):
+        return
+
+    import importlib
+
+    from simple_module_hosting._hydrate_step import hydrate_all
+
+    service_cls = importlib.import_module("settings.service").SettingService
+    store_cls = importlib.import_module("settings.store").SettingsStore
+
+    async with app.state.sm.db.session_factory() as session:
+        await hydrate_all(app, store_cls(service_cls(session)))
+
+
+async def _is_first_run(app: FastAPI) -> bool:
+    """Whether this install has never been set up at all.
+
+    The distinction the boot check turns on. Two very different situations both
+    leave ``host.migrations`` outstanding:
+
+    - A **fresh deployment**: nothing is configured, so the administrator step
+      is pending too. Serving the wizard is exactly right — running the
+      migrations is one of the things it exists to do.
+    - A **configured install whose schema drifted**: someone deployed code
+      ahead of the migration job. It has administrators; only the schema is
+      behind.
+
+    Treating the second as "setup mode" is wrong twice over. It serves traffic
+    against a schema the code does not match — the failure ``SM010`` exists to
+    prevent — and it re-opens ``/setup``, whose migration endpoint is
+    unauthenticated, letting an anonymous request trigger an Alembic run on a
+    live system.
+
+    So: first run means *something other than the schema* is also outstanding.
+    ``False`` when no registry exists, since an app built outside
+    ``create_app`` has no steps to reason about and the old raising behaviour
+    is the safer default there.
+
+    Deliberately does not delegate to ``registry.incomplete()``: that method
+    treats a step whose predicate raises as *complete*, which is right for
+    ``SetupMiddleware``'s steady-state gate (a transient DB error must not
+    lock a working install out) but wrong here. On a genuinely fresh
+    database the non-migration steps' own tables don't exist yet — the
+    administrator check is a query against a table migrations create — so it
+    raises too, and swallowing that would make every step but the schema
+    look satisfied, exactly the "is setup complete" trap this function
+    exists to avoid. Here, a required step raising while the schema is
+    behind counts as pending: it is itself evidence the install is new.
+    """
+    registry = getattr(app.state.sm, "setup_registry", None)
+    if not registry:
+        return False
+    for step in registry.required_steps:
+        if step.id == STEP_MIGRATIONS:
+            continue
+        try:
+            done = await step.is_complete(app)
+        except Exception:
+            return True
+        if not done:
+            return True
+    return False
+
+
+def build_lifespan(modules: Sequence) -> Callable:
+    """Return the ``lifespan`` context manager for an app over *modules*."""
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+        # Report first, decide second. On a genuinely fresh install a
+        # behind-head database must still boot far enough to serve the wizard —
+        # running the migrations is one of the things that wizard does, and
+        # check_migrations' RuntimeError would make it unreachable. Anywhere
+        # else the original behaviour stands: a schema the code does not match
+        # fails the boot. See _is_first_run for why those two cases cannot be
+        # told apart by "is setup complete".
+        app.state.migration = await migration_status(app.state.sm.db.engine)
+        if not app.state.migration["is_current"] and not await _is_first_run(app):
+            raise RuntimeError(
+                f"Database is {app.state.migration['pending_count']} revision(s) behind "
+                f"(at {app.state.migration['current_revision']!r}, head is "
+                f"{app.state.migration['head_revision']!r}). Run: make migrate"
+            )
+
+        await hydrate_settings_from_db(app)
+
+        for mod in modules:
+            await mod.on_startup(app)
+        yield
+        for mod in reversed(modules):
+            await mod.on_shutdown(app)
+        await app.state.sm.db.engine.dispose()
+
+    return lifespan

simple_module_hosting-0.0.33/simple_module_hosting/_module_routes.py

@@ -0,0 +1,70 @@
+"""Mount a module's routers onto the app using its ``ModuleMeta`` prefixes.
+
+Split out of ``_phase_helpers`` once the admin router made this its own
+responsibility — and to keep both files under the 300-line cap.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, FastAPI
+from fastapi.routing import APIRoute
+
+__all__ = ["wire_module_routes"]
+
+
+def wire_module_routes(app: FastAPI, module) -> None:
+    """Attach a module's API + view (+ admin view) routers to ``app``.
+
+    The single canonical implementation so ``create_app`` and the test harness
+    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"])
+    module.register_routes(api_router, view_router)
+    _clone_bare_prefix_route(view_router, module.meta.view_prefix)
+    app.include_router(api_router)
+    app.include_router(view_router)
+
+    # Second view router for modules that serve both public and admin pages
+    # and therefore cannot express both under a single view_prefix — see
+    # ``ModuleMeta.admin_view_prefix``.
+    admin_prefix = getattr(module.meta, "admin_view_prefix", "")
+    if admin_prefix:
+        admin_router = APIRouter(
+            prefix=admin_prefix,
+            tags=[f"{module.meta.name} Admin Views"],
+        )
+        module.register_admin_routes(admin_router)
+        _clone_bare_prefix_route(admin_router, admin_prefix)
+        app.include_router(admin_router)
+
+
+def _clone_bare_prefix_route(router: APIRouter, prefix: str) -> None:
+    """Serve ``"/foo"`` as well as ``"/foo/"`` for a bare-prefix route.
+
+    Without this, FastAPI's ``redirect_slashes=True`` fires a 307 to
+    ``"/foo/"``, which clients like httpx strip ``X-Inertia`` from on follow —
+    turning that Inertia navigation into a broken HTML response.
+
+    Only covers routes declared *directly* on the router. A route contributed
+    via ``router.include_router(...)`` — which is how most modules register —
+    is not visible here: ``include_router`` stores a placeholder and only
+    flattens into ``APIRoute`` objects later, so there is nothing to match
+    yet. Modules in that (majority) case point their menu item at the
+    canonical trailing-slash URL instead, which costs no redirect either.
+    """
+    if not prefix:
+        return
+    bare_target = f"{prefix}/"
+    for route in list(router.routes):
+        if isinstance(route, APIRoute) and route.path == bare_target:
+            router.add_api_route(
+                "",
+                route.endpoint,
+                methods=list(route.methods or {"GET"}),
+                response_model=route.response_model,
+                include_in_schema=False,
+                dependencies=route.dependencies,
+                name=f"{route.name}__bare",
+            )

{simple_module_hosting-0.0.32 → simple_module_hosting-0.0.33}/simple_module_hosting/_phase_helpers.py

@@ -11,9 +11,8 @@ import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from fastapi import APIRouter, FastAPI
+from fastapi import FastAPI
 from fastapi.exceptions import RequestValidationError
-from fastapi.routing import APIRoute
 from fastapi.staticfiles import StaticFiles
 from inertia import (
     InertiaVersionConflictException,
@@ -24,7 +23,6 @@ from simple_module_core.exceptions import NotFoundError
 from simple_module_db import CommitBeforeResponseMiddleware
 from starlette.exceptions import HTTPException
 from starlette.middleware.gzip import GZipMiddleware
-from starlette.middleware.sessions import SessionMiddleware
 from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
 
 from simple_module_hosting._error_handlers import (
@@ -35,8 +33,10 @@ from simple_module_hosting._error_handlers import (
 )
 from simple_module_hosting._host_services import _HostServices
 from simple_module_hosting._inertia_cache import InertiaCacheMiddleware
+from simple_module_hosting._module_routes import wire_module_routes
 from simple_module_hosting.host_settings import HostSettings
 from simple_module_hosting.i18n_middleware import LocaleMiddleware
+from simple_module_hosting.maintenance import MaintenanceMiddleware
 from simple_module_hosting.middleware import (
     CorrelationIdMiddleware,
     InertiaLayoutDataMiddleware,
@@ -44,7 +44,9 @@ from simple_module_hosting.middleware import (
     SecurityHeadersMiddleware,
     TenantMiddleware,
 )
+from simple_module_hosting.session import SessionMiddleware
 from simple_module_hosting.settings import Settings
+from simple_module_hosting.setup_gate import SETUP_PATH, SetupMiddleware
 from simple_module_hosting.static_files import PrecompressedStaticFiles
 
 if TYPE_CHECKING:
@@ -104,12 +106,27 @@ def install_middleware(
     Order matters: last added = first executed. Execution order:
     (ProxyHeaders, if trusted_proxy) → CorrelationId → RequestLogging
     → Security → Session → [module] → (Tenant, if multi_tenant) → Locale
-    → Inertia → InertiaCache → CommitBeforeResponse.
+    → Inertia → InertiaCache → Setup → Maintenance → CommitBeforeResponse.
     """
     # Added first, so it is innermost and its send-wrapper is the first to see
     # the response: the request's DB work commits before any byte reaches the
     # client, instead of in get_db's post-response exit code (GH #257).
     app.add_middleware(CommitBeforeResponseMiddleware)
+    # Inside InertiaCache, so its short-circuit is still governed by it. The
+    # maintenance 503 renders through Inertia and carries this user's auth
+    # block and menus like any other payload; short-circuiting *outside* the
+    # cache guard would ship exactly the per-user payload GH #272 exists to
+    # keep out of caches. Added before Inertia so it *executes* after it: the
+    # page needs the shared props (auth, menus, i18n) to render with a layout,
+    # and auth + locale — both further out — to know who is asking and in which
+    # language to answer.
+    app.add_middleware(MaintenanceMiddleware)
+    # Added after Maintenance so it *executes* before it: an install that has
+    # never been set up has nothing meaningful to put into maintenance mode,
+    # and the setup redirect should win. Inside InertiaCache for the same
+    # reason Maintenance is — this short-circuits, and the redirect must not
+    # be stored by any cache.
+    app.add_middleware(SetupMiddleware)
     # Paired with InertiaLayoutDataMiddleware below, which is what puts this
     # user's auth, permissions and menus into every Inertia payload: this one
     # makes sure the payload that results is never stored where a page request
@@ -166,6 +183,18 @@ def attach_public_routes(app: FastAPI, settings: Settings, registry) -> None:
     ``app.state.public_routes``, where ``auth.middleware.AuthMiddleware`` reads it
     on every request.
     """
+    # The setup wizard is anonymous by necessity: it is served precisely when
+    # no account exists, so gating it behind auth would redirect the operator
+    # to a login they cannot pass. Its own handlers 404 once setup completes,
+    # which is what keeps this exemption from outliving its purpose.
+    #
+    # Exact + trailing-slash prefix, not a bare "/setup" prefix: the latter
+    # would also hand anonymous access to any unrelated route that happens to
+    # start with those six characters ("/setup-guide"), and nothing about that
+    # route asked to be public.
+    registry.add_exact(SETUP_PATH)
+    registry.add_prefix(f"{SETUP_PATH}/")
+
     for prefix in settings.auth_public_paths:
         registry.add_prefix(prefix)
     app.state.public_routes = registry
@@ -256,35 +285,4 @@ def check_settings_registration(app: FastAPI, modules: list) -> list[Diagnostic]
     return diagnostics
 
 
-def wire_module_routes(app: FastAPI, module) -> None:
-    """Attach a module's API + view routers to ``app`` using its Meta prefixes.
-
-    The single canonical implementation so ``create_app`` and the test harness
-    in ``simple_module_test`` stay in lockstep if ``ModuleBase`` ever gains
-    a new router type.
-
-    Bare-prefix view routes (``view_prefix="/foo"`` + ``@router.get("/")``)
-    are also mounted at the trailing-slash-less form ``"/foo"``. Without this,
-    FastAPI's ``redirect_slashes=True`` fires a 307 to ``"/foo/"``, which
-    clients like httpx strip ``X-Inertia`` from on follow — turning every
-    Inertia navigation into a broken HTML response. Cloning the route at the
-    bare-prefix path serves the same handler directly, no redirect.
-    """
-    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"])
-    module.register_routes(api_router, view_router)
-    if module.meta.view_prefix:
-        bare_target = f"{module.meta.view_prefix}/"
-        for route in list(view_router.routes):
-            if isinstance(route, APIRoute) and route.path == bare_target:
-                view_router.add_api_route(
-                    "",
-                    route.endpoint,
-                    methods=list(route.methods or {"GET"}),
-                    response_model=route.response_model,
-                    include_in_schema=False,
-                    dependencies=route.dependencies,
-                    name=f"{route.name}__bare",
-                )
-    app.include_router(api_router)
-    app.include_router(view_router)
+__all__ = ["wire_module_routes"]