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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_sharing
-Version: 0.0.38
+Version: 0.0.40
 Summary: Generic resource shares (owner / shared-with-user) for simple_module resource-scoped access
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -11,10 +11,10 @@ License-Expression: MIT
 License-File: LICENSE
 Keywords: access-control,permissions,sharing,simple-module
 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-inertia==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
+Requires-Dist: simple-module-inertia==0.0.40
 Description-Content-Type: text/markdown
 
 # simple_module_sharing

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_sharing"
-version = "0.0.38"
+version = "0.0.40"
 description = "Generic resource shares (owner / shared-with-user) for simple_module resource-scoped access"
 readme = "README.md"
 license = "MIT"
@@ -9,10 +9,10 @@ requires-python = ">=3.12"
 authors = [{ name = "Anto Subash", email = "antosubash@live.com" }]
 keywords = ["simple-module", "sharing", "permissions", "access-control"]
 dependencies = [
-    "simple_module_core==0.0.38",
-    "simple_module_db==0.0.38",
-    "simple_module_hosting==0.0.38",
-    "simple_module_inertia==0.0.38",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_hosting==0.0.40",
+    "simple_module_inertia==0.0.40",
 ]
 
 [project.entry-points.simple_module]

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/sharing/locales/de.json

@@ -28,6 +28,7 @@
     "title": "Diese Freigabe widerrufen?",
     "description": "Die Person verliert sofort den Zugriff auf die Ressource.",
     "confirm": "Widerrufen",
-    "cancel": "Abbrechen"
+    "cancel": "Abbrechen",
+    "failed": "Die Freigabe konnte nicht widerrufen werden"
   }
 }

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/sharing/locales/en.json

@@ -28,6 +28,7 @@
     "title": "Revoke this share?",
     "description": "The user loses access to the resource immediately.",
     "confirm": "Revoke",
-    "cancel": "Cancel"
+    "cancel": "Cancel",
+    "failed": "Failed to revoke the share"
   }
 }

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/sharing/module.py

@@ -17,6 +17,7 @@ from sharing import constants as c
 if TYPE_CHECKING:
     from fastapi import APIRouter, FastAPI
     from simple_module_core.audit_links import AuditLinkRegistry
+    from simple_module_core.events import EventBus
     from simple_module_core.permissions import PermissionRegistry
 
 
@@ -27,6 +28,19 @@ class SharingModule(ModuleBase):
         view_prefix=c.VIEW_PREFIX,
     )
 
+    def register_event_handlers(self, bus: EventBus, app: FastAPI | None = None) -> None:
+        from simple_module_core.tenant_events import TenantDeleted
+
+        from sharing.tenant_cleanup import purge_tenant_data
+
+        bus.subscribe_durable(TenantDeleted, purge_tenant_data)
+
+        from simple_module_core.user_events import UserDeleted
+
+        from sharing.user_cleanup import purge_user_shares
+
+        bus.subscribe_durable(UserDeleted, purge_user_shares)
+
     def register_settings(self, app: FastAPI) -> None:
         from sharing.services import SharingServices
         from sharing.settings import SharingSettings

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/sharing/pages/Admin.tsx

@@ -7,6 +7,7 @@ import { PaginationBar } from '@simple-module-py/ui/components/PaginationBar';
 import { AdminLayout } from '@simple-module-py/ui/layouts/AdminLayout';
 import { Building2, Trash2 } from 'lucide-react';
 import { useState } from 'react';
+import { toast } from 'sonner';
 import { ShareTable } from './components/ShareTable';
 import type { Share } from './types';
 
@@ -37,11 +38,18 @@ function Admin(props: Props) {
   function confirmRevoke() {
     if (!pending) return;
     setBusy(true);
+    const onFailure = () => {
+      toast.error(t(keys.sharing.revoke.failed));
+      return false;
+    };
     router.post(
       `${BASE_URL}/${pending.id}/revoke`,
       {},
       {
         preserveScroll: true,
+        onError: onFailure,
+        onHttpException: onFailure,
+        onNetworkError: onFailure,
         onFinish: () => {
           setBusy(false);
           setPending(null);

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/sharing/service.py

@@ -9,9 +9,10 @@ grantee is someone the user directory knows. Rows are tenant-scoped by
 from __future__ import annotations
 
 import uuid
-from datetime import UTC, datetime
 from typing import Any
 
+from simple_module_core.datetimes import aware as _aware
+from simple_module_core.datetimes import utcnow
 from simple_module_core.resources import (
     ACTION_SHARE,
     ResourcePrincipal,
@@ -20,6 +21,7 @@ from simple_module_core.resources import (
 )
 from simple_module_core.user_directory import UserDirectory
 from simple_module_db.resource_policy import load_authorized
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
@@ -49,10 +51,6 @@ class SharingError(Exception):
         self.detail = detail
 
 
-def _aware(value: datetime) -> datetime:
-    return value if value.tzinfo is not None else value.replace(tzinfo=UTC)
-
-
 class SharingService:
     def __init__(
         self,
@@ -93,7 +91,7 @@ class SharingService:
         resource_type = self._type(data.resource_type)
         if data.role not in resource_type.shareable_actions:
             raise SharingError(422, ERR_BAD_ROLE)
-        if data.expires_at is not None and _aware(data.expires_at) <= datetime.now(UTC):
+        if data.expires_at is not None and _aware(data.expires_at) <= utcnow():
             raise SharingError(422, ERR_EXPIRED)
         row = await self._authorize(principal, resource_type, data.resource_id)
         grantee = (await self.directory.get_many(self.db, [data.subject_id])).get(data.subject_id)
@@ -112,8 +110,17 @@ class SharingService:
                 subject_id=grantee.id,
                 role=data.role,
                 granted_by=principal.user_id or "",
+                expires_at=data.expires_at,
             )
-            self.db.add(share)
+            try:
+                async with self.db.begin_nested():
+                    self.db.add(share)
+                    await self.db.flush()
+            except IntegrityError:
+                # Another grant may have won the unique-key race.
+                share = await self._existing(data.resource_type, resource_id, grantee.id)
+                if share is None:
+                    raise
         share.role = data.role
         share.expires_at = data.expires_at
         share.granted_by = principal.user_id or ""

simple_module_sharing-0.0.40/sharing/tenant_cleanup.py

@@ -0,0 +1,16 @@
+"""Durable teardown of tenant-owned sharing rows."""
+
+from simple_module_core.durable_events import DurableContext
+from simple_module_core.tenant_events import TenantDeleted
+from simple_module_db.tenancy import tenant_context
+from sqlmodel import delete
+
+from sharing.models import ResourceShare
+
+
+async def purge_tenant_data(event: TenantDeleted, ctx: DurableContext) -> None:
+    """Hard-delete tenant rows atomically with outbox acknowledgement."""
+    with tenant_context(event.tenant_id):
+        await ctx.db.execute(
+            delete(ResourceShare).where(ResourceShare.tenant_id == event.tenant_id)
+        )

simple_module_sharing-0.0.40/sharing/user_cleanup.py

@@ -0,0 +1,25 @@
+"""Revoke shares addressed to a deleted principal across tenants."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from simple_module_core.durable_events import DurableContext
+from simple_module_db import all_tenants
+from sqlmodel import col, delete
+
+from sharing.constants import SUBJECT_USER
+from sharing.models import ResourceShare
+
+if TYPE_CHECKING:
+    from simple_module_core.user_events import UserDeleted
+
+
+async def purge_user_shares(event: UserDeleted, ctx: DurableContext) -> None:
+    with all_tenants():
+        await ctx.db.execute(
+            delete(ResourceShare).where(
+                col(ResourceShare.subject_type) == SUBJECT_USER,
+                col(ResourceShare.subject_id) == str(event.user_id),
+            )
+        )

{simple_module_sharing-0.0.38 → simple_module_sharing-0.0.40}/tests/test_sharing_service.py

@@ -14,6 +14,7 @@ from _sharing_support import (
     create_note_table,
     register_note_type,
 )
+from sharing.constants import PERM_MANAGE
 from sharing.contracts.schemas import ShareGrant
 from sharing.models import ResourceShare
 from sharing.service import SharingError, SharingService
@@ -143,3 +144,84 @@ async def test_grantee_may_leave_and_owner_lists(env):
         await _refused(service.for_resource(_who(FRIEND), NOTE_TYPE, note_id), 403)
         await service.revoke(_who(FRIEND), share.id)
         assert await _visible(service.db, FRIEND) == []
+
+
+@pytest.mark.parametrize("role", [ACTION_VIEW, ACTION_EDIT])
+async def test_grantee_cannot_manage_shares_even_with_edit_role(env, role):
+    service, note_id = env
+    with tenant_context("t1"):
+        await service.grant(_who(OWNER), _grant(note_id, role=role))
+        reshare = _grant(note_id).model_copy(update={"subject_id": STRANGER})
+        await _refused(service.grant(_who(FRIEND), reshare), 403)
+        await _refused(service.for_resource(_who(FRIEND), NOTE_TYPE, note_id), 403)
+        assert len(await service.for_resource(_who(OWNER), NOTE_TYPE, note_id)) == 1
+
+
+@pytest.mark.parametrize("actor", [OWNER, FRIEND, "admin"])
+async def test_real_share_id_cannot_be_revoked_across_tenants(env, actor):
+    service, note_id = env
+    who = (
+        ResourcePrincipal(user_id=actor, permissions=frozenset({PERM_MANAGE}))
+        if actor == "admin"
+        else _who(actor)
+    )
+    with tenant_context("t1"):
+        share = await service.grant(_who(OWNER), _grant(note_id))
+    with tenant_context("t2"):
+        await _refused(service.revoke(who, share.id), 404)
+    with tenant_context("t1"):
+        assert [s.id for s in await service.for_resource(_who(OWNER), NOTE_TYPE, note_id)] == [
+            share.id
+        ]
+        assert await _visible(service.db, FRIEND) == ["n"]
+
+
+async def test_admin_may_revoke_without_resource_ownership(env):
+    service, note_id = env
+    admin = ResourcePrincipal(user_id=STRANGER, permissions=frozenset({PERM_MANAGE}))
+    with tenant_context("t1"):
+        share = await service.grant(_who(OWNER), _grant(note_id))
+        await service.revoke(admin, share.id)
+        assert await service.for_resource(_who(OWNER), NOTE_TYPE, note_id) == []
+        assert await _visible(service.db, FRIEND) == []
+        await _refused(service.revoke(admin, share.id), 404)
+
+
+async def test_expired_share_can_be_renewed_without_duplicate_grants(env):
+    service, note_id = env
+    with tenant_context("t1"):
+        share = await service.grant(_who(OWNER), _grant(note_id))
+        share.expires_at = datetime.now(UTC) - timedelta(days=1)
+        await service.db.flush()
+        assert await _visible(service.db, FRIEND) == []
+        assert [s.id for s in await service.for_resource(_who(OWNER), NOTE_TYPE, note_id)] == [
+            share.id
+        ]
+        future = datetime.now(UTC) + timedelta(days=1)
+        renewed = await service.grant(
+            _who(OWNER), _grant(note_id, expires_at=future, role=ACTION_EDIT)
+        )
+        assert renewed.id == share.id
+        assert await _visible(service.db, FRIEND, ACTION_EDIT) == ["n"]
+        assert len(await service.for_resource(_who(OWNER), NOTE_TYPE, note_id)) == 1
+
+
+async def test_duplicate_insert_race_reuses_winner_and_preserves_transaction(env, monkeypatch):
+    service, note_id = env
+    with tenant_context("t1"):
+        winner = await service.grant(_who(OWNER), _grant(note_id))
+        original = service._existing
+        calls = 0
+
+        async def miss_once(*args):
+            nonlocal calls
+            calls += 1
+            return None if calls == 1 else await original(*args)
+
+        # Simulate a concurrent winner becoming visible after our initial lookup.
+        monkeypatch.setattr(service, "_existing", miss_once)
+        result = await service.grant(_who(OWNER), _grant(note_id, role=ACTION_EDIT))
+        assert result.id == winner.id
+        assert result.role == ACTION_EDIT
+        assert len(await service.for_resource(_who(OWNER), NOTE_TYPE, note_id)) == 1
+        assert await _visible(service.db, FRIEND, ACTION_EDIT) == ["n"]

simple_module_sharing-0.0.40/tests/test_sharing_tenant_cleanup.py

@@ -0,0 +1,43 @@
+"""Tenant deletion purges only the deleted tenant through a durable handler."""
+
+from sharing.models import ResourceShare
+from sharing.module import SharingModule
+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 simple_module_db.tenancy import all_tenants, tenant_context
+from sqlmodel import select
+
+
+async def test_durable_tenant_cleanup_is_scoped_idempotent_and_transactional(db_session):
+    bus = EventBus()
+    SharingModule().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
+    for tenant_id in ("deleted-tenant", "other-tenant"):
+        with tenant_context(tenant_id):
+            db_session.add(
+                ResourceShare(
+                    resource_type="test.note",
+                    resource_id="note",
+                    subject_id="user",
+                    role="view",
+                    granted_by="owner",
+                )
+            )
+            await db_session.flush()
+    await db_session.commit()
+    event = TenantDeleted(tenant_id="deleted-tenant", slug="deleted", name="Deleted")
+    ctx = DurableContext(db=db_session, attempt=1)
+    # A worker rollback must restore rows: the handler must never commit its session.
+    await subscription.handler(event, ctx)
+    await db_session.rollback()
+    with all_tenants():
+        assert len((await db_session.execute(select(ResourceShare))).scalars().all()) == 2
+    await subscription.handler(event, ctx)
+    await subscription.handler(event, DurableContext(db=db_session, attempt=2))
+    with all_tenants():
+        remaining = (await db_session.execute(select(ResourceShare))).scalars().all()
+    assert [row.tenant_id for row in remaining] == ["other-tenant"]

simple_module_sharing-0.0.40/tests-js/sharing_Admin.test.tsx

@@ -0,0 +1,110 @@
+import { configureI18n, keys } from '@simple-module-py/i18n';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { ComponentProps } from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+configureI18n({ locale: 'en', messages: {} });
+const { post, get } = vi.hoisted(() => ({ post: vi.fn(), get: vi.fn() }));
+vi.mock('@inertiajs/react', () => ({
+  Head: () => null,
+  router: { post, get },
+  usePage: () => ({ props: {} }),
+}));
+
+import Admin from '../sharing/pages/Admin';
+
+const props: ComponentProps<typeof Admin> = {
+  shares: [
+    {
+      id: 'share-1',
+      resource_type: 'notes.note',
+      resource_id: 'note-1',
+      subject_type: 'user',
+      subject_id: 'friend',
+      subject_label: 'Friend',
+      role: 'view',
+      granted_by: 'owner',
+      granted_by_label: 'Owner',
+      expires_at: null,
+      expired: false,
+      created_at: null,
+    },
+  ],
+  total: 21,
+  page: 2,
+  per_page: 10,
+  can_revoke: true,
+  tenant_required: false,
+};
+
+afterEach(() => vi.clearAllMocks());
+
+describe('sharing Admin', () => {
+  it('renders labels and hides revoke from read-only viewers', () => {
+    render(<Admin {...props} can_revoke={false} />);
+    expect(screen.getByText('Friend')).toBeInTheDocument();
+    expect(screen.getByText('Owner')).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: keys.sharing.list.revoke })).toBeNull();
+  });
+
+  it('shows the tenant warning instead of shares and pagination when unbound', () => {
+    render(<Admin {...props} tenant_required />);
+    expect(screen.getByText(keys.sharing.admin.tenant_required)).toBeInTheDocument();
+    expect(screen.queryByText('Friend')).toBeNull();
+    expect(screen.queryByRole('button', { name: keys.ui.pagination.next })).toBeNull();
+  });
+
+  it('shows an empty state without pagination for an empty list', () => {
+    render(<Admin {...props} shares={[]} total={0} page={1} />);
+    expect(screen.getByText(keys.sharing.list.empty_title)).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: keys.ui.pagination.next })).toBeNull();
+  });
+
+  it.each([
+    [keys.ui.pagination.previous, 1],
+    [keys.ui.pagination.next, 3],
+  ])('navigates using %s', (name, page) => {
+    render(<Admin {...props} />);
+    fireEvent.click(screen.getByRole('button', { name }));
+    expect(get).toHaveBeenCalledWith('/admin/sharing/', { page }, { preserveScroll: true });
+  });
+
+  it.each([1, 3])('disables navigation beyond page %s', (page) => {
+    render(<Admin {...props} page={page} />);
+    const name = page === 1 ? keys.ui.pagination.previous : keys.ui.pagination.next;
+    expect(screen.getByRole('button', { name })).toBeDisabled();
+  });
+
+  it('cancels without writing and revokes only after confirmation', async () => {
+    render(<Admin {...props} />);
+    fireEvent.click(screen.getByRole('button', { name: keys.sharing.list.revoke }));
+    expect(post).not.toHaveBeenCalled();
+    fireEvent.click(await screen.findByRole('button', { name: keys.sharing.revoke.cancel }));
+    await waitFor(() => expect(screen.queryByText(keys.sharing.revoke.description)).toBeNull());
+    expect(post).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole('button', { name: keys.sharing.list.revoke }));
+    fireEvent.click(await screen.findByRole('button', { name: keys.sharing.revoke.confirm }));
+    expect(post).toHaveBeenCalledWith(
+      '/admin/sharing/share-1/revoke',
+      {},
+      expect.objectContaining({
+        preserveScroll: true,
+        onFinish: expect.any(Function),
+      }),
+    );
+    expect(screen.getByRole('button', { name: keys.sharing.revoke.confirm })).toBeDisabled();
+    act(() => post.mock.calls[0][2].onFinish());
+    await waitFor(() => expect(screen.queryByText(keys.sharing.revoke.description)).toBeNull());
+  });
+
+  it('clears pending state on visit completion so an unchanged share can be retried', async () => {
+    render(<Admin {...props} />);
+    fireEvent.click(screen.getByRole('button', { name: keys.sharing.list.revoke }));
+    fireEvent.click(await screen.findByRole('button', { name: keys.sharing.revoke.confirm }));
+    act(() => post.mock.calls[0][2].onFinish());
+    await waitFor(() => expect(screen.queryByText(keys.sharing.revoke.description)).toBeNull());
+    expect(screen.getByText('Friend')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: keys.sharing.list.revoke }));
+    expect(await screen.findByRole('button', { name: keys.sharing.revoke.confirm })).toBeEnabled();
+  });
+});

simple_module_sharing-0.0.40/tests-js/sharing_Admin_errors.test.tsx

@@ -0,0 +1,61 @@
+import { configureI18n } from '@simple-module-py/i18n';
+import { act, fireEvent, render, screen, within } from '@testing-library/react';
+import { toast } from 'sonner';
+import { beforeEach, expect, test, vi } from 'vitest';
+import Admin from '../sharing/pages/Admin';
+
+configureI18n({ locale: 'en', messages: {} });
+const { post } = vi.hoisted(() => ({ post: vi.fn() }));
+vi.mock('@inertiajs/react', () => ({
+  Head: () => null,
+  router: { post },
+  usePage: () => ({ props: {} }),
+}));
+vi.mock('sonner', () => ({ toast: { error: vi.fn() } }));
+
+beforeEach(() => vi.clearAllMocks());
+
+test.each(['onError', 'onHttpException', 'onNetworkError'])(
+  'revoke failures show a toast and release the busy dialog (%s)',
+  (callback) => {
+    render(
+      <Admin
+        shares={[
+          {
+            id: 's1',
+            resource_type: 'order',
+            resource_id: 'o1',
+            subject_type: 'user',
+            subject_id: 'u1',
+            subject_label: null,
+            role: 'viewer',
+            granted_by: 'u2',
+            granted_by_label: null,
+            expires_at: null,
+            expired: false,
+            created_at: null,
+          },
+        ]}
+        total={1}
+        page={1}
+        per_page={20}
+        can_revoke
+        tenant_required={false}
+      />,
+    );
+    fireEvent.click(screen.getAllByRole('button', { name: 'sharing.list.revoke' })[0]);
+    fireEvent.click(
+      within(screen.getByRole('alertdialog')).getByRole('button', {
+        name: 'sharing.revoke.confirm',
+      }),
+    );
+    const [url, , options] = post.mock.calls[0];
+    expect(url).toBe('/admin/sharing/s1/revoke');
+    act(() => {
+      options[callback]({});
+      options.onFinish();
+    });
+    expect(toast.error).toHaveBeenCalledWith('sharing.revoke.failed');
+    expect(screen.queryByRole('alertdialog')).toBeNull();
+  },
+);