simple-module-settings 0.0.31__tar.gz → 0.0.32__tar.gz

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_settings
-Version: 0.0.31
+Version: 0.0.32
 Summary: Runtime settings UI — modules plug their own settings panels into a shared admin view
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,9 +21,9 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: simple-module-core==0.0.31
-Requires-Dist: simple-module-db==0.0.31
-Requires-Dist: simple-module-hosting==0.0.31
+Requires-Dist: simple-module-core==0.0.32
+Requires-Dist: simple-module-db==0.0.32
+Requires-Dist: simple-module-hosting==0.0.32
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_settings"
-version = "0.0.31"
+version = "0.0.32"
 description = "Runtime settings UI — modules plug their own settings panels into a shared admin view"
 readme = "README.md"
 license = "MIT"
@@ -21,9 +21,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.31",
-    "simple_module_db==0.0.31",
-    "simple_module_hosting==0.0.31",
+    "simple_module_core==0.0.32",
+    "simple_module_db==0.0.32",
+    "simple_module_hosting==0.0.32",
     "typer>=0.12",
 ]
 

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/settings/_module_settings.py

@@ -12,10 +12,12 @@ from dataclasses import dataclass
 from typing import Any
 
 from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
 from pydantic_settings import BaseSettings
 
 from settings.env_vars import env_prefix_for
 from settings.hydrate import value_type_for_field
+from settings.service import SettingService
 
 # We intentionally DON'T match the bare word "token" (would mask
 # `verification_token_lifetime_seconds` — just an int) or "key" alone (would
@@ -236,8 +238,29 @@ def _build_view(
     )
 
 
+async def overrides_by_package(service: SettingService) -> dict[str, frozenset[str]]:
+    """Map package -> field names carrying a stored override.
+
+    Reads the SYSTEM scope once and buckets by key prefix. Packages with no
+    overrides are simply absent, which :func:`collect_module_settings` already
+    treats as "nothing overridden". Shared by both the Inertia view and the
+    JSON API so the two never drift on what "overridden" means.
+    """
+    from settings.store import SettingsStore
+
+    return await SettingsStore(service).all_override_fields()
+
+
 def serialize(views: list[ModuleSettingsView]) -> list[dict[str, Any]]:
-    """Convert dataclass views to plain dicts for Inertia props."""
+    """Convert dataclass views to plain dicts for Inertia props.
+
+    Field values arrive as whatever type the module declared — pydantic has
+    already coerced ``media_root: Path`` to a ``PosixPath``, ``timeout:
+    timedelta`` to a ``timedelta`` — and this screen reflects every installed
+    module's settings, so the set of types is open-ended by design. They are
+    encoded here rather than handed on as-is: this is the boundary where a
+    settings object stops being Python and becomes a prop.
+    """
     return [
         {
             "module_name": v.module_name,
@@ -248,8 +271,8 @@ def serialize(views: list[ModuleSettingsView]) -> list[dict[str, Any]]:
                 {
                     "name": f.name,
                     "env_var": f.env_var,
-                    "value": f.value,
-                    "default": f.default,
+                    "value": jsonable_encoder(f.value),
+                    "default": jsonable_encoder(f.default),
                     "description": f.description,
                     "is_secret": f.is_secret,
                     "type": f.type,

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/settings/endpoints/module_api.py

@@ -17,6 +17,7 @@ from settings._module_settings import (
     SECRET_MASK,
     collect_module_settings,
     is_secret_field,
+    overrides_by_package,
     serialize,
 )
 from settings.constants import MODULE_PACKAGE, PERM_DELETE, PERM_EDIT, PERM_VIEW
@@ -47,8 +48,15 @@ def _strip_mask_sentinels(changes: dict[str, Any]) -> dict[str, Any]:
 
 
 @router.get("", dependencies=_VIEW)
-async def list_modules(request: Request) -> dict[str, Any]:
-    views = collect_module_settings(request.app)
+async def list_modules(
+    request: Request,
+    service: SettingService = Depends(get_setting_service),
+) -> dict[str, Any]:
+    # Match the Inertia ModulesEdit view: without the overrides map, every
+    # field's `source`/`db_override` would report env/default even when a
+    # stored override is actually in force.
+    overrides = await overrides_by_package(service)
+    views = collect_module_settings(request.app, overrides)
     return {"modules": serialize(views)}
 
 

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/settings/endpoints/views.py

@@ -9,6 +9,8 @@ strings below match what ``pages/*.tsx`` declare.
 
 from __future__ import annotations
 
+import asyncio
+
 from fastapi import APIRouter, Depends, HTTPException, Request
 from inertia import InertiaResponse
 from pydantic import ValidationError
@@ -17,7 +19,12 @@ from simple_module_hosting.inertia_utils import redirect_back_with_errors, valid
 from simple_module_hosting.permissions import RequiresPermission
 from starlette.responses import RedirectResponse
 
-from settings._module_settings import _package_of, collect_module_settings, serialize
+from settings._module_settings import (
+    _package_of,
+    collect_module_settings,
+    overrides_by_package,
+    serialize,
+)
 from settings.constants import (
     ERR_SETTING_NOT_FOUND,
     PERM_CREATE,
@@ -187,7 +194,7 @@ async def modules_view(
     an ``SM_*`` env var, or the field default — so a setting that "isn't taking
     effect" explains itself.
     """
-    overrides = await _overrides_by_package(service)
+    overrides = await overrides_by_package(service)
     views = collect_module_settings(request.app, overrides)
     return await inertia.render(
         _PAGE_MODULES_EDIT,
@@ -200,18 +207,6 @@ async def modules_view(
     )
 
 
-async def _overrides_by_package(service: SettingService) -> dict[str, frozenset[str]]:
-    """Map package -> field names carrying a stored override.
-
-    Reads the SYSTEM scope once and buckets by key prefix. Packages with no
-    overrides are simply absent, which ``collect_module_settings`` already
-    treats as "nothing overridden".
-    """
-    from settings.store import SettingsStore
-
-    return await SettingsStore(service).all_override_fields()
-
-
 def _testable_packages(request: Request) -> list[str]:
     """Packages whose module registered at least one health check.
 
@@ -257,13 +252,21 @@ async def test_connection(package: str, request: Request) -> dict:
     if not checks:
         raise HTTPException(status_code=404, detail=f"{owner.meta.name} has no connection to test")
 
-    results = []
-    for check in checks:
+    # Run independently of one another — a module can register several checks
+    # (e.g. SMTP + primary storage + backup storage), and sequentially awaiting
+    # each one would block the request for the sum of their latencies instead
+    # of the slowest one, the same reasoning dashboard.stats._run_health_checks
+    # already applies to probe checks.
+    async def _run_one(check) -> dict:
         try:
             outcome = await check.check()
-            results.append(
-                {"name": check.name, "status": outcome.status.value, "detail": outcome.detail or ""}
-            )
+            return {
+                "name": check.name,
+                "status": outcome.status.value,
+                "detail": outcome.detail or "",
+            }
         except Exception as exc:
-            results.append({"name": check.name, "status": "unhealthy", "detail": str(exc)})
+            return {"name": check.name, "status": "unhealthy", "detail": str(exc)}
+
+    results = await asyncio.gather(*[_run_one(c) for c in checks])
     return {"module": owner.meta.name, "checks": results}

{simple_module_settings-0.0.31 → simple_module_settings-0.0.32}/settings/pages/ModulesEdit.tsx

@@ -36,7 +36,9 @@ function ModulesEdit({ modules, testable = [] }: Props) {
   return (
     <>
       <Head title="Modules" />
-      <div className="flex h-[calc(100vh-64px)] bg-background">
+      {/* Master/detail pane fills the viewport minus the chrome above it,
+          whose height the layout publishes as --app-chrome-h. */}
+      <div className="flex h-[calc(100vh-var(--app-chrome-h))] bg-background">
         <aside className="w-72 shrink-0 border-r border-border bg-secondary/30 overflow-y-auto">
           <div className="p-3">
             <div className="relative">

simple_module_settings-0.0.32/tests/test_module_settings_render.py

@@ -0,0 +1,90 @@
+"""Settings → Modules must render for a module with a rich settings type.
+
+This screen reflects *every* installed module's pydantic settings, so the value
+types are open-ended — but none of the modules in this repo declare anything
+the stdlib JSON encoder can't handle, which is why the failure only ever showed
+up downstream. A wheel-installed module with ``media_root: Path`` was enough to
+500 the page, and only on a client-side visit: the HTML render path has its own
+encoder, so reloading the same URL worked and the report read as "sometimes".
+
+The demo module below exists to keep a non-JSON-native settings type in the
+suite permanently.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+import pytest
+from fastapi import FastAPI
+from pydantic_settings import BaseSettings
+from simple_module_core.module import ModuleMeta
+
+_OK = 200
+_SERVER_ERROR = 500
+_INERTIA = {"X-Inertia": "true", "X-Inertia-Version": "1.0"}
+
+
+class _PathCfg(BaseSettings):
+    """Mirrors the shape that broke it: a Path with a relative default."""
+
+    media_root: Path = Path("var/demo/media")
+    workers: int = 2
+
+
+class _PathModule:
+    meta = ModuleMeta(name="PathDemo")
+
+
+_PathModule.__module__ = "pathdemo"
+
+
+@dataclass
+class _PathServices:
+    settings: _PathCfg
+
+
+@pytest.fixture
+def app_with_path_setting(app: FastAPI) -> FastAPI:
+    """Register the demo module against the live app the client talks to."""
+    app.state.settings.module_registry.register("pathdemo", _PathCfg)
+    app.state.pathdemo = _PathServices(settings=_PathCfg())
+    return app
+
+
+class TestModulesScreenRenders:
+    async def test_client_side_visit_does_not_500(
+        self,
+        app_with_path_setting: FastAPI,
+        authenticated_client: httpx.AsyncClient,
+    ) -> None:
+        """The reported bug: reaching the page by clicking the sidebar link."""
+        resp = await authenticated_client.get("/settings/", headers=_INERTIA)
+
+        assert resp.status_code != _SERVER_ERROR
+        assert resp.status_code == _OK
+
+    async def test_the_path_survives_as_a_string(
+        self,
+        app_with_path_setting: FastAPI,
+        authenticated_client: httpx.AsyncClient,
+    ) -> None:
+        resp = await authenticated_client.get("/settings/", headers=_INERTIA)
+        modules = resp.json()["props"]["modules"]
+
+        demo = next(m for m in modules if m["package"] == "pathdemo")
+        media_root = next(f for f in demo["fields"] if f["name"] == "media_root")
+        assert media_root["value"] == "var/demo/media"
+
+    async def test_full_page_load_still_works(
+        self,
+        app_with_path_setting: FastAPI,
+        authenticated_client: httpx.AsyncClient,
+    ) -> None:
+        """The path that always worked must keep working."""
+        resp = await authenticated_client.get("/settings/")
+
+        assert resp.status_code == _OK
+        assert resp.headers["content-type"].startswith("text/html")

simple_module_settings-0.0.32/tests/test_module_settings_serialize.py

@@ -0,0 +1,92 @@
+"""Serialized module settings must be props, not live Python objects.
+
+Settings → Modules reflects every installed module's pydantic settings, so the
+value types are whatever those modules declared — pydantic has already turned
+``media_root: Path`` into a ``PosixPath`` before this screen sees it. Passing
+one on untouched puts a value in the Inertia payload that only the HTML render
+path can encode, so the page renders on a reload and 500s when an admin clicks
+"Settings" in the sidebar.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+import pytest
+from settings._module_settings import (
+    ModuleSettingField,
+    ModuleSettingsView,
+    serialize,
+)
+
+
+def _view_with(value: Any, default: Any = "") -> ModuleSettingsView:
+    return ModuleSettingsView(
+        module_name="Demo",
+        package="demo",
+        env_prefix="SM_DEMO_",
+        class_name="DemoCfg",
+        fields=[
+            ModuleSettingField(
+                name="media_root",
+                env_var="SM_DEMO_MEDIA_ROOT",
+                value=value,
+                default=default,
+                description="",
+                is_secret=False,
+                type="Path",
+                requires_restart=False,
+                group=None,
+            )
+        ],
+    )
+
+
+def _only_field(views: list[dict]) -> dict:
+    return views[0]["fields"][0]
+
+
+class TestSerializeProducesJsonSafeProps:
+    def test_a_path_value_becomes_a_string(self) -> None:
+        result = serialize([_view_with(Path("var/pagebuilder/media"))])
+
+        assert _only_field(result)["value"] == "var/pagebuilder/media"
+
+    def test_a_path_default_becomes_a_string(self) -> None:
+        """Defaults reach the payload too — the screen shows both."""
+        result = serialize([_view_with("", default=Path("var/media"))])
+
+        assert _only_field(result)["default"] == "var/media"
+
+    @pytest.mark.parametrize(
+        "value",
+        [Path("var/media"), Decimal("1.5"), date(2026, 8, 21)],
+        ids=["path", "decimal", "date"],
+    )
+    def test_the_payload_survives_a_plain_json_dump(self, value: Any) -> None:
+        """The check that matters: Starlette's JSONResponse has no encoder.
+
+        Asserting on ``json.dumps`` rather than on each converted type keeps
+        this honest for value types no one has thought of yet.
+        """
+        result = serialize([_view_with(value)])
+
+        assert json.dumps(result)
+
+    def test_ordinary_values_are_unchanged(self) -> None:
+        result = serialize([_view_with(8000, default=25)])
+        field = _only_field(result)
+
+        assert field["value"] == 8000
+        assert field["default"] == 25
+
+    def test_the_rest_of_the_view_is_intact(self) -> None:
+        result = serialize([_view_with(Path("x"))])
+
+        assert result[0]["package"] == "demo"
+        assert _only_field(result)["env_var"] == "SM_DEMO_MEDIA_ROOT"
+        assert _only_field(result)["source"] == "default"