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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_hosting
-Version: 0.0.38
+Version: 0.0.40
 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
@@ -21,19 +21,19 @@ Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: click>=8.1
-Requires-Dist: fastapi<0.157,>=0.140
-Requires-Dist: httpx>=0.27
-Requires-Dist: itsdangerous>=2.0
-Requires-Dist: jinja2>=3.1
-Requires-Dist: simple-module-core==0.0.38
-Requires-Dist: simple-module-db==0.0.38
-Requires-Dist: simple-module-inertia==0.0.38
-Requires-Dist: starlette>=0.44
-Requires-Dist: tomlkit>=0.13
-Requires-Dist: uvicorn[standard]>=0.34
+Requires-Dist: click<9,>=8.1
+Requires-Dist: fastapi<0.159,>=0.140
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: itsdangerous<3,>=2.0
+Requires-Dist: jinja2<4,>=3.1
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-inertia==0.0.40
+Requires-Dist: starlette<2,>=0.44
+Requires-Dist: tomlkit<0.16,>=0.13
+Requires-Dist: uvicorn[standard]<0.55,>=0.34
 Provides-Extra: redis
-Requires-Dist: redis>=5; extra == 'redis'
+Requires-Dist: redis<7,>=5; extra == 'redis'
 Provides-Extra: sentry
 Requires-Dist: sentry-sdk[celery,fastapi]<3,>=2.20; extra == 'sentry'
 Description-Content-Type: text/markdown

{simple_module_hosting-0.0.38 → simple_module_hosting-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_hosting"
-version = "0.0.38"
+version = "0.0.40"
 description = "FastAPI + Inertia.js host runtime for simple_module — app_builder, middleware stack, CLI (sm / simple-module), scaffolding"
 readme = "README.md"
 license = "MIT"
@@ -21,25 +21,25 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "click>=8.1",
-    "fastapi>=0.140,<0.157",
-    "httpx>=0.27",
+    "click>=8.1,<9",
+    "fastapi>=0.140,<0.159",
+    "httpx>=0.27,<0.29",
     # SessionMiddleware (starlette.middleware.sessions) imports itsdangerous at
     # module import time; starlette treats it as an optional extra, so declare
     # it directly — out-of-tree hosts have nothing else pulling it in.
-    "itsdangerous>=2.0",
-    "jinja2>=3.1",
-    "simple_module_core==0.0.38",
-    "simple_module_db==0.0.38",
-    "simple_module_inertia==0.0.38",
-    "starlette>=0.44",
-    "tomlkit>=0.13",
-    "uvicorn[standard]>=0.34",
+    "itsdangerous>=2.0,<3",
+    "jinja2>=3.1,<4",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_inertia==0.0.40",
+    "starlette>=0.44,<2",
+    "tomlkit>=0.13,<0.16",
+    "uvicorn[standard]>=0.34,<0.55",
 ]
 
 [project.optional-dependencies]
 # Shared rate-limiter store (SM_REDIS_URL). Without it the limiter counts per worker.
-redis = ["redis>=5"]
+redis = ["redis>=5,<7"]
 # Error reporting (SM_SENTRY_DSN). Never imported unless the DSN is set.
 sentry = ["sentry-sdk[fastapi,celery]>=2.20,<3"]
 

{simple_module_hosting-0.0.38 → simple_module_hosting-0.0.40}/simple_module_hosting/_body_limit.py

@@ -22,7 +22,7 @@ from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from simple_module_hosting._error_handlers import _wants_json
+from simple_module_hosting._error_negotiation import _wants_json
 from simple_module_hosting._request_guard_responses import send_guard_response
 
 logger = logging.getLogger("simple_module.request_guard")

{simple_module_hosting-0.0.38 → simple_module_hosting-0.0.40}/simple_module_hosting/_boot_checks.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
+from simple_module_core.app_state import get_tenant_resolver
 from simple_module_core.diagnostics import Diagnostic, check_tenant_resolver, print_diagnostics
 
 from simple_module_hosting._route_access import check_unguarded_api_routes
@@ -27,7 +28,7 @@ logger = logging.getLogger(__name__)
 def _tenant_checks(app: FastAPI, settings: Any) -> list[Diagnostic]:
     return check_tenant_resolver(
         multi_tenant=bool(getattr(settings, "multi_tenant", False)),
-        resolver=getattr(app.state, "tenant_resolver", None),
+        resolver=get_tenant_resolver(app),
     )
 
 

simple_module_hosting-0.0.40/simple_module_hosting/_deferred_startup.py

@@ -0,0 +1,65 @@
+"""Settings hydration and deferred startup replay, independent of setup gates."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from fastapi import FastAPI
+from simple_module_core.app_state import get_deferred_startup, get_deferred_startup_lock
+from simple_module_core.module_settings import get_module_settings_registry
+from simple_module_db.stored_settings import SessionOverrideSource, settings_table_exists
+
+from simple_module_hosting._hydrate_step import hydrate_all
+
+logger = logging.getLogger(__name__)
+
+
+async def hydrate_settings_from_db(app: FastAPI) -> None:
+    """Merge DB-stored overrides into every registered settings object.
+
+    Reads the settings table directly (``simple_module_db.stored_settings``),
+    so it works whether or not the ``settings`` plugin is enabled (#500). A
+    missing table is a fresh install: nothing is stored yet, so there is
+    nothing to merge.
+
+    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 get_module_settings_registry(app) is None:
+        return
+
+    async with app.state.sm.db.session_factory() as session:
+        if not await settings_table_exists(session):
+            return
+        await hydrate_all(app, SessionOverrideSource(session), session)
+
+
+async def run_deferred_startup(app: FastAPI) -> None:
+    """Replay the ``on_startup`` hooks that could not run on an unmigrated DB.
+
+    Called from the wizard's migrations action and from the setup gate's
+    schema re-check, so a worker that did not itself run the migrations (or an
+    operator's out-of-band ``make migrate``) still finishes starting its
+    modules. Serialised per app; a hook that fails again is logged and dropped
+    rather than raised, because this runs after the migrations have already
+    committed and a 500 there would help nobody.
+    """
+    deferred = get_deferred_startup(app)
+    if not deferred:
+        return
+    lock = get_deferred_startup_lock(app)
+    if lock is None:  # no await between check and set, so this cannot race
+        lock = app.state.deferred_startup_lock = asyncio.Lock()
+    async with lock:
+        if not deferred:
+            return
+        await hydrate_settings_from_db(app)
+        while deferred:
+            mod = deferred.pop(0)
+            try:
+                await mod.on_startup(app)
+            except Exception:
+                logger.exception("Deferred on_startup of %s failed after migrations", mod.meta.name)

simple_module_hosting-0.0.40/simple_module_hosting/_error_handlers.py

@@ -0,0 +1,75 @@
+"""Framework-wide exception handlers that render Inertia error pages."""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from simple_module_core.exceptions import NotFoundError
+from simple_module_core.permission_denied import PermissionDenied
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import Response
+
+from simple_module_hosting._error_negotiation import _wants_json
+from simple_module_hosting._error_page import render_error_page
+from simple_module_hosting._observability import CorrelationIdMiddleware
+
+logger = logging.getLogger(__name__)
+
+_INERTIA_ERROR_STATUSES = frozenset({401, 403, 404, 413, 419, 422, 429, 500, 503})
+
+
+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 ""
+        required = exc.permission if isinstance(exc, PermissionDenied) else None
+        return await render_error_page(request, exc.status_code, detail, headers, required)
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"detail": exc.detail},
+        headers=headers,
+    )
+
+
+async def not_found_error_handler(request: Request, exc: NotFoundError) -> Response:
+    if _wants_json(request):
+        return JSONResponse(status_code=404, content={"detail": str(exc)})
+    return await render_error_page(request, 404, str(exc))
+
+
+async def request_validation_error_handler(
+    request: Request, exc: RequestValidationError
+) -> Response:
+    """Return an Inertia error page for browser requests with invalid params.
+
+    Same negotiation rule as 403/404/500 (``_wants_json``), so one request
+    never sees two different error shapes depending on the error class.
+    """
+    if _wants_json(request):
+        return JSONResponse(status_code=422, content={"detail": jsonable_encoder(exc.errors())})
+    return await render_error_page(request, 422, "The requested URL contains invalid parameters.")
+
+
+async def unhandled_exception_handler(request: Request, exc: Exception) -> Response:
+    logger.exception("Unhandled exception: %s", exc)
+    if _wants_json(request):
+        response: Response = JSONResponse(
+            status_code=500, content={"detail": "Internal Server Error"}
+        )
+    else:
+        response = await render_error_page(request, 500, "")
+    # A catch-all `Exception` handler runs in Starlette's ServerErrorMiddleware,
+    # which wraps *outside* CorrelationIdMiddleware, so the response never
+    # passes through it. Without this the 500 — the one response a caller most
+    # needs to quote back to support — is the one without the header.
+    cid = getattr(request.state, "correlation_id", "")
+    if cid:
+        response.headers.setdefault(CorrelationIdMiddleware.HEADER, cid)
+    return response

simple_module_hosting-0.0.40/simple_module_hosting/_error_negotiation.py

@@ -0,0 +1,65 @@
+"""Choose JSON or HTML for framework error responses."""
+
+from starlette.requests import Request
+
+from simple_module_hosting._inertia_shared import _INERTIA_HEADER
+
+
+def _explicit_accept_q(accept: str, media_type: str) -> float | None:
+    """Quality the Accept header gives ``media_type`` by explicit listing, or
+    ``None`` when the caller never named it at all.
+
+    Only exact entries count (no ``*/*`` / ``type/*`` wildcards) — the
+    negotiation below cares whether the caller *named* html or json, and at
+    what preference, and separately whether they named it *at all* (``None``
+    vs. an explicit ``q=0``). Malformed q-values fall back to 1.0 per RFC 9110.
+    """
+    for part in accept.split(","):
+        media, _, params = part.partition(";")
+        if media.strip().lower() != media_type:
+            continue
+        q = 1.0
+        for param in params.split(";"):
+            name, _, value = param.partition("=")
+            if name.strip().lower() == "q":
+                try:
+                    q = float(value.strip())
+                except ValueError:
+                    q = 1.0
+        return q
+    return None
+
+
+def _wants_json(request: Request) -> bool:
+    """API callers get JSON error bodies; browser-shaped requests get the page.
+
+    A request that explicitly accepts ``text/html`` is a browser navigation —
+    and those reach ``/api/*`` too (OAuth login links, file-download hrefs) —
+    so it always gets the rendered page, unless the caller *prefers* JSON via
+    q-values (``application/json, text/html;q=0.5`` is an API client keeping
+    an html fallback). So does an Inertia visit (``X-Inertia`` header),
+    whatever its Accept — an Inertia client can only consume Inertia-protocol
+    responses, never a bare JSON body. Otherwise ``/api/*``, the documented
+    prefix for every module's JSON surface (``ModuleMeta.route_prefix``),
+    gets JSON — a bare ``fetch()`` sends ``Accept: */*`` — as does an
+    explicit ``Accept: application/json`` anywhere else.
+
+    ``text/html;q=0`` rules html out *everywhere*, not just under ``/api/*``:
+    once the caller has explicitly said they won't accept html, this never
+    chooses the html page. The (already-moot) html fallback survives only
+    when json wasn't mentioned either — there's nothing else to offer, so a
+    view path keeps its pre-existing default and an ``/api/*`` path keeps
+    getting JSON either way.
+    """
+    if request.headers.get(_INERTIA_HEADER):
+        return False
+    accept = request.headers.get("accept", "")
+    html_q = _explicit_accept_q(accept, "text/html")
+    json_q = _explicit_accept_q(accept, "application/json")
+    if html_q is not None and html_q > 0 and html_q >= (json_q or 0.0):
+        return False
+    path = request.url.path
+    is_api = path == "/api" or path.startswith("/api/")
+    if html_q == 0:
+        return is_api if json_q is None else True
+    return is_api or bool(json_q)

simple_module_hosting-0.0.38/simple_module_hosting/_error_handlers.py → simple_module_hosting-0.0.40/simple_module_hosting/_error_page.py

@@ -1,4 +1,4 @@
-"""Framework-wide exception handlers that render Inertia error pages."""
+"""Render error responses without depending on handlers or middleware wiring."""
 
 from __future__ import annotations
 
@@ -6,28 +6,19 @@ import logging
 from collections.abc import Mapping
 from http import HTTPStatus
 
-from fastapi.encoders import jsonable_encoder
-from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
-from simple_module_core.exceptions import NotFoundError
-from simple_module_core.permission_denied import PermissionDenied
+from simple_module_core.app_state import get_auth_provider, get_inertia_dependency
 from simple_module_inertia import (
     Inertia,
     InertiaConfig,
     InertiaVersionConflictException,
     inertia_version_conflict_exception_handler,
 )
-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._observability import CorrelationIdMiddleware
-
 logger = logging.getLogger(__name__)
 
-_INERTIA_ERROR_STATUSES = frozenset({401, 403, 404, 413, 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})
@@ -62,8 +53,7 @@ def _login_url(request: Request) -> str | None:
     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)
+    provider = get_auth_provider(request.app)
     if provider is None:
         return None
     try:
@@ -74,66 +64,6 @@ def _login_url(request: Request) -> str | None:
         return None
 
 
-def _explicit_accept_q(accept: str, media_type: str) -> float | None:
-    """Quality the Accept header gives ``media_type`` by explicit listing, or
-    ``None`` when the caller never named it at all.
-
-    Only exact entries count (no ``*/*`` / ``type/*`` wildcards) — the
-    negotiation below cares whether the caller *named* html or json, and at
-    what preference, and separately whether they named it *at all* (``None``
-    vs. an explicit ``q=0``). Malformed q-values fall back to 1.0 per RFC 9110.
-    """
-    for part in accept.split(","):
-        media, _, params = part.partition(";")
-        if media.strip().lower() != media_type:
-            continue
-        q = 1.0
-        for param in params.split(";"):
-            name, _, value = param.partition("=")
-            if name.strip().lower() == "q":
-                try:
-                    q = float(value.strip())
-                except ValueError:
-                    q = 1.0
-        return q
-    return None
-
-
-def _wants_json(request: Request) -> bool:
-    """API callers get JSON error bodies; browser-shaped requests get the page.
-
-    A request that explicitly accepts ``text/html`` is a browser navigation —
-    and those reach ``/api/*`` too (OAuth login links, file-download hrefs) —
-    so it always gets the rendered page, unless the caller *prefers* JSON via
-    q-values (``application/json, text/html;q=0.5`` is an API client keeping
-    an html fallback). So does an Inertia visit (``X-Inertia`` header),
-    whatever its Accept — an Inertia client can only consume Inertia-protocol
-    responses, never a bare JSON body. Otherwise ``/api/*``, the documented
-    prefix for every module's JSON surface (``ModuleMeta.route_prefix``),
-    gets JSON — a bare ``fetch()`` sends ``Accept: */*`` — as does an
-    explicit ``Accept: application/json`` anywhere else.
-
-    ``text/html;q=0`` rules html out *everywhere*, not just under ``/api/*``:
-    once the caller has explicitly said they won't accept html, this never
-    chooses the html page. The (already-moot) html fallback survives only
-    when json wasn't mentioned either — there's nothing else to offer, so a
-    view path keeps its pre-existing default and an ``/api/*`` path keeps
-    getting JSON either way.
-    """
-    if request.headers.get(_INERTIA_HEADER):
-        return False
-    accept = request.headers.get("accept", "")
-    html_q = _explicit_accept_q(accept, "text/html")
-    json_q = _explicit_accept_q(accept, "application/json")
-    if html_q is not None and html_q > 0 and html_q >= (json_q or 0.0):
-        return False
-    path = request.url.path
-    is_api = path == "/api" or path.startswith("/api/")
-    if html_q == 0:
-        return is_api if json_q is None else True
-    return is_api or bool(json_q)
-
-
 async def render_error_page(
     request: Request,
     status_code: int,
@@ -164,7 +94,7 @@ async def render_error_page(
         # 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)
+        inertia_dep = get_inertia_dependency(request.app)
         if inertia_dep is not None:
             inertia = inertia_dep(request, None)
         else:
@@ -224,56 +154,3 @@ def _apply_headers(response: Response, headers: Mapping[str, str] | None) -> Non
         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 ""
-        required = exc.permission if isinstance(exc, PermissionDenied) else None
-        return await render_error_page(request, exc.status_code, detail, headers, required)
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={"detail": exc.detail},
-        headers=headers,
-    )
-
-
-async def not_found_error_handler(request: Request, exc: NotFoundError) -> Response:
-    if _wants_json(request):
-        return JSONResponse(status_code=404, content={"detail": str(exc)})
-    return await render_error_page(request, 404, str(exc))
-
-
-async def request_validation_error_handler(
-    request: Request, exc: RequestValidationError
-) -> Response:
-    """Return an Inertia error page for browser requests with invalid params.
-
-    Same negotiation rule as 403/404/500 (``_wants_json``), so one request
-    never sees two different error shapes depending on the error class.
-    """
-    if _wants_json(request):
-        return JSONResponse(status_code=422, content={"detail": jsonable_encoder(exc.errors())})
-    return await render_error_page(request, 422, "The requested URL contains invalid parameters.")
-
-
-async def unhandled_exception_handler(request: Request, exc: Exception) -> Response:
-    logger.exception("Unhandled exception: %s", exc)
-    if _wants_json(request):
-        response: Response = JSONResponse(
-            status_code=500, content={"detail": "Internal Server Error"}
-        )
-    else:
-        response = await render_error_page(request, 500, "")
-    # A catch-all `Exception` handler runs in Starlette's ServerErrorMiddleware,
-    # which wraps *outside* CorrelationIdMiddleware, so the response never
-    # passes through it. Without this the 500 — the one response a caller most
-    # needs to quote back to support — is the one without the header.
-    cid = getattr(request.state, "correlation_id", "")
-    if cid:
-        response.headers.setdefault(CorrelationIdMiddleware.HEADER, cid)
-    return response

{simple_module_hosting-0.0.38 → simple_module_hosting-0.0.40}/simple_module_hosting/_inertia_setup.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import hashlib
 import logging
 from pathlib import Path
 
 from fastapi import FastAPI
+from simple_module_core.app_state import get_branding, get_host_services
 from simple_module_inertia import InertiaConfig, SiteInfo, inertia_dependency_factory
 from starlette.requests import Request
 
@@ -50,8 +52,8 @@ def branding_head(request: Request) -> dict:
     """
     # A per-request object (same duck shape) wins: branding resolves a tenant's
     # own theme into ``request.state.branding`` from its shared-props provider.
-    services = getattr(getattr(request, "state", None), "branding", None) or getattr(
-        request.app.state, "branding", None
+    services = getattr(getattr(request, "state", None), "branding", None) or get_branding(
+        request.app
     )
     settings = getattr(services, "settings", None)
     app_name = getattr(settings, "app_name", "") or _DEFAULT_APP_NAME
@@ -68,7 +70,7 @@ def branding_head(request: Request) -> dict:
 
 def site_info(request: Request) -> SiteInfo:
     """The public base URL (operator setting, never the request ``Host``) and app name."""
-    host = getattr(request.app.state, "host", None)
+    host = get_host_services(request.app)
     base_url = getattr(getattr(host, "settings", None), "public_base_url", "") or ""
     return SiteInfo(base_url=base_url, app_name=branding_head(request)["app_name"])
 
@@ -144,12 +146,18 @@ def setup_inertia(
 
     use_dev_server = settings.environment in NON_PROD_ENVIRONMENTS
     inertia_environment = "development" if use_dev_server else "production"
+    manifest_path = "" if use_dev_server else _prod_manifest_path(project_root)
+    version = (
+        hashlib.sha256(Path(manifest_path).read_bytes()).hexdigest()
+        if manifest_path
+        else _INERTIA_VERSION
+    )
 
     inertia_config = InertiaConfig(
         environment=inertia_environment,
-        version=_INERTIA_VERSION,
+        version=version,
         dev_url=settings.vite_dev_url if use_dev_server else "",
-        manifest_json_path="" if use_dev_server else _prod_manifest_path(project_root),
+        manifest_json_path=manifest_path,
         assets_prefix="" if use_dev_server else _ASSETS_PREFIX,
         templates=templates,
         root_template_filename=_ROOT_TEMPLATE_FILENAME,

{simple_module_hosting-0.0.38 → simple_module_hosting-0.0.40}/simple_module_hosting/_inertia_shared.py

@@ -7,6 +7,7 @@ import logging
 from collections.abc import Callable
 from typing import Any
 
+from simple_module_core.app_state import get_inertia_shared_providers, get_services
 from simple_module_core.i18n import Translator
 from starlette.datastructures import Headers
 from starlette.requests import Request
@@ -45,7 +46,7 @@ def build_i18n_block(scope: Scope, request: Request, *, is_authenticated: bool =
     """
     # Test fixtures sometimes build a bare FastAPI with a partial app.state.sm
     # stub (e.g. permissions-only, no i18n); guard both lookups to keep them usable.
-    sm = getattr(request.app.state, "sm", None)
+    sm = get_services(request.app)
     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:
@@ -138,7 +139,7 @@ def build_menu_translator(request: Request) -> Callable[[str], str] | None:
     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)
+    sm = get_services(request.app)
     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:
@@ -158,7 +159,7 @@ async def merge_shared_prop_providers(app: Any, request: Request, shared: dict)
     provider's key. A provider may be ``async`` (its result is awaited) — a
     per-tenant lookup cannot be answered from a process-wide object.
     """
-    providers = getattr(app.state, "inertia_shared_providers", None) or ()
+    providers = get_inertia_shared_providers(app) or ()
     for provider in providers:
         name = getattr(provider, "__name__", provider)
         try:
@@ -187,6 +188,6 @@ def default_home_url(app: Any) -> str:
     named by string from ``sm.view_prefixes`` so nothing is imported (SM009);
     ``/`` is a host route in every app, so the link can never 404.
     """
-    sm = getattr(app.state, "sm", None)
+    sm = get_services(app)
     prefix = getattr(sm, "view_prefixes", {}).get("Dashboard")
     return f"{prefix}/" if prefix else "/"