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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_settings
-Version: 0.0.38
+Version: 0.0.40
 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,10 +21,10 @@ 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.38
-Requires-Dist: simple-module-db==0.0.38
-Requires-Dist: simple-module-hosting==0.0.38
-Requires-Dist: typer>=0.12
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-hosting==0.0.40
+Requires-Dist: typer<0.28,>=0.12
 Description-Content-Type: text/markdown
 
 # simple_module_settings

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simple-module-py/settings",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "private": true,
   "description": "Frontend assets for the Settings module",
   "peerDependencies": {

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

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

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/_listing.py

@@ -6,6 +6,7 @@ from simple_module_db import LIKE_ESCAPE_CHAR, like_contains_pattern
 from simple_module_db.stored_settings import SYSTEM_SCOPE_ID, Setting
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import col
 
 from settings._row_masking import out
 from settings.constants import ALL_SCOPES, DEFAULT_PER_PAGE, SCOPE_ALL
@@ -111,6 +112,6 @@ class SettingListing:
     def _scope_stmt(scope: SettingScope, scope_id: str):
         return (
             select(Setting)
-            .where(Setting.scope == scope.value, Setting.scope_id == scope_id)  # ty: ignore[invalid-argument-type]
+            .where(col(Setting.scope) == scope.value, col(Setting.scope_id) == scope_id)
             .order_by(Setting.key)
         )

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/_managed_keys.py

@@ -25,11 +25,12 @@ from collections.abc import Awaitable, Callable
 from settings.constants import ERR_MANAGED_KEY_DELETE
 from settings.contracts.registry import SettingsRegistry, clear_route
 from settings.contracts.schemas import SettingScope
+from settings.exceptions import SettingsError
 
 TenantIsLive = Callable[[str], Awaitable[bool]]
 
 
-class ManagedKeyError(Exception):
+class ManagedKeyError(SettingsError):
     """The key is cleared through ``clear_via``, not by deleting its row."""
 
     def __init__(self, key: str, clear_via: str) -> None:

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/_unique_write.py

@@ -12,8 +12,10 @@ from simple_module_db.stored_settings import Setting
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from settings.exceptions import SettingsError
 
-class DuplicateSettingError(Exception):
+
+class DuplicateSettingError(SettingsError):
     """A row with this (scope, scope_id, key) already exists."""
 
 

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/deps.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 from typing import Annotated
 
 from fastapi import Depends, Request
+from simple_module_core.app_state import get_services
 from simple_module_db.deps import get_db
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -25,7 +26,7 @@ async def get_setting_service(
     request: Request,
     db: AsyncSession = Depends(get_db),
 ) -> SettingService:
-    bus = getattr(getattr(request.app.state, "sm", None), "invalidation", None)
+    bus = getattr(get_services(request.app), "invalidation", None)
 
     async def tenant_is_live(tenant_id: str) -> bool:
         return await is_known_tenant(request, tenant_id)

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/endpoints/module_api.py

@@ -12,7 +12,6 @@ from typing import Any
 from fastapi import APIRouter, Depends, FastAPI, HTTPException, Request, Response, status
 from pydantic import ValidationError
 from simple_module_core.module_settings import module_settings_registry
-from simple_module_core.settings_hydrate import hydrate_settings
 from simple_module_hosting.i18n_deps import TranslatorDep
 from simple_module_hosting.permissions import RequiresPermission
 
@@ -23,8 +22,8 @@ from settings._module_settings import (
 )
 from settings._module_settings_props import serialize
 from settings.constants import PERM_DELETE, PERM_EDIT, PERM_VIEW
-from settings.contracts.events import SettingsReloaded
 from settings.deps import get_setting_service
+from settings.invalidation import reload_on_commit
 from settings.reload import EnvPinnedError, apply_changes_and_reload
 from settings.service import SettingService
 from settings.store import SettingsStore
@@ -162,11 +161,6 @@ async def clear_module_field(
     store = SettingsStore(service)
     await store.clear_override(package, field)
 
-    hydrated = await hydrate_settings(cls, store, package)
-    services = getattr(request.app.state, package)
-    services.settings = hydrated
-
-    bus = request.app.state.sm.event_bus
-    await bus.publish(SettingsReloaded(package=package, changed=(field,)))
+    reload_on_commit(request.app, request.app.state.sm.event_bus, store, package)
 
     return Response(status_code=status.HTTP_204_NO_CONTENT)

simple_module_settings-0.0.40/settings/exceptions.py

@@ -0,0 +1,5 @@
+"""Transport-independent settings business failures."""
+
+
+class SettingsError(Exception):
+    """Base for errors raised by settings services."""

simple_module_settings-0.0.40/settings/invalidation.py

@@ -0,0 +1,70 @@
+"""Rehydrate module settings and notify local consumers only after durable writes."""
+
+import logging
+
+from fastapi import FastAPI
+from simple_module_core.app_state import get_services
+from simple_module_core.events import EventBus
+from simple_module_core.invalidation import InvalidationBus
+from simple_module_core.invalidation_refresh import InvalidationRefresh
+from simple_module_core.module_settings import module_settings_registry
+from simple_module_core.settings_hydrate import hydrate_settings
+from simple_module_db.stored_settings import settings_table_exists
+
+from settings.contracts.events import SettingsReloaded
+from settings.store import SettingsStore
+
+CHANNEL = "settings.modules"
+logger = logging.getLogger(__name__)
+
+
+async def reload_package(app: FastAPI, bus: EventBus, store: SettingsStore, package: str) -> None:
+    cls = module_settings_registry(app).get(package)
+    if cls is None:
+        return
+    services = getattr(app.state, package, None)
+    if services is None:
+        return
+    hydrated = await hydrate_settings(cls, store, package, lenient=True)
+    changed = tuple(
+        sorted(
+            name
+            for name in cls.model_fields
+            if getattr(services.settings, name) != getattr(hydrated, name)
+        )
+    )
+    services.settings = hydrated
+    if changed:
+        await bus.publish(SettingsReloaded(package=package, changed=changed))
+
+
+def reload_on_commit(app: FastAPI, bus: EventBus, store: SettingsStore, package: str) -> None:
+    async def committed() -> None:
+        invalidation = getattr(get_services(app), "invalidation", None)
+        if invalidation is None:
+            await reload_package(app, bus, store, package)
+        else:
+            await invalidation.publish(CHANNEL, key=package)
+
+    store.on_commit(committed)
+
+
+def subscribe(bus: InvalidationBus, app: FastAPI) -> InvalidationRefresh:
+    from settings.service import SettingService
+
+    async def reload(key: str | None) -> None:
+        async with app.state.sm.db.session_factory() as db:
+            if not await settings_table_exists(db):  # fresh install, before migrations
+                return
+            store = SettingsStore(SettingService(db))
+            packages = [key] if key is not None else module_settings_registry(app).all_packages()
+            for package in packages:
+                # One package's failed read or invalid cross-field rule must not
+                # starve the packages after it on every later cycle.
+                try:
+                    await reload_package(app, app.state.sm.event_bus, store, package)
+                except Exception:
+                    logger.exception("Reloading %s settings failed; keeping current ones", package)
+                    await db.rollback()
+
+    return InvalidationRefresh(bus, CHANNEL, reload)

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/module.py

@@ -29,6 +29,7 @@ from settings.constants import (
 )
 
 if TYPE_CHECKING:
+    from simple_module_core.invalidation import InvalidationBus
     from sqlalchemy.ext.asyncio import AsyncSession
 
 
@@ -79,6 +80,19 @@ class SettingsModule(ModuleBase):
         # Self-register so the UI lists our own settings alongside other modules.
         services.module_registry.register(MODULE_PACKAGE, SettingsSettings)
 
+    def register_invalidations(self, bus: InvalidationBus, app: FastAPI) -> None:
+        from settings.invalidation import subscribe
+
+        self._refresh = subscribe(bus, app)
+
+    async def on_startup(self, app: FastAPI) -> None:
+        if hasattr(self, "_refresh"):
+            self._refresh.start()
+
+    async def on_shutdown(self, app: FastAPI) -> None:
+        if hasattr(self, "_refresh"):
+            await self._refresh.stop()
+
     def register_exception_handlers(self, app: FastAPI) -> None:
         from settings.errors import install_exception_handlers
 

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/pages/ModulesEdit.tsx

@@ -142,7 +142,11 @@ function ModulesEdit({ modules, testable = {} }: Props) {
               </div>
             </Card>
           ) : current ? (
-            <ModuleForm module={current} checks={testable[current.package] ?? []} />
+            <ModuleForm
+              key={current.package}
+              module={current}
+              checks={testable[current.package] ?? []}
+            />
           ) : (
             <p className="text-muted-foreground">{t(keys.settings.modules.empty_title)}</p>
           )}

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/pages/components/ModuleForm.tsx

@@ -42,18 +42,23 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
     return o;
   }, [m.fields]);
 
-  const [values, setValues] = useState<Record<string, unknown>>(initial);
-  const [baseline, setBaseline] = useState<Record<string, unknown>>(initial);
+  const [{ values, baseline }, setBuffer] = useState({ values: initial, baseline: initial });
   const [errors, setErrors] = useState<Record<string, string>>({});
   const [busy, setBusy] = useState(false);
   const [saved, setSaved] = useState(false);
   const [formErrors, setFormErrors] = useState<string[]>([]);
 
-  // Reset the edit buffer whenever the underlying module changes (package
-  // switch, or server-reloaded props after a save/reset).
+  // Refresh saved values without discarding drafts in other fields (#637).
   useEffect(() => {
-    setValues(initial);
-    setBaseline(initial);
+    setBuffer((prev) => ({
+      values: Object.fromEntries(
+        Object.entries(initial).map(([name, value]) => [
+          name,
+          notEqual(prev.values[name], prev.baseline[name]) ? prev.values[name] : value,
+        ]),
+      ),
+      baseline: initial,
+    }));
     setErrors({});
     setSaved(false);
   }, [initial]);
@@ -107,7 +112,7 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
     } else {
       // Keeping the form mounted lets the confirmation remain visible instead
       // of being discarded by an immediate Inertia reload.
-      setBaseline({ ...values });
+      setBuffer((prev) => ({ ...prev, baseline: { ...values } }));
       setSaved(true);
     }
     setBusy(false);
@@ -121,6 +126,10 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
         params: { path: { package: m.package, field: name } },
       }),
     );
+    setBuffer((prev) => ({
+      ...prev,
+      values: { ...prev.values, [name]: prev.baseline[name] },
+    }));
     router.reload({ only: ['modules'] });
   }
 
@@ -187,7 +196,10 @@ export function ModuleForm({ module: m, checks = [] }: Props) {
                   onReset={() => onReset(f.name)}
                   onChange={(name, v) => {
                     setSaved(false);
-                    setValues((prev) => ({ ...prev, [name]: v }));
+                    setBuffer((prev) => ({
+                      ...prev,
+                      values: { ...prev.values, [name]: v },
+                    }));
                   }}
                 />
               ))}

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/pages/components/TestConnectionButton.tsx

@@ -3,7 +3,7 @@ import { Button } from '@simple-module-py/ui/components/ui/button';
 import { useRelativeTime } from '@simple-module-py/ui/hooks/use-relative-time';
 import { apiFetch } from '@simple-module-py/ui/lib/api';
 import { CheckCircle2, PlugZap, XCircle } from 'lucide-react';
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { ROUTES } from '../routes';
 import { type LastTest, readLastTest, writeLastTest } from './last-test';
 
@@ -35,9 +35,19 @@ export function TestConnectionButton({ pkg, checks }: Props) {
   const [error, setError] = useState<string | null>(null);
   const [last, setLast] = useState<LastTest | null>(null);
 
+  const requestId = useRef(0);
+
   // Read on mount rather than during render: the result is per-tab session
   // state, and touching sessionStorage while rendering breaks SSR hydration.
-  useEffect(() => setLast(readLastTest(pkg)), [pkg]);
+  useEffect(() => {
+    setLast(readLastTest(pkg));
+    setResults(null);
+    setError(null);
+    setBusy(false);
+    return () => {
+      requestId.current++;
+    };
+  }, [pkg]);
 
   // "users.mailer" → "mailer". Naming the check is the difference between
   // "Test connection" and knowing an SMTP dial is about to happen; with two
@@ -50,6 +60,7 @@ export function TestConnectionButton({ pkg, checks }: Props) {
       : t(keys.settings.modules.test_connection_generic);
 
   async function run() {
+    const id = ++requestId.current;
     setBusy(true);
     setError(null);
     setResults(null);
@@ -57,8 +68,9 @@ export function TestConnectionButton({ pkg, checks }: Props) {
     const result = await apiFetch<{ checks?: CheckResult[] }>(ROUTES.testConnection(pkg), {
       method: 'POST',
     });
-    if (result.ok) {
-      const checkResults = result.data?.checks ?? [];
+    if (id !== requestId.current) return;
+    const checkResults = result.data?.checks;
+    if (result.ok && Array.isArray(checkResults) && checkResults.length > 0) {
       setResults(checkResults);
       setLast(
         writeLastTest(

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/reload.py

@@ -11,9 +11,13 @@ from pydantic_core import to_jsonable_python
 from pydantic_settings import BaseSettings
 from simple_module_core.events import EventBus
 from simple_module_core.module_settings import module_settings_registry
-from simple_module_core.settings_hydrate import env_supplied_fields, value_type_for_field
+from simple_module_core.settings_hydrate import (
+    env_supplied_fields,
+    hydrate_settings,
+    value_type_for_field,
+)
 
-from settings.contracts.events import SettingsReloaded
+from settings.invalidation import reload_on_commit
 from settings.store import SettingsStore
 
 
@@ -87,7 +91,7 @@ async def apply_changes_and_reload(
     package: str,
     changes: dict[str, Any],
 ) -> BaseSettings:
-    """Validate, persist, hot-swap, and publish ``SettingsReloaded``."""
+    """Validate and persist; reload and publish ``SettingsReloaded`` after commit."""
     registry = module_settings_registry(app)
     cls = registry.get(package)
     if cls is None:
@@ -97,8 +101,8 @@ async def apply_changes_and_reload(
     if unknown:
         raise KeyError(f"Unknown field(s) for {package!r}: {sorted(unknown)}")
 
-    services = getattr(app.state, package)
-    current = services.settings
+    # Include prior writes in this transaction without exposing them to other requests.
+    current = await hydrate_settings(cls, store, package, lenient=True)
     # Compare against the *dumped* current value, not the attribute: a field
     # typed as a list of models (branding's ``footer_links``) holds model
     # instances, while ``changes`` carries the plain dicts a DTO dumps to. The
@@ -118,6 +122,7 @@ async def apply_changes_and_reload(
                 await store.clear_override(package, name)
 
     if not diff:
+        reload_on_commit(app, bus, store, package)
         return current
 
     # Only a field that would actually change is refused: a client that echoes
@@ -153,6 +158,5 @@ async def apply_changes_and_reload(
         except ValidationError as exc:
             raise _relocate(exc, field_name) from exc
 
-    services.settings = validated
-    await bus.publish(SettingsReloaded(package=package, changed=tuple(sorted(diff))))
+    reload_on_commit(app, bus, store, package)
     return validated

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/service.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 from simple_module_db.stored_settings import SYSTEM_SCOPE_ID, VALUE_TYPE_STRING, Setting
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import col
 
 from settings._announce import announce
 from settings._listing import SettingListing
@@ -204,9 +205,9 @@ class SettingService(SettingListing):
 
     async def _find(self, scope: SettingScope, scope_id: str, key: str) -> Setting | None:
         stmt = select(Setting).where(
-            Setting.scope == scope.value,  # ty: ignore[invalid-argument-type]
-            Setting.scope_id == scope_id,  # ty: ignore[invalid-argument-type]
-            Setting.key == key,  # ty: ignore[invalid-argument-type]
+            col(Setting.scope) == scope.value,
+            col(Setting.scope_id) == scope_id,
+            col(Setting.key) == key,
         )
         result = await self.db.execute(stmt)
         return result.scalar_one_or_none()

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/settings/store.py

@@ -18,6 +18,7 @@ see ``_module_settings._field_view``.
 
 from __future__ import annotations
 
+from simple_module_db.callbacks import OnCommitCallback
 from simple_module_db.stored_settings import (  # noqa: F401  (re-exported, #500)
     SYSTEM_SCOPE_ID,
     get_overrides_sync,
@@ -41,6 +42,9 @@ class SettingsStore:
     def __init__(self, service: SettingService) -> None:
         self._service = service
 
+    def on_commit(self, callback: OnCommitCallback) -> None:
+        self._service.db.on_commit(callback)
+
     async def get_overrides(self, package: str) -> dict[str, tuple[str, str]]:
         """Return ``{field_name: (raw_value, value_type)}`` for a package."""
         items = await self._service.list_by_scope_unmasked(SettingScope.SYSTEM, SYSTEM_SCOPE_ID)

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/tests/test_reload.py

@@ -14,6 +14,7 @@ from settings.settings import SettingsSettings
 from settings.store import SettingsStore
 from simple_module_core.events import EventBus
 from simple_module_core.module_settings import register_module_settings
+from simple_module_db.transaction import finalize_session
 
 
 class _UsersCfg(BaseSettings):
@@ -56,7 +57,10 @@ async def test_apply_changes_updates_app_state_and_fires_event(app_and_bus, db_s
 
     assert new_settings.allow_signup is True
     assert new_settings.smtp_port == 587
-    assert app.state.users.settings is new_settings
+    assert app.state.users.settings.allow_signup is False
+    assert received == []
+    await finalize_session(db_session)
+    assert app.state.users.settings == new_settings
     assert received == [SettingsReloaded(package="users", changed=("allow_signup", "smtp_port"))]
 
     persisted = await store.get_overrides("users")
@@ -96,3 +100,15 @@ async def test_apply_changes_unknown_package_raises(app_and_bus, db_session):
             package="unknown",
             changes={"x": 1},
         )
+
+
+async def test_multiple_settings_edits_in_one_transaction_keep_both(app_and_bus, db_session):
+    app, bus = app_and_bus
+    store = SettingsStore(SettingService(db_session))
+    await apply_changes_and_reload(app, bus, store, package="users", changes={"allow_signup": True})
+    await apply_changes_and_reload(app, bus, store, package="users", changes={"smtp_port": 587})
+    assert app.state.users.settings.allow_signup is False
+    assert app.state.users.settings.smtp_port == 25
+    await finalize_session(db_session)
+    assert app.state.users.settings.allow_signup is True
+    assert app.state.users.settings.smtp_port == 587

simple_module_settings-0.0.40/tests/test_settings_commit_invalidation.py

@@ -0,0 +1,99 @@
+"""Module settings and reload events only reflect committed state."""
+
+import pytest
+from settings.contracts.events import SettingsReloaded
+from settings.reload import apply_changes_and_reload
+from settings.service import SettingService
+from settings.store import SettingsStore
+from simple_module_core.invalidation import Invalidation
+from simple_module_db.transaction import finalize_session, rollback_session
+
+
+@pytest.mark.parametrize("commit", [False, True])
+async def test_settings_and_events_wait_for_commit(app, commit):
+    received = []
+    bus = app.state.sm.event_bus
+
+    async def record(event):
+        received.append(event)
+
+    bus.subscribe(SettingsReloaded, record)
+    original = app.state.users.settings
+    wanted = not original.allow_signup
+    async with app.state.sm.db.session_factory() as db:
+        await apply_changes_and_reload(
+            app,
+            bus,
+            SettingsStore(SettingService(db)),
+            package="users",
+            changes={"allow_signup": wanted},
+        )
+        assert app.state.users.settings is original
+        assert received == []
+        if commit:
+            await finalize_session(db)
+        else:
+            await rollback_session(db)
+    assert app.state.users.settings.allow_signup is (wanted if commit else original.allow_signup)
+    assert len(received) == int(commit)
+    if commit:
+        assert received[0].changed == ("allow_signup",)
+
+
+async def test_remote_settings_changes_and_clears_reload_and_emit_event(app):
+    received = []
+
+    async def record(event):
+        received.append(event)
+
+    app.state.sm.event_bus.subscribe(SettingsReloaded, record)
+    original = app.state.users.settings.allow_signup
+    factory = app.state.sm.db.session_factory
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).set_override(
+            "users", "allow_signup", str(not original), "bool"
+        )
+        await db.commit()
+    message = Invalidation(channel="settings.modules", key="users", origin="other")
+    await app.state.sm.invalidation.deliver(message.to_wire())
+    assert app.state.users.settings.allow_signup is not original
+    assert received[-1].changed == ("allow_signup",)
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).clear_override("users", "allow_signup")
+        await db.commit()
+    await app.state.sm.invalidation.deliver(message.to_wire())
+    assert app.state.users.settings.allow_signup is original
+    assert len(received) == 2
+
+
+@pytest.mark.parametrize("commit", [False, True])
+async def test_clearing_module_setting_waits_for_commit(app, commit):
+    from settings.endpoints.module_api import clear_module_field
+    from starlette.requests import Request
+
+    original = app.state.users.settings.allow_signup
+    factory = app.state.sm.db.session_factory
+    async with factory() as db:
+        await SettingsStore(SettingService(db)).set_override(
+            "users", "allow_signup", str(not original), "bool"
+        )
+        await db.commit()
+    await app.state.sm.invalidation.publish("settings.modules", key="users")
+    received = []
+
+    async def record(event):
+        received.append(event)
+
+    app.state.sm.event_bus.subscribe(SettingsReloaded, record)
+    async with factory() as db:
+        await clear_module_field(
+            "users", "allow_signup", Request({"type": "http", "app": app}), SettingService(db)
+        )
+        assert app.state.users.settings.allow_signup is not original
+        assert received == []
+        if commit:
+            await finalize_session(db)
+        else:
+            await rollback_session(db)
+    assert app.state.users.settings.allow_signup is (original if commit else not original)
+    assert len(received) == int(commit)

simple_module_settings-0.0.40/tests/test_settings_domain_errors.py

@@ -0,0 +1,10 @@
+"""Settings business failures share a transport-independent base."""
+
+
+def test_settings_errors_share_a_module_base():
+    from settings._managed_keys import ManagedKeyError
+    from settings._unique_write import DuplicateSettingError
+    from settings.exceptions import SettingsError
+
+    assert isinstance(ManagedKeyError("key", "/clear"), SettingsError)
+    assert isinstance(DuplicateSettingError("key"), SettingsError)

{simple_module_settings-0.0.38 → simple_module_settings-0.0.40}/tests/test_settings_secret_json_roundtrip.py

@@ -25,6 +25,13 @@ class _SecretCfg(BaseSettings):
 class _Store:
     def __init__(self) -> None:
         self.rows: dict[str, tuple[str, str]] = {}
+        self.callbacks = []
+
+    def on_commit(self, callback) -> None:
+        self.callbacks.append(callback)
+
+    async def get_overrides(self, package):
+        return dict(self.rows)
 
     async def set_override(self, package, field, raw, value_type) -> None:
         self.rows[field] = (raw, value_type)