simple-module-feature-flags 0.0.38__tar.gz → 0.0.40__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_feature_flags
-Version: 0.0.38
+Version: 0.0.40
 Summary: Simple feature-flag module with per-tenant overrides and a consumer API for simple_module
 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.38
-Requires-Dist: simple-module-db==0.0.38
-Requires-Dist: simple-module-hosting==0.0.38
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-hosting==0.0.40
 Description-Content-Type: text/markdown
 
 # simple_module_feature_flags

{simple_module_feature_flags-0.0.38 → simple_module_feature_flags-0.0.40}/feature_flags/deps.py

@@ -14,9 +14,10 @@ from feature_flags.service import FeatureFlagService
 
 
 async def get_feature_flag_service(
+    request: Request,
     db: AsyncSession = Depends(get_db),
 ) -> FeatureFlagService:
-    return FeatureFlagService(db)
+    return FeatureFlagService(db, app=request.app)
 
 
 async def get_feature_flag_registry(request: Request) -> FeatureFlagRegistry:

{simple_module_feature_flags-0.0.38 → simple_module_feature_flags-0.0.40}/feature_flags/endpoints/api.py

@@ -70,6 +70,8 @@ async def set_override(
     await service.set_override(name, body.enabled, registry=registry)
     view = service.build_view(registry, name)
     assert view is not None  # _ensure_registered already proved it exists
+    view.enabled = body.enabled
+    view.overridden = True
     return view
 
 
@@ -125,6 +127,8 @@ async def set_tenant_override(
     )
     view = service.build_view(registry, name, tenant_id=tenant_id)
     assert view is not None  # _ensure_registered already proved it exists
+    view.enabled = body.enabled
+    view.overridden = True
     return view
 
 

simple_module_feature_flags-0.0.40/feature_flags/invalidation.py

@@ -0,0 +1,17 @@
+"""Re-read flag overrides after commit or a remote invalidation."""
+
+from fastapi import FastAPI
+from simple_module_core.invalidation import InvalidationBus
+from simple_module_core.invalidation_refresh import InvalidationRefresh
+
+from feature_flags.service import FeatureFlagService
+
+CHANNEL = "feature_flags.overrides"
+
+
+def subscribe(bus: InvalidationBus, app: FastAPI) -> InvalidationRefresh:
+    async def reload(_key: str | None) -> None:
+        async with app.state.sm.db.session_factory() as db:
+            await FeatureFlagService(db).hydrate_registry(app.state.sm.feature_flags)
+
+    return InvalidationRefresh(bus, CHANNEL, reload)

{simple_module_feature_flags-0.0.38 → simple_module_feature_flags-0.0.40}/feature_flags/module.py

@@ -29,6 +29,8 @@ from feature_flags.constants import (
 )
 
 if TYPE_CHECKING:
+    from simple_module_core.events import EventBus
+    from simple_module_core.invalidation import InvalidationBus
     from sqlalchemy.ext.asyncio import AsyncSession
 
 _logger = logging.getLogger(__name__)
@@ -67,6 +69,18 @@ class FeatureFlagsModule(ModuleBase):
         i18n_audience="admin",
     )
 
+    def register_event_handlers(self, bus: EventBus, app: FastAPI | None = None) -> None:
+        from simple_module_core.tenant_events import TenantDeleted
+
+        from feature_flags.tenant_cleanup import purge_tenant_data
+
+        bus.subscribe_durable(TenantDeleted, purge_tenant_data)
+
+    def register_invalidations(self, bus: InvalidationBus, app: FastAPI) -> None:
+        from feature_flags.invalidation import subscribe
+
+        self._refresh = subscribe(bus, app)
+
     def register_routes(self, api_router: APIRouter, view_router: APIRouter) -> None:
         from feature_flags.endpoints.api import router as api
         from feature_flags.endpoints.views import router as views
@@ -149,3 +163,10 @@ class FeatureFlagsModule(ModuleBase):
                 await service.hydrate_registry(sm.feature_flags)
         except Exception:
             _logger.exception("feature_flags.hydrate_failed — continuing with registry defaults")
+
+        if hasattr(self, "_refresh"):
+            self._refresh.start()
+
+    async def on_shutdown(self, app: FastAPI) -> None:
+        if hasattr(self, "_refresh"):
+            await self._refresh.stop()

{simple_module_feature_flags-0.0.38 → simple_module_feature_flags-0.0.40}/feature_flags/service.py

@@ -9,9 +9,11 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
+from fastapi import FastAPI
 from simple_module_core.feature_flags import FeatureFlagDefinition, FeatureFlagRegistry
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import col
 
 from feature_flags.constants import SCOPE_SYSTEM, SCOPE_TENANT, SYSTEM_SCOPE_ID
 from feature_flags.contracts.schemas import FeatureFlagOverrideOut, FeatureFlagView
@@ -59,8 +61,9 @@ class FeatureFlagService:
     extra DB hit per request.
     """
 
-    def __init__(self, db: AsyncSession) -> None:
+    def __init__(self, db: AsyncSession, app: FastAPI | None = None) -> None:
         self.db = db
+        self.app = app
 
     async def list_overrides(self) -> list[FeatureFlagOverrideOut]:
         """Every persisted override across all scopes, ordered for stable display."""
@@ -151,9 +154,9 @@ class FeatureFlagService:
     async def _find(self, scope: str, scope_id: str, name: str) -> FeatureFlagOverride | None:
         result = await self.db.execute(
             select(FeatureFlagOverride).where(
-                FeatureFlagOverride.scope == scope,  # ty: ignore[invalid-argument-type]
-                FeatureFlagOverride.scope_id == scope_id,  # ty: ignore[invalid-argument-type]
-                FeatureFlagOverride.name == name,  # ty: ignore[invalid-argument-type]
+                col(FeatureFlagOverride.scope) == scope,
+                col(FeatureFlagOverride.scope_id) == scope_id,
+                col(FeatureFlagOverride.name) == name,
             )
         )
         return result.scalar_one_or_none()
@@ -178,7 +181,7 @@ class FeatureFlagService:
             existing.enabled = enabled
             await self.db.flush()
         if registry is not None:
-            registry.set_override(name, enabled, tenant_id=_registry_tenant_id(scope, scope_id))
+            self._on_commit(registry, name, enabled, scope, scope_id)
         return FeatureFlagOverrideOut.model_validate(existing)
 
     async def clear_override(
@@ -194,16 +197,34 @@ class FeatureFlagService:
             return False
         await self.db.delete(existing)
         if registry is not None:
-            registry.clear_override(name, tenant_id=_registry_tenant_id(scope, scope_id))
+            self._on_commit(registry, name, None, scope, scope_id)
         return True
 
     async def hydrate_registry(self, registry: FeatureFlagRegistry) -> int:
         """Load every persisted override (system + tenant) into the registry at boot."""
         overrides = await self.list_overrides()
-        for ovr in overrides:
-            registry.set_override(
-                ovr.name,
-                ovr.enabled,
-                tenant_id=_registry_tenant_id(ovr.scope, ovr.scope_id),
-            )
+        registry.replace_overrides(
+            {o.name: o.enabled for o in overrides if o.scope == SCOPE_SYSTEM},
+            {(o.name, o.scope_id): o.enabled for o in overrides if o.scope == SCOPE_TENANT},
+        )
         return len(overrides)
+
+    def _on_commit(
+        self,
+        registry: FeatureFlagRegistry,
+        name: str,
+        enabled: bool | None,
+        scope: str,
+        scope_id: str,
+    ) -> None:
+        async def committed() -> None:
+            if self.app is not None:
+                from feature_flags.invalidation import CHANNEL
+
+                await self.app.state.sm.invalidation.publish(CHANNEL, key=name)
+            elif enabled is None:
+                registry.clear_override(name, tenant_id=_registry_tenant_id(scope, scope_id))
+            else:
+                registry.set_override(name, enabled, tenant_id=_registry_tenant_id(scope, scope_id))
+
+        self.db.on_commit(committed)

simple_module_feature_flags-0.0.40/feature_flags/tenant_cleanup.py

@@ -0,0 +1,18 @@
+"""Durable cleanup of tenant-scoped feature flag overrides."""
+
+from simple_module_core.durable_events import DurableContext
+from simple_module_core.tenant_events import TenantDeleted
+from sqlmodel import col, delete
+
+from feature_flags.constants import SCOPE_TENANT
+from feature_flags.models import FeatureFlagOverride
+
+
+async def purge_tenant_data(event: TenantDeleted, ctx: DurableContext) -> None:
+    """Keep system/other tenants' overrides; acknowledge with the worker transaction."""
+    await ctx.db.execute(
+        delete(FeatureFlagOverride).where(
+            col(FeatureFlagOverride.scope) == SCOPE_TENANT,
+            col(FeatureFlagOverride.scope_id) == event.tenant_id,
+        )
+    )

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_feature_flags"
-version = "0.0.38"
+version = "0.0.40"
 description = "Simple feature-flag module with per-tenant overrides and a consumer API for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -21,9 +21,9 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.38",
-    "simple_module_db==0.0.38",
-    "simple_module_hosting==0.0.38",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_hosting==0.0.40",
 ]
 
 [project.entry-points.simple_module]

simple_module_feature_flags-0.0.40/tests/test_feature_flags_commit_invalidation.py

@@ -0,0 +1,78 @@
+"""Flag changes must survive commit before reaching any worker's registry."""
+
+import pytest
+from feature_flags.models import FeatureFlagOverride
+from feature_flags.service import FeatureFlagService
+from simple_module_core.feature_flags import FeatureFlagDefinition, FeatureFlagRegistry
+from simple_module_core.invalidation import Invalidation
+from simple_module_db.transaction import finalize_session, rollback_session
+
+
+@pytest.mark.parametrize("commit", [False, True])
+@pytest.mark.parametrize("scope,scope_id", [("system", ""), ("tenant", "acme")])
+@pytest.mark.parametrize("clear", [False, True])
+async def test_flag_mutation_waits_for_commit(db_session, commit, scope, scope_id, clear):
+    registry = FeatureFlagRegistry()
+    registry.add(FeatureFlagDefinition("switch"))
+    tenant_id = scope_id or None
+    if clear:
+        db_session.add(
+            FeatureFlagOverride(scope=scope, scope_id=scope_id, name="switch", enabled=True)
+        )
+        await db_session.commit()
+        registry.set_override("switch", True, tenant_id=tenant_id)
+    service = FeatureFlagService(db_session)
+    if clear:
+        await service.clear_override("switch", registry, scope, scope_id)
+    else:
+        await service.set_override("switch", True, registry, scope, scope_id)
+    assert registry.is_enabled("switch", tenant_id) is clear
+    if commit:
+        await finalize_session(db_session)
+    else:
+        await rollback_session(db_session)
+    assert registry.is_enabled("switch", tenant_id) is (clear != commit)
+
+
+@pytest.mark.parametrize("scope,scope_id", [("system", ""), ("tenant", "acme")])
+async def test_remote_flag_changes_and_deletions_reload(app, scope, scope_id):
+    registry = app.state.sm.feature_flags
+    registry.add(FeatureFlagDefinition("switch"))
+    factory = app.state.sm.db.session_factory
+    async with factory() as db:
+        row = FeatureFlagOverride(scope=scope, scope_id=scope_id, name="switch", enabled=True)
+        db.add(row)
+        await db.commit()
+        row_id = row.id
+    bus = app.state.sm.invalidation
+    message = Invalidation(channel="feature_flags.overrides", origin="other")
+    await bus.deliver(message.to_wire())
+    assert registry.is_enabled("switch", scope_id or None) is True
+    async with factory() as db:
+        await db.delete(await db.get(FeatureFlagOverride, row_id))
+        await db.commit()
+    await bus.deliver(message.to_wire())
+    assert registry.is_enabled("switch", scope_id or None) is False
+
+
+@pytest.mark.parametrize("commit", [False, True])
+@pytest.mark.parametrize("scope,scope_id", [("system", ""), ("tenant", "acme")])
+async def test_flag_request_publishes_only_after_commit(app, commit, scope, scope_id):
+    from feature_flags.deps import get_feature_flag_service
+    from starlette.requests import Request
+
+    registry = app.state.sm.feature_flags
+    registry.add(FeatureFlagDefinition("switch"))
+    messages = []
+    app.state.sm.invalidation.subscribe("feature_flags.overrides", messages.append)
+    async with app.state.sm.db.session_factory() as db:
+        service = await get_feature_flag_service(Request({"type": "http", "app": app}), db)
+        await service.set_override("switch", True, registry, scope, scope_id)
+        assert registry.is_enabled("switch", scope_id or None) is False
+        assert messages == []
+        if commit:
+            await finalize_session(db)
+        else:
+            await rollback_session(db)
+    assert registry.is_enabled("switch", scope_id or None) is commit
+    assert len(messages) == int(commit)

{simple_module_feature_flags-0.0.38 → simple_module_feature_flags-0.0.40}/tests/test_feature_flags_service.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from feature_flags.constants import SCOPE_TENANT
 from feature_flags.service import FeatureFlagService
 from simple_module_core.feature_flags import FeatureFlagDefinition, FeatureFlagRegistry
+from simple_module_db.transaction import finalize_session
 from sqlalchemy.ext.asyncio import AsyncSession
 
 
@@ -25,6 +26,7 @@ class TestFeatureFlagServiceSystem:
         assert result.name == "beta_ui"
         assert result.scope == "system"
         assert result.enabled is True
+        await finalize_session(db_session)
         assert reg.is_enabled("beta_ui") is True
 
     async def test_set_override_twice_updates_in_place(self, db_session: AsyncSession):
@@ -37,6 +39,7 @@ class TestFeatureFlagServiceSystem:
         rows = await svc.list_overrides()
         assert len(rows) == 1
         assert rows[0].enabled is False
+        await finalize_session(db_session)
         assert reg.is_enabled("beta_ui") is False
 
     async def test_clear_override_removes_row_and_reverts_registry(self, db_session: AsyncSession):
@@ -48,6 +51,7 @@ class TestFeatureFlagServiceSystem:
 
         assert cleared is True
         assert await svc.list_overrides() == []
+        await finalize_session(db_session)
         assert reg.is_enabled("beta_ui") is False  # back to default
 
     async def test_clear_override_unknown_flag_is_noop(self, db_session: AsyncSession):
@@ -62,6 +66,7 @@ class TestFeatureFlagServiceSystem:
         )
         await svc.set_override("a.flag", True, registry=reg)
 
+        await finalize_session(db_session)
         views = await svc.list_flags(reg)
 
         by_name = {v.name: v for v in views}
@@ -82,6 +87,7 @@ class TestFeatureFlagServiceSystem:
         await svc.set_override("legacy", True, registry=reg_old)
 
         reg_new = _registry_with(("current", "", False))
+        await finalize_session(db_session)
         views = await svc.list_flags(reg_new)
 
         assert [v.name for v in views] == ["current"]
@@ -98,6 +104,7 @@ class TestFeatureFlagServiceTenant:
         rows = await svc.list_overrides()
         assert len(rows) == 2
         # tenant row beats system for that tenant
+        await finalize_session(db_session)
         assert reg.is_enabled("beta_ui", tenant_id="acme") is False
         # other tenants fall back to system
         assert reg.is_enabled("beta_ui", tenant_id="other") is True
@@ -115,6 +122,7 @@ class TestFeatureFlagServiceTenant:
         )
 
         assert cleared is True
+        await finalize_session(db_session)
         assert reg.is_enabled("beta_ui", tenant_id="acme") is False
         assert reg.is_enabled("beta_ui", tenant_id="globex") is True
 
@@ -124,6 +132,7 @@ class TestFeatureFlagServiceTenant:
         await svc.set_override("beta_ui", True, registry=reg)  # system on
         await svc.set_override("beta_ui", False, registry=reg, scope=SCOPE_TENANT, scope_id="acme")
 
+        await finalize_session(db_session)
         views = await svc.list_flags(reg, tenant_id="acme")
 
         view = next(v for v in views if v.name == "beta_ui")
@@ -138,6 +147,7 @@ class TestFeatureFlagServiceTenant:
         reg = _registry_with(("beta_ui", "", False))
         await svc.set_override("beta_ui", True, registry=reg)  # system on
 
+        await finalize_session(db_session)
         views = await svc.list_flags(reg, tenant_id="acme")
 
         view = next(v for v in views if v.name == "beta_ui")

simple_module_feature_flags-0.0.40/tests/test_feature_flags_tenant_cleanup.py

@@ -0,0 +1,34 @@
+"""Tenant deletion purges tenant overrides without touching other scopes."""
+
+from feature_flags.constants import SCOPE_SYSTEM, SCOPE_TENANT
+from feature_flags.models import FeatureFlagOverride
+from feature_flags.module import FeatureFlagsModule
+from simple_module_core.durable_events import DurableContext, event_key
+from simple_module_core.events import EventBus
+from simple_module_core.tenant_events import TenantDeleted
+from sqlmodel import select
+
+
+async def test_durable_tenant_cleanup_is_scoped_idempotent_and_transactional(db_session):
+    bus = EventBus()
+    FeatureFlagsModule().register_event_handlers(bus)
+    names = bus.durable.handler_names(TenantDeleted)
+    assert len(names) == 1
+    subscription = bus.durable.lookup(event_key(TenantDeleted), names[0])
+    assert subscription is not None
+    scopes = [(SCOPE_TENANT, "deleted"), (SCOPE_TENANT, "other"), (SCOPE_SYSTEM, "deleted")]
+    for scope, scope_id in scopes:
+        db_session.add(FeatureFlagOverride(scope=scope, scope_id=scope_id, name="test.flag"))
+    await db_session.commit()
+    event = TenantDeleted(tenant_id="deleted", slug="deleted", name="Deleted")
+    ctx = DurableContext(db=db_session, attempt=1)
+    await subscription.handler(event, ctx)
+    await db_session.rollback()
+    assert len((await db_session.execute(select(FeatureFlagOverride))).scalars().all()) == 3
+    await subscription.handler(event, ctx)
+    await subscription.handler(event, DurableContext(db=db_session, attempt=2))
+    rows = (await db_session.execute(select(FeatureFlagOverride))).scalars().all()
+    assert {(row.scope, row.scope_id) for row in rows} == {
+        (SCOPE_TENANT, "other"),
+        (SCOPE_SYSTEM, "deleted"),
+    }