Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Keep organization access bound to the selected read

pulse-triage[bot]4fb2457c5e85
diff --git a/frontend-modern/browser-verification/18a1e997e94a0284.json b/frontend-modern/browser-verification/18a1e997e94a0284.json
new file mode 100644
index 0000000000..4174bbe30f
--- /dev/null
+++ b/frontend-modern/browser-verification/18a1e997e94a0284.json
@@ -0,0 +1,76 @@
+{
+ "version": 1,
+ "base_sha": "b0923554fcc531166f1e5c3500c7a1b94cf06931",
+ "verified_at": "2026-10-31T17:41:47.863Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/api/orgs.ts",
+ "frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx",
+ "frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx",
+ "frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx",
+ "frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts",
+ "frontend-modern/src/utils/organizationSettingsPresentation.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/api/orgs.ts": "57345a09f2fe818ec50ad435ede99ff823f075e0c77896d091306e9b56126c7e",
+ "frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx": "0a8b5c32e45272b7c00616fd4d86fd8c008531eb8d0e372e79a7ac3c621b49b2",
+ "frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx": "94ef2a2924d3f6608985afff5a364af92008ec239a51cfb03c9b45b2598478aa",
+ "frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx": "8c6a2bc014cefbe68aecdf0afcd725f16be520bf9fa9d01f0ed385ed83d6bc0c",
+ "frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts": "aeeddfa26d44270f048896b61ccbd58945957755b3d53f9e73c52e9067d69f6b",
+ "frontend-modern/src/utils/organizationSettingsPresentation.ts": "f1a8a7a0c80786c0c873fc40de7b761b4bc9d5e432efe9cdf62b7dd4db47ddf5"
+ },
+ "routes": [
+ "Existing Organization Access settings: production panel, state, API client and stylesheet served in an isolated HTTP fixture"
+ ],
+ "viewports": [
+ {
+ "width": 1440,
+ "height": 1050
+ },
+ {
+ "width": 320,
+ "height": 900
+ }
+ ],
+ "states": [
+ "Selected organization unavailable, not empty",
+ "Pending read-only reload",
+ "Successful selected-org read and cleared peer draft",
+ "Unconfirmed mutation requires read reconciliation",
+ "Accepted empty membership",
+ "Read-only session with disabled invitation controls",
+ "Late prior-org read ignored",
+ "Interrupted mutation cannot affect a different selection"
+ ],
+ "interactions": [
+ "Switch organization during failed and delayed reads; retry only the selected read",
+ "Deliberately invite a member, change their role, revoke an invitation and confirm member removal on the current organization",
+ "As a viewer, accept and decline only the loaded personal invitation without member-management controls",
+ "Refuse a POST with 403: no transport replay; reload preserves the draft before a deliberate second change",
+ "Switch while POST is pending: no mutation replay, stale toast, new-draft loss or stale selection replacement",
+ "Lose and restore the existing multi-tenant capability; fresh selected read, no old save replay",
+ "Select default explicitly, retaining exact default read identity"
+ ],
+ "browsers": [
+ {
+ "engine": "Chromium",
+ "version": "141.0.7390.37"
+ },
+ {
+ "engine": "WebKit",
+ "version": "26.0"
+ }
+ ],
+ "playwright_version": "1.56.1",
+ "checks": 74,
+ "captures": 16,
+ "pixel_review": "All 16 final captures opened with native view_image. Error/reconciliation copy and reload controls remain readable at 320px; current-org identity, retained drafts and disabled read-only controls are visible. The existing member grid scrolls horizontally on narrow screens; interactions reached its actions.",
+ "evidence": [
+ "RECEIPTS.md",
+ "BROWSER-SUMMARY.json",
+ "PIXEL-REVIEW.json",
+ "CURRENT.tar.xz",
+ "final-captures/browser-result.json"
+ ],
+ "limitations": "Safe synthetic HTTP fixtures, not a private hosted installation, native SSO recovery, published release or customer acceptance. The initial proxy-identity regression and unsuccessful fixture attempts remain retained separately."
+}
diff --git a/frontend-modern/src/api/__tests__/orgs.access.test.ts b/frontend-modern/src/api/__tests__/orgs.access.test.ts
new file mode 100644
index 0000000000..ea4a0a96f2
--- /dev/null
+++ b/frontend-modern/src/api/__tests__/orgs.access.test.ts
@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrgsAPI, type OrganizationAccessRequestOptions } from '../orgs';
+import { apiClient, clearApiToken, getOrgID, setApiToken, setOrgID } from '@/utils/apiClient';
+
+const mockFetch = vi.fn();
+const accessRequests: {
+ name: string;
+ run: (options: OrganizationAccessRequestOptions) => Promise<unknown>;
+ path: string;
+ method: string;
+}[] = [
+ {
+ name: 'organization',
+ run: (options) => OrgsAPI.get('org/a', options),
+ path: '/api/orgs/org%2Fa',
+ method: 'GET',
+ },
+ {
+ name: 'members',
+ run: (options) => OrgsAPI.listMembers('org/a', options),
+ path: '/api/orgs/org%2Fa/members',
+ method: 'GET',
+ },
+ {
+ name: 'pending invitations',
+ run: (options) => OrgsAPI.listPendingInvitations('org/a', options),
+ path: '/api/orgs/org%2Fa/invitations',
+ method: 'GET',
+ },
+ {
+ name: 'personal invitations',
+ run: (options) => OrgsAPI.listMyInvitations(options),
+ path: '/api/org-invitations',
+ method: 'GET',
+ },
+ {
+ name: 'invite member',
+ run: (options) =>
+ OrgsAPI.inviteMember('org/a', { userId: 'new-user', role: 'viewer' }, options),
+ path: '/api/orgs/org%2Fa/members',
+ method: 'POST',
+ },
+ {
+ name: 'update role',
+ run: (options) =>
+ OrgsAPI.updateMemberRole('org/a', { userId: 'existing-user', role: 'editor' }, options),
+ path: '/api/orgs/org%2Fa/members',
+ method: 'POST',
+ },
+ {
+ name: 'remove member',
+ run: (options) => OrgsAPI.removeMember('org/a', 'user/b', options),
+ path: '/api/orgs/org%2Fa/members/user%2Fb',
+ method: 'DELETE',
+ },
+ {
+ name: 'revoke invitation',
+ run: (options) => OrgsAPI.revokeInvitation('org/a', 'user/b', options),
+ path: '/api/orgs/org%2Fa/invitations/user%2Fb',
+ method: 'DELETE',
+ },
+ {
+ name: 'accept personal invitation',
+ run: (options) => OrgsAPI.acceptMyInvitation('inviting/org', options),
+ path: '/api/org-invitations/inviting%2Forg/accept',
+ method: 'POST',
+ },
+ {
+ name: 'decline personal invitation',
+ run: (options) => OrgsAPI.declineMyInvitation('inviting/org', options),
+ path: '/api/org-invitations/inviting%2Forg',
+ method: 'DELETE',
+ },
+];
+const options = (): OrganizationAccessRequestOptions => ({
+ expectedOrgID: 'org-a',
+ retry: false,
+ signal: new AbortController().signal,
+});
+
+beforeEach(() => {
+ vi.useRealTimers();
+ mockFetch.mockReset();
+ vi.stubGlobal('fetch', mockFetch);
+ window.sessionStorage.clear();
+ window.localStorage.clear();
+ clearApiToken();
+ setOrgID('org-a');
+ document.cookie = 'pulse_csrf=synthetic-csrf; Path=/';
+});
+
+afterEach(() => {
+ clearApiToken();
+ setOrgID(null);
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+});
+
+describe('Organization Access strict transport', () => {
+ it.each(accessRequests)(
+ 'binds $name to the selected context, preserves session authentication and encodes target identities',
+ async ({ run, path, method }) => {
+ setApiToken('synthetic-token');
+ mockFetch.mockResolvedValue(new Response('{}'));
+ const binding = options();
+ await run(binding);
+ expect(mockFetch).toHaveBeenCalledTimes(1);
+ const [url, request] = mockFetch.mock.calls[0];
+ expect(url).toBe(path);
+ expect(request.method ?? 'GET').toBe(method);
+ expect(request.headers['X-Pulse-Org-ID']).toBe('org-a');
+ expect(request.headers['X-API-Token']).toBeUndefined();
+ expect(request.credentials).toBe('include');
+ expect(request.signal).toBe(binding.signal);
+ if (method !== 'GET') expect(request.headers['X-CSRF-Token']).toBeTruthy();
+ },
+ );
+
+ it.each([400, 403, 429])(
+ 'does not replay an access mutation or change selection after HTTP %i',
+ async (status) => {
+ mockFetch.mockResolvedValue(
+ new Response(JSON.stringify({ error: 'invalid_org' }), {
+ status,
+ headers: { 'X-CSRF-Token': 'new-csrf', 'Retry-After': '1' },
+ }),
+ );
+ await expect(
+ OrgsAPI.inviteMember('org-a', { userId: 'new-user', role: 'viewer' }, options()),
+ ).rejects.toThrow();
+ expect(mockFetch).toHaveBeenCalledTimes(1);
+ expect(getOrgID()).toBe('org-a');
+ },
+ );
+
+ it('does not fall back to the stored token after a refused session read', async () => {
+ setApiToken('synthetic-token');
+ mockFetch.mockResolvedValue(new Response('{}', { status: 401 }));
+ await expect(OrgsAPI.get('org-a', options())).rejects.toThrow();
+ expect(mockFetch).toHaveBeenCalledTimes(1);
+ expect(mockFetch.mock.calls[0][1].headers['X-API-Token']).toBeUndefined();
+ });
+
+ it('rejects a stale selection before dispatch, including during asynchronous CSRF preparation', async () => {
+ let finish!: (value: string) => void;
+ vi.spyOn(apiClient as any, 'loadCSRFToken').mockReturnValueOnce(null);
+ vi.spyOn(apiClient as any, 'ensureCSRFToken').mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const pending = OrgsAPI.removeMember('org-a', 'user-2', options());
+ setOrgID('org-b');
+ finish('synthetic-csrf');
+ await expect(pending).rejects.toThrow('Organisation changed');
+ expect(mockFetch).not.toHaveBeenCalled();
+ await expect(OrgsAPI.get('org-a', options())).rejects.toThrow('Organisation changed');
+ expect(mockFetch).not.toHaveBeenCalled();
+ });
+
+ it('does not dispatch after a controller was invalidated while CSRF was pending', async () => {
+ let finish!: (value: string) => void;
+ vi.spyOn(apiClient as any, 'loadCSRFToken').mockReturnValueOnce(null);
+ vi.spyOn(apiClient as any, 'ensureCSRFToken').mockReturnValueOnce(
+ new Promise((resolve) => {
+ finish = resolve;
+ }),
+ );
+ const controller = new AbortController();
+ const pending = OrgsAPI.declineMyInvitation('inviting-org', {
+ ...options(),
+ signal: controller.signal,
+ });
+ controller.abort();
+ finish('synthetic-csrf');
+ await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+ expect(mockFetch).not.toHaveBeenCalled();
+ });
+});
diff --git a/frontend-modern/src/api/orgs.ts b/frontend-modern/src/api/orgs.ts
index ee72d9eb66..529f647c20 100644
--- a/frontend-modern/src/api/orgs.ts
+++ b/frontend-modern/src/api/orgs.ts
@@ -61,6 +61,15 @@ export interface IncomingOrganizationShare extends OrganizationShare {
sourceOrgName: string;
}
+// Organization Access can bind an explicit read or change to the selection
+// that produced it, including the pre-dispatch CSRF wait. Other callers keep
+// their existing transport behaviour unless they opt in.
+export interface OrganizationAccessRequestOptions {
+ expectedOrgID: string;
+ signal: AbortSignal;
+ retry: false;
+}
+
export const OrgsAPI = {
list: () =>
apiFetchJSON<Organization[]>('/api/orgs', {
@@ -76,10 +85,11 @@ export const OrgsAPI = {
skipOrgContext: true,
}),
- get: (id: string) =>
+ get: (id: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<Organization>(`/api/orgs/${encodeURIComponent(id)}`, {
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
update: (id: string, payload: { displayName: string }) =>
@@ -97,74 +107,91 @@ export const OrgsAPI = {
skipOrgContext: true,
}),
- listMembers: (id: string) =>
+ listMembers: (id: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<OrganizationMember[]>(`/api/orgs/${encodeURIComponent(id)}/members`, {
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- listPendingInvitations: (id: string) =>
+ listPendingInvitations: (id: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<OrganizationInvitation[]>(`/api/orgs/${encodeURIComponent(id)}/invitations`, {
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- listMyInvitations: () =>
+ listMyInvitations: (options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<UserOrganizationInvitation[]>('/api/org-invitations', {
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- inviteMember: (id: string, payload: { userId: string; role: OrganizationRole }) =>
+ inviteMember: (
+ id: string,
+ payload: { userId: string; role: OrganizationRole },
+ options?: OrganizationAccessRequestOptions,
+ ) =>
apiFetchJSON<OrganizationAccessMutationResult>(`/api/orgs/${encodeURIComponent(id)}/members`, {
method: 'POST',
body: JSON.stringify(payload),
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- acceptMyInvitation: (id: string) =>
+ acceptMyInvitation: (id: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<OrganizationAccessMutationResult>(
`/api/org-invitations/${encodeURIComponent(id)}/accept`,
{
method: 'POST',
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
},
),
- declineMyInvitation: (id: string) =>
+ declineMyInvitation: (id: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<void>(`/api/org-invitations/${encodeURIComponent(id)}`, {
method: 'DELETE',
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- updateMemberRole: (id: string, payload: { userId: string; role: OrganizationRole }) =>
+ updateMemberRole: (
+ id: string,
+ payload: { userId: string; role: OrganizationRole },
+ options?: OrganizationAccessRequestOptions,
+ ) =>
apiFetchJSON<OrganizationAccessMutationResult>(`/api/orgs/${encodeURIComponent(id)}/members`, {
method: 'POST',
body: JSON.stringify(payload),
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
}),
- revokeInvitation: (id: string, userId: string) =>
+ revokeInvitation: (id: string, userId: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<void>(
`/api/orgs/${encodeURIComponent(id)}/invitations/${encodeURIComponent(userId)}`,
{
method: 'DELETE',
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
},
),
- removeMember: (id: string, userId: string) =>
+ removeMember: (id: string, userId: string, options?: OrganizationAccessRequestOptions) =>
apiFetchJSON<void>(
`/api/orgs/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`,
{
method: 'DELETE',
preferSessionAuth: true,
skipOrgContext: true,
+ ...options,
},
),
diff --git a/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx b/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx
index 463e81fd4d..0f2ce43f94 100644
--- a/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx
+++ b/frontend-modern/src/components/Settings/OrganizationAccessInvitationsSection.tsx
@@ -39,7 +39,7 @@ export const OrganizationAccessInvitationsSection: Component<
variant="primary"
size="mdCompact"
onClick={() => void props.state.acceptInvitation(invitation.orgId)}
- disabled={props.state.saving()}
+ disabled={!props.state.canChangeAccess()}
>
Accept
</Button>
@@ -47,7 +47,7 @@ export const OrganizationAccessInvitationsSection: Component<
variant="dangerOutline"
size="mdCompact"
onClick={() => void props.state.declineInvitation(invitation.orgId)}
- disabled={props.state.saving()}
+ disabled={!props.state.canChangeAccess()}
>
Decline
</Button>
@@ -82,7 +82,7 @@ export const OrganizationAccessInvitationsSection: Component<
variant="dangerOutline"
size="mdCompact"
onClick={() => void props.state.revokeInvitation(invitation.userId)}
- disabled={props.state.saving()}
+ disabled={!props.state.canChangeAccess()}
>
Revoke
</Button>
diff --git a/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx b/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx
index b611513cfc..c409a35c77 100644
--- a/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx
+++ b/frontend-modern/src/components/Settings/OrganizationAccessManagementSection.tsx
@@ -23,6 +23,7 @@ export const OrganizationAccessManagementSection: Component<
<div class="grid gap-2 sm:grid-cols-[1fr_auto_auto]">
<input
type="text"
+ aria-label="Invite user ID"
value={props.state.inviteUserID()}
onInput={(event) => props.state.setInviteUserID(event.currentTarget.value)}
placeholder="username"
@@ -62,7 +63,7 @@ export const OrganizationAccessManagementSection: Component<
<Show when={!props.state.canManageCurrentOrg()}>
<div class="rounded-md border border-amber-200 bg-amber-50 p-3 text-sm text-amber-800 dark:border-amber-800 dark:bg-amber-900/25 dark:text-amber-300">
- {getOrganizationAccessManageRequiredMessage()}
+ {getOrganizationAccessManageRequiredMessage(props.state.readOnly())}
</div>
</Show>
</>
diff --git a/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx b/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx
index 8f656fcc87..902dcfc5b3 100644
--- a/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx
+++ b/frontend-modern/src/components/Settings/OrganizationAccessPanel.tsx
@@ -1,8 +1,13 @@
import { Component, Show } from 'solid-js';
+import { Button } from '@/components/shared/Button';
+import { Card } from '@/components/shared/Card';
import SettingsPanel from '@/components/shared/SettingsPanel';
import { isMultiTenantEnabled } from '@/stores/license';
import { presentationPolicyHidesOrganizationSurfaces } from '@/stores/sessionPresentationPolicy';
import {
+ getOrganizationAccessReloadMessage,
+ ORGANIZATION_ACCESS_RELOAD_LABEL,
+ ORGANIZATION_ACCESS_UNAVAILABLE_TITLE,
ORGANIZATION_SETTINGS_UNAVAILABLE_CLASS,
ORGANIZATION_SETTINGS_UNAVAILABLE_MESSAGE,
} from '@/utils/organizationSettingsPresentation';
@@ -33,10 +38,40 @@ export const OrganizationAccessPanel: Component<OrganizationAccessPanelProps> =
<div class="space-y-6">
<SettingsPanel title="Organization Access" bodyClass="space-y-5">
<Show when={!state.loading()} fallback={<OrganizationAccessLoadingState />}>
- <Show when={state.org()}>
- <OrganizationAccessInvitationsSection state={state} />
- <OrganizationAccessManagementSection state={state} currentUser={props.currentUser} />
- <OrganizationAccessMembersSection state={state} currentUser={props.currentUser} />
+ <Show when={state.loadError()}>
+ <Card tone="warning" padding="md">
+ <div role="alert" class="space-y-3 text-sm">
+ <p class="font-semibold">{ORGANIZATION_ACCESS_UNAVAILABLE_TITLE}</p>
+ <p>{state.loadError()}</p>
+ <p>{getOrganizationAccessReloadMessage(state.selectedOrgID())}</p>
+ <Button
+ onClick={() => void state.loadOrganizationAccess()}
+ disabled={state.loading() || state.saving()}
+ class="w-full sm:w-auto"
+ >
+ {ORGANIZATION_ACCESS_RELOAD_LABEL}
+ </Button>
+ </div>
+ </Card>
+ </Show>
+ <Show when={!state.loadError() && state.org()}>
+ {(currentOrg) => (
+ <>
+ <p class="text-sm text-muted break-words">
+ Access for{' '}
+ <span class="font-medium text-base-content">
+ {currentOrg().displayName || currentOrg().id}
+ </span>{' '}
+ ({currentOrg().id})
+ </p>
+ <OrganizationAccessInvitationsSection state={state} />
+ <OrganizationAccessManagementSection
+ state={state}
+ currentUser={props.currentUser}
+ />
+ <OrganizationAccessMembersSection state={state} currentUser={props.currentUser} />
+ </>
+ )}
</Show>
</Show>
</SettingsPanel>
diff --git a/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx b/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx
index 21b1860caf..db117827c1 100644
--- a/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx
+++ b/frontend-modern/src/components/Settings/__tests__/OrganizationAccessPanel.test.tsx
@@ -1,5 +1,8 @@
+import { createSignal } from 'solid-js';
+import { useOrganizationAccessPanelState } from '../useOrganizationAccessPanelState';
+import type { OrganizationMember } from '@/api/orgs';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen, waitFor } from '@solidjs/testing-library';
+import { cleanup, fireEvent, render, screen, waitFor } from '@solidjs/testing-library';
import { OrganizationAccessPanel } from '../OrganizationAccessPanel';
import organizationAccessStateSource from '../useOrganizationAccessPanelState.ts?raw';
@@ -20,6 +23,11 @@ const notificationErrorMock = vi.fn();
const eventBusOnMock = vi.fn();
const eventBusEmitMock = vi.fn();
const loggerErrorMock = vi.fn();
+const readOnlyMock = vi.fn();
+const hideOrganizationsMock = vi.fn();
+let setEnabled: (enabled: boolean) => void;
+let setReadOnly: (readOnly: boolean) => void;
+const listeners = new Map<string, Set<() => void>>();
vi.mock('@/api/orgs', () => ({
OrgsAPI: {
@@ -40,6 +48,11 @@ vi.mock('@/stores/license', () => ({
isMultiTenantEnabled: (...args: unknown[]) => isMultiTenantEnabledMock(...args),
}));
+vi.mock('@/stores/sessionPresentationPolicy', () => ({
+ presentationPolicyHidesOrganizationSurfaces: () => hideOrganizationsMock(),
+ presentationPolicyIsReadOnly: () => readOnlyMock(),
+}));
+
vi.mock('@/utils/apiClient', () => ({
getOrgID: (...args: unknown[]) => getOrgIDMock(...args),
}));
@@ -114,16 +127,37 @@ beforeEach(() => {
eventBusEmitMock.mockReset();
loggerErrorMock.mockReset();
- isMultiTenantEnabledMock.mockReturnValue(true);
+ const [enabled, updateEnabled] = createSignal(true);
+ const [readOnly, updateReadOnly] = createSignal(false);
+ setEnabled = updateEnabled;
+ setReadOnly = updateReadOnly;
+ isMultiTenantEnabledMock.mockImplementation(enabled);
+ readOnlyMock.mockImplementation(readOnly);
+ hideOrganizationsMock.mockReturnValue(false);
+ vi.stubGlobal(
+ 'confirm',
+ vi.fn(() => true),
+ );
getOrgIDMock.mockReturnValue('org-a');
- eventBusOnMock.mockReturnValue(() => undefined);
+ listeners.clear();
+ eventBusOnMock.mockImplementation((event, callback) => {
+ if (!listeners.has(event)) listeners.set(event, new Set());
+ listeners.get(event)!.add(callback);
+ return () => listeners.get(event)?.delete(callback);
+ });
+ eventBusEmitMock.mockImplementation((event) => {
+ listeners.get(event)?.forEach((callback) => callback());
+ });
orgGetMock.mockResolvedValue(baseOrg);
listMembersMock.mockResolvedValue(baseMembers);
listPendingInvitationsMock.mockResolvedValue([]);
listMyInvitationsMock.mockResolvedValue([]);
updateMemberRoleMock.mockResolvedValue(undefined);
- inviteMemberMock.mockResolvedValue({ kind: 'invitation' });
+ inviteMemberMock.mockResolvedValue({
+ kind: 'invitation',
+ invitation: { userId: 'new-user', role: 'viewer' },
+ });
acceptMyInvitationMock.mockResolvedValue({ kind: 'member' });
declineMyInvitationMock.mockResolvedValue(undefined);
revokeInvitationMock.mockResolvedValue(undefined);
@@ -132,6 +166,7 @@ beforeEach(() => {
afterEach(() => {
cleanup();
+ vi.unstubAllGlobals();
});
describe('OrganizationAccessPanel', () => {
@@ -151,8 +186,503 @@ describe('OrganizationAccessPanel', () => {
});
});
+ it.each(['role', 'remove'] as const)(
+ 'admits the real datagrid proxy for a current %s change',
+ async (operation) => {
+ renderPanel();
+ await screen.findByText('user-2');
+ if (operation === 'role') {
+ fireEvent.change(screen.getByRole('combobox', { name: 'Role for user-2' }), {
+ target: { value: 'editor' },
+ });
+ await waitFor(() =>
+ expect(updateMemberRoleMock).toHaveBeenCalledWith(
+ 'org-a',
+ { userId: 'user-2', role: 'editor' },
+ expect.objectContaining({ expectedOrgID: 'org-a', retry: false }),
+ ),
+ );
+ } else {
+ fireEvent.click(screen.getByRole('button', { name: 'Remove', exact: true }));
+ await waitFor(() =>
+ expect(removeMemberMock).toHaveBeenCalledWith(
+ 'org-a',
+ 'user-2',
+ expect.objectContaining({ expectedOrgID: 'org-a', retry: false }),
+ ),
+ );
+ }
+ },
+ );
+
it('normalizes org scope through the shared helper', () => {
expect(organizationAccessStateSource).toContain('normalizeOrgScope(getOrgID())');
expect(organizationAccessStateSource).not.toContain("getOrgID() || 'default'");
});
});
+
+describe('Organization Access selection safety', () => {
+ it('does not restore the previous organization after a failed switch, and offers a read-only retry', async () => {
+ renderPanel();
+ await screen.findByText('user-2');
+ getOrgIDMock.mockReturnValue('org-b');
+ orgGetMock.mockRejectedValueOnce(new Error('Forbidden'));
+ eventBusEmitMock('org_switched');
+ await waitFor(() => expect(loggerErrorMock).toHaveBeenCalled());
+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();
+ expect(screen.queryByRole('button', { name: 'Invite', exact: true })).not.toBeInTheDocument();
+ expect(screen.getByRole('alert')).toHaveTextContent('org-b');
+ expect(screen.getByRole('button', { name: 'Reload access' })).toBeInTheDocument();
+ });
+
+ it('does not let a late old read replace the current organization', async () => {
+ const oldMembers = deferred<typeof baseMembers>();
+ listMembersMock.mockReturnValueOnce(oldMembers.promise);
+ renderPanel();
+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));
+ getOrgIDMock.mockReturnValue('org-b');
+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b', displayName: 'Organization B' });
+ listMembersMock.mockResolvedValueOnce([{ ...baseMembers[1], userId: 'member-b' }]);
+ eventBusEmitMock('org_switched');
+ await screen.findByText('member-b');
+ oldMembers.resolve(baseMembers);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(screen.getByText('member-b')).toBeInTheDocument();
+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();
+ });
+});
+
+const pendingInvitation = {
+ userId: 'invited-user',
+ role: 'viewer',
+ invitedAt: '2026-10-01T00:00:00Z',
+ invitedBy: 'user-1',
+};
+const personalInvitation = {
+ ...pendingInvitation,
+ userId: 'user-1',
+ orgId: 'inviting-org',
+ orgDisplayName: 'Inviting Organization',
+};
+const renderState = () => {
+ let state!: ReturnType<typeof useOrganizationAccessPanelState>;
+ const view = render(() => {
+ state = useOrganizationAccessPanelState({ currentUser: 'user-1' });
+ return <div />;
+ });
+ return { state, ...view };
+};
+const ready = async (state: ReturnType<typeof useOrganizationAccessPanelState>) => {
+ await waitFor(() => expect(state.loading()).toBe(false));
+ expect(state.loadError()).toBeNull();
+};
+const writes = () => [
+ updateMemberRoleMock,
+ inviteMemberMock,
+ acceptMyInvitationMock,
+ declineMyInvitationMock,
+ revokeInvitationMock,
+ removeMemberMock,
+];
+const expectNoWrites = () => writes().forEach((write) => expect(write).not.toHaveBeenCalled());
+
+describe('Organization Access read admission', () => {
+ it('keeps first-read failure distinct from accepted empty membership, and retries only reads', async () => {
+ orgGetMock.mockRejectedValueOnce(new Error('Unavailable'));
+ renderPanel();
+ await screen.findByRole('alert');
+ expect(screen.queryByText('No organization members found.')).not.toBeInTheDocument();
+ orgGetMock.mockResolvedValue(baseOrg);
+ listMembersMock.mockResolvedValue([]);
+ fireEvent.click(screen.getByRole('button', { name: 'Reload access' }));
+ await screen.findByText('No organization members found.');
+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+ expectNoWrites();
+ });
+
+ it('preserves only the same-selection invitation draft through a failed refresh and reload', async () => {
+ renderPanel();
+ const input = await screen.findByRole('textbox', { name: 'Invite user ID' });
+ fireEvent.input(input, { target: { value: 'unsent-user' } });
+ orgGetMock.mockRejectedValueOnce(new Error('Unavailable'));
+ eventBusEmitMock('organizations_changed');
+ await screen.findByRole('alert');
+ expect(screen.queryByText('user-2')).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'Reload access' }));
+ expect(await screen.findByRole('textbox', { name: 'Invite user ID' })).toHaveValue(
+ 'unsent-user',
+ );
+ expectNoWrites();
+ });
+
+ it('does not follow an obsolete organization lookup with membership reads', async () => {
+ const oldOrg = deferred<typeof baseOrg>();
+ orgGetMock.mockReturnValueOnce(oldOrg.promise);
+ const { state } = renderState();
+ getOrgIDMock.mockReturnValue('org-b');
+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b' });
+ eventBusEmitMock('org_switched');
+ await ready(state);
+ oldOrg.resolve(baseOrg);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(listMembersMock.mock.calls.map(([orgId]) => orgId)).toEqual(['org-b']);
+ expect(state.org()?.id).toBe('org-b');
+ });
+
+ it.each(['late success', 'late failure'])(
+ 'ignores %s from the first read after A → B → A',
+ async (result) => {
+ const first = deferred<typeof baseMembers>();
+ listMembersMock.mockReturnValueOnce(first.promise);
+ const { state } = renderState();
+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));
+ getOrgIDMock.mockReturnValue('org-b');
+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'org-b' });
+ eventBusEmitMock('org_switched');
+ await ready(state);
+ getOrgIDMock.mockReturnValue('org-a');
+ listMembersMock.mockResolvedValueOnce([{ ...baseMembers[1], userId: 'new-snapshot' }]);
+ eventBusEmitMock('org_switched');
+ await ready(state);
+ if (result === 'late success') first.resolve(baseMembers);
+ else first.reject(new Error('Old selection failed'));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(state.members().map((member) => member.userId)).toEqual(['new-snapshot']);
+ expect(state.loadError()).toBeNull();
+ expect(loggerErrorMock).not.toHaveBeenCalled();
+ },
+ );
+
+ it('rejects a different organization returned by the server without reading its members', async () => {
+ orgGetMock.mockResolvedValueOnce({ ...baseOrg, id: 'different-org' });
+ const { state } = renderState();
+ await waitFor(() => expect(state.loadError()).not.toBeNull());
+ expect(state.org()).toBeNull();
+ expect(listMembersMock).not.toHaveBeenCalled();
+ expectNoWrites();
+ });
+
+ it.each(['members', 'pending', 'personal'] as const)(
+ 'does not admit a malformed %s list as empty',
+ async (list) => {
+ const request = {
+ members: listMembersMock,
+ pending: listPendingInvitationsMock,
+ personal: listMyInvitationsMock,
+ }[list];
+ request.mockResolvedValueOnce(null);
+ const { state } = renderState();
+ await waitFor(() => expect(state.loadError()).not.toBeNull());
+ expect(state.org()).toBeNull();
+ expect(state.canManageCurrentOrg()).toBe(false);
+ },
+ );
+
+ it('binds every admitted read to the exact selected organization with one abort signal', async () => {
+ const { state } = renderState();
+ await ready(state);
+ for (const request of [orgGetMock, listMembersMock, listPendingInvitationsMock]) {
+ expect(request).toHaveBeenCalledWith(
+ 'org-a',
+ expect.objectContaining({
+ expectedOrgID: 'org-a',
+ retry: false,
+ signal: expect.any(AbortSignal),
+ }),
+ );
+ }
+ expect(listMyInvitationsMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ expectedOrgID: 'org-a',
+ retry: false,
+ signal: expect.any(AbortSignal),
+ }),
+ );
+ });
+
+ it('normalizes deliberate default selection without accepting another payload identity', async () => {
+ getOrgIDMock.mockReturnValue(null);
+ orgGetMock.mockResolvedValue({ ...baseOrg, id: 'default', ownerUserId: undefined });
+ const { state } = renderState();
+ await ready(state);
+ expect(state.org()?.id).toBe('default');
+ expect(orgGetMock.mock.calls[0][1].expectedOrgID).toBe('default');
+ expect(state.canManageCurrentOrg()).toBe(false);
+ });
+});
+
+describe('Organization Access change safety', () => {
+ beforeEach(() => {
+ listPendingInvitationsMock.mockResolvedValue([pendingInvitation]);
+ listMyInvitationsMock.mockResolvedValue([personalInvitation]);
+ });
+
+ const exerciseAllChanges = async (
+ state: ReturnType<typeof useOrganizationAccessPanelState>,
+ member: OrganizationMember,
+ ) => {
+ state.setInviteUserID('new-user');
+ await state.inviteMember();
+ await state.updateRole(member, 'editor');
+ await state.removeMember(member);
+ await state.revokeInvitation('invited-user');
+ await state.acceptInvitation('inviting-org');
+ await state.declineInvitation('inviting-org');
+ };
+
+ it.each(['pending', 'failed', 'switched without event', 'read-only', 'disabled'])(
+ 'rejects every retained mutation handler when %s',
+ async (reason) => {
+ const { state } = renderState();
+ await ready(state);
+ const member = state.members()[1];
+ if (reason === 'switched without event') getOrgIDMock.mockReturnValue('org-b');
+ if (reason === 'read-only') setReadOnly(true);
+ if (reason === 'disabled') setEnabled(false);
+ if (reason === 'pending' || reason === 'failed') {
+ const lookup = deferred<typeof baseOrg>();
+ orgGetMock.mockReturnValueOnce(lookup.promise);
+ eventBusEmitMock('organizations_changed');
+ if (reason === 'failed') {
+ lookup.reject(new Error('Unavailable'));
+ await waitFor(() => expect(state.loadError()).not.toBeNull());
+ }
+ }
+ await exerciseAllChanges(state, member);
+ expectNoWrites();
+ expect(confirm).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(['invite', 'role', 'remove', 'revoke', 'accept', 'decline'] as const)(
+ 'uses exactly one snapshot-bound %s mutation and blocks concurrent changes',
+ async (operation) => {
+ const { state } = renderState();
+ await ready(state);
+ const member = state.members()[1];
+ const result = deferred<any>();
+ const request = {
+ invite: inviteMemberMock,
+ role: updateMemberRoleMock,
+ remove: removeMemberMock,
+ revoke: revokeInvitationMock,
+ accept: acceptMyInvitationMock,
+ decline: declineMyInvitationMock,
+ }[operation];
+ request.mockReturnValueOnce(result.promise);
+ state.setInviteUserID('new-user');
+ const action = {
+ invite: () => state.inviteMember(),
+ role: () => state.updateRole(member, 'editor'),
+ remove: () => state.removeMember(member),
+ revoke: () => state.revokeInvitation('invited-user'),
+ accept: () => state.acceptInvitation('inviting-org'),
+ decline: () => state.declineInvitation('inviting-org'),
+ }[operation];
+ const pending = action();
+ expect(state.saving()).toBe(true);
+ await exerciseAllChanges(state, member);
+ expect(writes().reduce((sum, write) => sum + write.mock.calls.length, 0)).toBe(1);
+ expect(request.mock.calls[0].at(-1)).toMatchObject({
+ expectedOrgID: 'org-a',
+ retry: false,
+ signal: expect.any(AbortSignal),
+ });
+ expect(request.mock.calls[0][0]).toBe(
+ operation === 'accept' || operation === 'decline' ? 'inviting-org' : 'org-a',
+ );
+ result.resolve({ kind: 'member', member });
+ await pending;
+ await ready(state);
+ expect(notificationSuccessMock).toHaveBeenCalledTimes(1);
+ expect(orgGetMock).toHaveBeenCalledTimes(2);
+ },
+ );
+
+ it('requires a read after a failed mutation, retaining the draft without replaying the change', async () => {
+ const { state } = renderState();
+ await ready(state);
+ state.setInviteUserID('new-user');
+ inviteMemberMock.mockRejectedValueOnce(new Error('Connection lost'));
+ await state.inviteMember();
+ expect(state.loadError()).toMatch(/could not be confirmed/);
+ expect(state.inviteUserID()).toBe('new-user');
+ await state.inviteMember();
+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);
+ expect(orgGetMock).toHaveBeenCalledTimes(1);
+ await state.loadOrganizationAccess();
+ await ready(state);
+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);
+ expect(state.inviteUserID()).toBe('new-user');
+ });
+
+ it('does not erase a newer draft on successful invite', async () => {
+ const result = deferred<any>();
+ inviteMemberMock.mockReturnValueOnce(result.promise);
+ const { state } = renderState();
+ await ready(state);
+ state.setInviteUserID('first-user');
+ const pending = state.inviteMember();
+ state.setInviteUserID('next-user');
+ result.resolve({ kind: 'member' });
+ await pending;
+ await ready(state);
+ expect(state.inviteUserID()).toBe('next-user');
+ });
+
+ it.each(['success', 'failure'])(
+ 'ignores old mutation %s after switching, without clearing the new draft or pending read',
+ async (outcome) => {
+ const result = deferred<any>();
+ inviteMemberMock.mockReturnValueOnce(result.promise);
+ const { state } = renderState();
+ await ready(state);
+ state.setInviteUserID('old-user');
+ const pending = state.inviteMember();
+ const signal = inviteMemberMock.mock.calls[0][2].signal;
+ const lookup = deferred<typeof baseOrg>();
+ orgGetMock.mockReturnValueOnce(lookup.promise);
+ getOrgIDMock.mockReturnValue('org-b');
+ eventBusEmitMock('org_switched');
+ expect(signal.aborted).toBe(true);
+ expect(state.inviteUserID()).toBe('');
+ state.setInviteUserID('new-draft');
+ if (outcome === 'success') result.resolve({ kind: 'member' });
+ else result.reject(new Error('Old change failed'));
+ await pending;
+ expect(state.loading()).toBe(true);
+ expect(state.inviteUserID()).toBe('new-draft');
+ expect(notificationSuccessMock).not.toHaveBeenCalled();
+ expect(notificationErrorMock).not.toHaveBeenCalled();
+ lookup.resolve({ ...baseOrg, id: 'org-b' });
+ await ready(state);
+ expect(inviteMemberMock).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it('does not accept a stale member object or absent invitation after a same-organization reload', async () => {
+ const { state } = renderState();
+ await ready(state);
+ const staleMember = state.members()[1];
+ listMembersMock.mockResolvedValue(baseMembers.map((member) => ({ ...member })));
+ listPendingInvitationsMock.mockResolvedValue([]);
+ listMyInvitationsMock.mockResolvedValue([]);
+ await state.loadOrganizationAccess();
+ await state.updateRole(staleMember, 'editor');
+ await state.removeMember(staleMember);
+ await state.revokeInvitation('invited-user');
+ await state.acceptInvitation('inviting-org');
+ await state.declineInvitation('inviting-org');
+ expectNoWrites();
+ });
+
+ it('rechecks a remove confirmation against the selection that supplied it', async () => {
+ const { state } = renderState();
+ await ready(state);
+ vi.mocked(confirm).mockImplementationOnce(() => {
+ getOrgIDMock.mockReturnValue('org-b');
+ return true;
+ });
+ await state.removeMember(state.members()[1]);
+ expect(removeMemberMock).not.toHaveBeenCalled();
+ });
+
+ it('preserves the owner and existing-member ownership transfer rules', async () => {
+ const { state } = renderState();
+ await ready(state);
+ await state.removeMember(state.members()[0]);
+ await state.updateRole(state.members()[0], 'viewer');
+ state.setInviteUserID('not-a-member');
+ state.setInviteRole('owner');
+ await state.inviteMember();
+ expectNoWrites();
+ expect(notificationErrorMock).toHaveBeenCalledWith(
+ 'Ownership can only be transferred to an existing member.',
+ );
+ });
+
+ it('allows a viewer to answer their own invitation but not manage members or pending invitations', async () => {
+ orgGetMock.mockResolvedValue({
+ ...baseOrg,
+ ownerUserId: 'someone-else',
+ members: baseMembers.map((member) => ({ ...member, role: 'viewer' })),
+ });
+ const { state } = renderState();
+ await ready(state);
+ expect(state.canManageCurrentOrg()).toBe(false);
+ expect(listPendingInvitationsMock).not.toHaveBeenCalled();
+ state.setInviteUserID('new-user');
+ await state.inviteMember();
+ await state.updateRole(state.members()[1], 'admin');
+ await state.removeMember(state.members()[1]);
+ expect(inviteMemberMock).not.toHaveBeenCalled();
+ expect(updateMemberRoleMock).not.toHaveBeenCalled();
+ expect(removeMemberMock).not.toHaveBeenCalled();
+ await state.acceptInvitation('inviting-org');
+ expect(acceptMyInvitationMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('shows a read-only session notice instead of presenting a false role requirement', async () => {
+ setReadOnly(true);
+ renderPanel();
+ await screen.findByText('Organization access is read-only for this session.');
+ expect(screen.getByRole('button', { name: 'Accept', exact: true })).toBeDisabled();
+ expect(screen.getByRole('button', { name: 'Decline', exact: true })).toBeDisabled();
+ expect(screen.queryByRole('textbox', { name: 'Invite user ID' })).not.toBeInTheDocument();
+ expect(
+ screen.queryByText('Admin or owner role required to manage organization access.'),
+ ).not.toBeInTheDocument();
+ });
+});
+
+describe('Organization Access lifetime', () => {
+ it('invalidates reads on capability loss and reads afresh when the capability returns', async () => {
+ const oldMembers = deferred<typeof baseMembers>();
+ listMembersMock.mockReturnValueOnce(oldMembers.promise);
+ const { state } = renderState();
+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(1));
+ const signal = listMembersMock.mock.calls[0][1].signal;
+ setEnabled(false);
+ await waitFor(() => expect(state.loading()).toBe(false));
+ expect(signal.aborted).toBe(true);
+ oldMembers.resolve(baseMembers);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(state.org()).toBeNull();
+ setEnabled(true);
+ await ready(state);
+ expect(orgGetMock).toHaveBeenCalledTimes(2);
+ expect(state.members()).toEqual(baseMembers);
+ });
+
+ it('invalidates an older identity and clears its draft even in the same organization', async () => {
+ const [currentUser, setCurrentUser] = createSignal('user-1');
+ render(() => <OrganizationAccessPanel currentUser={currentUser()} />);
+ fireEvent.input(await screen.findByRole('textbox', { name: 'Invite user ID' }), {
+ target: { value: 'private-draft' },
+ });
+ const pending = deferred<typeof baseMembers>();
+ listMembersMock.mockReturnValueOnce(pending.promise);
+ eventBusEmitMock('organizations_changed');
+ await waitFor(() => expect(listMembersMock).toHaveBeenCalledTimes(2));
+ orgGetMock.mockResolvedValue({ ...baseOrg, ownerUserId: 'user-b' });
+ setCurrentUser('user-b');
+ expect(await screen.findByRole('textbox', { name: 'Invite user ID' })).toHaveValue('');
+ pending.reject(new Error('Old identity failed'));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+ });
+
+ it('aborts reads and unsubscribes on disposal without emitting late errors', async () => {
+ const pending = deferred<typeof baseOrg>();
+ orgGetMock.mockReturnValueOnce(pending.promise);
+ const { unmount } = renderState();
+ const signal = orgGetMock.mock.calls[0][1].signal;
+ unmount();
+ expect(signal.aborted).toBe(true);
+ pending.reject(new Error('Disposed read'));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(loggerErrorMock).not.toHaveBeenCalled();
+ eventBusEmitMock('org_switched');
+ expect(orgGetMock).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts b/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts
index 51e5f718a5..aca9c9439e 100644
--- a/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts
+++ b/frontend-modern/src/components/Settings/useOrganizationAccessPanelState.ts
@@ -1,7 +1,9 @@
-import { createMemo, createSignal, onCleanup, onMount } from 'solid-js';
+import { batch, createEffect, createMemo, createSignal, on, onCleanup } from 'solid-js';
+import { unwrap } from 'solid-js/store';
import {
OrgsAPI,
type Organization,
+ type OrganizationAccessRequestOptions,
type OrganizationInvitation,
type OrganizationMember,
type OrganizationRole,
@@ -10,7 +12,10 @@ import {
import { eventBus } from '@/stores/events';
import { isMultiTenantEnabled } from '@/stores/license';
import { notificationStore } from '@/stores/notifications';
-import { presentationPolicyHidesOrganizationSurfaces } from '@/stores/sessionPresentationPolicy';
+import {
+ presentationPolicyHidesOrganizationSurfaces,
+ presentationPolicyIsReadOnly,
+} from '@/stores/sessionPresentationPolicy';
import { getOrgID } from '@/utils/apiClient';
import { logger } from '@/utils/logger';
import { normalizeOrgScope } from '@/utils/orgScope';
@@ -33,6 +38,7 @@ import {
getOrganizationOwnerRoleLockedMessage,
getOrganizationRemoveMemberErrorMessage,
getOrganizationSettingsLoadErrorMessage,
+ ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE,
} from '@/utils/organizationSettingsPresentation';
import { canManageOrg, normalizeRole } from '@/utils/orgUtils';
@@ -42,6 +48,7 @@ interface OrganizationAccessPanelProps {
export function useOrganizationAccessPanelState(props: OrganizationAccessPanelProps) {
const [loading, setLoading] = createSignal(true);
+ const [loadError, setLoadError] = createSignal<string | null>(null);
const [saving, setSaving] = createSignal(false);
const [org, setOrg] = createSignal<Organization | null>(null);
const [members, setMembers] = createSignal<OrganizationMember[]>([]);
@@ -51,218 +58,310 @@ export function useOrganizationAccessPanelState(props: OrganizationAccessPanelPr
const [inviteRole, setInviteRole] = createSignal<OrganizationRole>('viewer');
const activeOrgId = () => normalizeOrgScope(getOrgID());
- const canManageCurrentOrg = createMemo(() => canManageOrg(org(), props.currentUser));
+ const [selectedOrgID, setSelectedOrgID] = createSignal(activeOrgId());
+ const [selectedUser, setSelectedUser] = createSignal(props.currentUser);
+ let generation = 0;
+ let disposed = false;
+ let readController: AbortController | undefined;
+ let mutationController: AbortController | undefined;
+ const surfaceEnabled = () =>
+ isMultiTenantEnabled() && !presentationPolicyHidesOrganizationSurfaces();
+ const selectionIsCurrent = () =>
+ !disposed &&
+ surfaceEnabled() &&
+ selectedOrgID() === activeOrgId() &&
+ selectedUser() === props.currentUser;
+ const hasCurrentAccess = () =>
+ selectionIsCurrent() && !loading() && !loadError() && org()?.id === activeOrgId();
+ const canManageCurrentOrg = createMemo(
+ () =>
+ hasCurrentAccess() &&
+ !presentationPolicyIsReadOnly() &&
+ canManageOrg(org(), props.currentUser),
+ );
+ const canChangeAccess = () =>
+ hasCurrentAccess() && !!props.currentUser && !presentationPolicyIsReadOnly() && !saving();
+
+ // PulseDataGrid wraps the accepted row in a Solid store proxy. Compare its
+ // underlying object, not the proxy, without admitting an older read's row.
+ const isCurrentMember = (member: OrganizationMember) => members().includes(unwrap(member));
+
+ const clearAccess = () => {
+ setOrg(null);
+ setMembers([]);
+ setPendingInvitations([]);
+ setMyInvitations([]);
+ };
+
+ const invalidateRequests = () => {
+ generation += 1;
+ readController?.abort();
+ readController = undefined;
+ mutationController?.abort();
+ mutationController = undefined;
+ setSaving(false);
+ };
const loadOrganizationAccess = async () => {
- setLoading(true);
+ if (disposed) return;
+ invalidateRequests();
+ const orgId = activeOrgId();
+ const user = props.currentUser;
+ const request = generation;
+ const isCurrent = () => request === generation && selectionIsCurrent();
+ batch(() => {
+ if (selectedOrgID() !== orgId || selectedUser() !== user) {
+ setInviteUserID('');
+ setInviteRole('viewer');
+ }
+ setSelectedOrgID(orgId);
+ setSelectedUser(user);
+ clearAccess();
+ setLoadError(null);
+ setLoading(surfaceEnabled());
+ });
+ if (!surfaceEnabled()) return;
+
+ const controller = new AbortController();
+ readController = controller;
+ const options: OrganizationAccessRequestOptions = {
+ expectedOrgID: orgId,
+ signal: controller.signal,
+ retry: false,
+ };
try {
- const orgId = activeOrgId();
- const orgData = await OrgsAPI.get(orgId);
- const manageable = canManageOrg(orgData, props.currentUser);
+ const orgData = await OrgsAPI.get(orgId, options);
+ if (!isCurrent()) return;
+ if (!orgData || orgData.id !== orgId) {
+ throw new Error('Organization access returned a different selection');
+ }
+ const manageable = canManageOrg(orgData, user);
const [memberData, invitationData, myInvitationData] = await Promise.all([
- OrgsAPI.listMembers(orgId),
- manageable ? OrgsAPI.listPendingInvitations(orgId) : Promise.resolve([]),
- OrgsAPI.listMyInvitations(),
+ OrgsAPI.listMembers(orgId, options),
+ manageable ? OrgsAPI.listPendingInvitations(orgId, options) : Promise.resolve([]),
+ OrgsAPI.listMyInvitations(options),
]);
- setOrg(orgData);
- setMembers(memberData);
- setPendingInvitations(invitationData);
- setMyInvitations(myInvitationData);
+ if (!isCurrent()) return;
+ if (
+ !Array.isArray(memberData) ||
+ !Array.isArray(invitationData) ||
+ !Array.isArray(myInvitationData)
+ ) {
+ throw new Error('Organization access returned invalid lists');
+ }
+ batch(() => {
+ setOrg(orgData);
+ setMembers(memberData);
+ setPendingInvitations(invitationData);
+ setMyInvitations(myInvitationData);
+ });
} catch (error) {
+ if (!isCurrent()) return;
logger.error('Failed to load organization access data', error);
const message = error instanceof Error ? error.message : '';
- notificationStore.error(getOrganizationSettingsLoadErrorMessage(message, 'access'));
+ setLoadError(getOrganizationSettingsLoadErrorMessage(message, 'access'));
} finally {
- setLoading(false);
+ if (!disposed && request === generation) {
+ // Also cancel sibling reads when only one Promise.all member failed.
+ controller.abort();
+ readController = undefined;
+ setLoading(false);
+ if (!selectionIsCurrent()) void loadOrganizationAccess();
+ }
}
};
- const updateRole = async (member: OrganizationMember, role: OrganizationRole) => {
- const currentOrg = org();
- if (!currentOrg) return;
- const currentRole = normalizeRole(member.role);
- if (currentRole === role) return;
-
- if (member.userId === currentOrg.ownerUserId && role !== 'owner') {
- notificationStore.error(getOrganizationOwnerRoleLockedMessage());
- return;
- }
-
+ const changeAccess = async <T>(
+ change: (options: OrganizationAccessRequestOptions) => Promise<T>,
+ successMessage: (result: T) => string,
+ errorMessage: (message?: string) => string,
+ afterSuccess?: () => void,
+ ) => {
+ if (!canChangeAccess()) return;
+ const request = generation;
+ const controller = new AbortController();
+ mutationController = controller;
setSaving(true);
+ const isCurrent = () => request === generation && selectionIsCurrent();
try {
- await OrgsAPI.updateMemberRole(currentOrg.id, { userId: member.userId, role });
- notificationStore.success(getOrganizationAccessRoleUpdatedMessage(member.userId, role));
- await loadOrganizationAccess();
+ const result = await change({
+ expectedOrgID: selectedOrgID(),
+ signal: controller.signal,
+ retry: false,
+ });
+ if (!isCurrent()) return;
+ notificationStore.success(successMessage(result));
+ afterSuccess?.();
+ mutationController = undefined;
+ setSaving(false);
+ // Refresh the accepted snapshot for every mutation, and notify the other
+ // organization surfaces. Our existing subscription owns the single read.
+ eventBus.emit('organizations_changed');
} catch (error) {
- logger.error('Failed to update member role', error);
- notificationStore.error(
- getOrganizationMemberRoleUpdateErrorMessage(
- error instanceof Error ? error.message : undefined,
- ),
- );
+ if (!isCurrent()) return;
+ logger.error('Failed to change organization access', error);
+ notificationStore.error(errorMessage(error instanceof Error ? error.message : undefined));
+ // A failed response does not establish whether the server applied the
+ // change. Require a read, never automatically repeat a write.
+ batch(() => {
+ clearAccess();
+ setLoadError(ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE);
+ });
} finally {
- setSaving(false);
+ if (mutationController === controller) {
+ mutationController = undefined;
+ setSaving(false);
+ if (!disposed && !selectionIsCurrent()) void loadOrganizationAccess();
+ }
}
};
- const inviteMember = async () => {
- const currentOrg = org();
- if (!currentOrg) return;
+ const updateRole = async (member: OrganizationMember, role: OrganizationRole) => {
+ if (!canChangeAccess() || !canManageCurrentOrg() || !isCurrentMember(member)) return;
+ const currentOrg = org()!;
+ if (normalizeRole(member.role) === role) return;
+ if (
+ (member.userId === currentOrg.ownerUserId && role !== 'owner') ||
+ (role === 'owner' && props.currentUser !== currentOrg.ownerUserId)
+ ) {
+ notificationStore.error(getOrganizationOwnerRoleLockedMessage());
+ return;
+ }
+ await changeAccess(
+ (options) =>
+ OrgsAPI.updateMemberRole(currentOrg.id, { userId: member.userId, role }, options),
+ () => getOrganizationAccessRoleUpdatedMessage(member.userId, role),
+ getOrganizationMemberRoleUpdateErrorMessage,
+ );
+ };
- const userId = inviteUserID().trim();
+ const inviteMember = async () => {
+ if (!canChangeAccess() || !canManageCurrentOrg()) return;
+ const currentOrg = org()!;
+ const draft = inviteUserID();
+ const userId = draft.trim();
+ const role = inviteRole();
if (!userId) {
notificationStore.error(getOrganizationMemberUserIdRequiredMessage());
return;
}
-
- setSaving(true);
- try {
- const role = inviteRole();
- if (role === 'owner' && !members().some((member) => member.userId === userId)) {
+ if (role === 'owner') {
+ if (props.currentUser !== currentOrg.ownerUserId) return;
+ if (!members().some((member) => member.userId === userId)) {
notificationStore.error(getOrganizationAccessOwnerTransferMemberRequiredMessage());
return;
}
-
- const result = await OrgsAPI.inviteMember(currentOrg.id, { userId, role });
- if (result.kind === 'invitation') {
- notificationStore.success(
- getOrganizationAccessInvitationSentMessage(userId, result.invitation.role),
- );
- } else {
- notificationStore.success(getOrganizationAccessMemberAddedMessage(userId, role));
- }
- setInviteUserID('');
- setInviteRole('viewer');
- await loadOrganizationAccess();
- } catch (error) {
- logger.error('Failed to add organization member', error);
- notificationStore.error(
- getOrganizationAddMemberErrorMessage(error instanceof Error ? error.message : undefined),
- );
- } finally {
- setSaving(false);
}
+ await changeAccess(
+ (options) => OrgsAPI.inviteMember(currentOrg.id, { userId, role }, options),
+ (result) =>
+ result.kind === 'invitation'
+ ? getOrganizationAccessInvitationSentMessage(userId, result.invitation.role)
+ : getOrganizationAccessMemberAddedMessage(userId, role),
+ getOrganizationAddMemberErrorMessage,
+ () => {
+ if (inviteUserID() === draft && inviteRole() === role) {
+ setInviteUserID('');
+ setInviteRole('viewer');
+ }
+ },
+ );
};
const acceptInvitation = async (orgId: string) => {
- setSaving(true);
- try {
- await OrgsAPI.acceptMyInvitation(orgId);
- notificationStore.success(
- getOrganizationAccessInvitationAcceptedMessage(props.currentUser || 'user'),
- );
- eventBus.emit('organizations_changed');
- await loadOrganizationAccess();
- } catch (error) {
- logger.error('Failed to accept organization invitation', error);
- notificationStore.error(
- getOrganizationInvitationActionErrorMessage(
- error instanceof Error ? error.message : undefined,
- ),
- );
- } finally {
- setSaving(false);
- }
+ if (!canChangeAccess() || !myInvitations().some((invitation) => invitation.orgId === orgId))
+ return;
+ await changeAccess(
+ (options) => OrgsAPI.acceptMyInvitation(orgId, options),
+ () => getOrganizationAccessInvitationAcceptedMessage(props.currentUser!),
+ getOrganizationInvitationActionErrorMessage,
+ );
};
const declineInvitation = async (orgId: string) => {
- setSaving(true);
- try {
- await OrgsAPI.declineMyInvitation(orgId);
- notificationStore.success(getOrganizationAccessInvitationDeclinedMessage(orgId));
- eventBus.emit('organizations_changed');
- await loadOrganizationAccess();
- } catch (error) {
- logger.error('Failed to decline organization invitation', error);
- notificationStore.error(
- getOrganizationInvitationActionErrorMessage(
- error instanceof Error ? error.message : undefined,
- ),
- );
- } finally {
- setSaving(false);
- }
+ if (!canChangeAccess() || !myInvitations().some((invitation) => invitation.orgId === orgId))
+ return;
+ await changeAccess(
+ (options) => OrgsAPI.declineMyInvitation(orgId, options),
+ () => getOrganizationAccessInvitationDeclinedMessage(orgId),
+ getOrganizationInvitationActionErrorMessage,
+ );
};
const revokeInvitation = async (userId: string) => {
- const currentOrg = org();
- if (!currentOrg) return;
-
- setSaving(true);
- try {
- await OrgsAPI.revokeInvitation(currentOrg.id, userId);
- notificationStore.success(getOrganizationAccessInvitationRevokedMessage(userId));
- eventBus.emit('organizations_changed');
- await loadOrganizationAccess();
- } catch (error) {
- logger.error('Failed to revoke organization invitation', error);
- notificationStore.error(
- getOrganizationInvitationActionErrorMessage(
- error instanceof Error ? error.message : undefined,
- ),
- );
- } finally {
- setSaving(false);
- }
+ if (
+ !canChangeAccess() ||
+ !canManageCurrentOrg() ||
+ !pendingInvitations().some((invitation) => invitation.userId === userId)
+ )
+ return;
+ const orgId = org()!.id;
+ await changeAccess(
+ (options) => OrgsAPI.revokeInvitation(orgId, userId, options),
+ () => getOrganizationAccessInvitationRevokedMessage(userId),
+ getOrganizationInvitationActionErrorMessage,
+ );
};
const removeMember = async (member: OrganizationMember) => {
- const currentOrg = org();
- if (!currentOrg) return;
- const organizationName = currentOrg.displayName || currentOrg.id;
- if (!confirm(getOrganizationMemberRemoveConfirmMessage(member.userId, organizationName))) {
+ if (!canChangeAccess() || !canManageCurrentOrg() || !isCurrentMember(member)) return;
+ const currentOrg = org()!;
+ if (member.userId === currentOrg.ownerUserId) return;
+ if (
+ !confirm(
+ getOrganizationMemberRemoveConfirmMessage(
+ member.userId,
+ currentOrg.displayName || currentOrg.id,
+ ),
+ )
+ )
return;
- }
-
- setSaving(true);
- try {
- await OrgsAPI.removeMember(currentOrg.id, member.userId);
- notificationStore.success(getOrganizationAccessMemberRemovedMessage(member.userId));
- await loadOrganizationAccess();
- } catch (error) {
- logger.error('Failed to remove organization member', error);
- notificationStore.error(
- getOrganizationRemoveMemberErrorMessage(error instanceof Error ? error.message : undefined),
- );
- } finally {
- setSaving(false);
- }
+ // A confirmation can outlive the snapshot that supplied its member.
+ if (org() !== currentOrg || !isCurrentMember(member) || !canManageCurrentOrg()) return;
+ await changeAccess(
+ (options) => OrgsAPI.removeMember(currentOrg.id, member.userId, options),
+ () => getOrganizationAccessMemberRemovedMessage(member.userId),
+ getOrganizationRemoveMemberErrorMessage,
+ );
};
- onMount(() => {
- if (!isMultiTenantEnabled() || presentationPolicyHidesOrganizationSurfaces()) {
- setLoading(false);
- return;
- }
- void loadOrganizationAccess();
-
- const unsubscribe = eventBus.on('org_switched', () => {
- void loadOrganizationAccess();
- });
- const unsubscribeOrganizationsChanged = eventBus.on('organizations_changed', () => {
+ const unsubscribeOrg = eventBus.on('org_switched', () => void loadOrganizationAccess());
+ const unsubscribeChanged = eventBus.on(
+ 'organizations_changed',
+ () => void loadOrganizationAccess(),
+ );
+ createEffect(
+ on([surfaceEnabled, () => props.currentUser, presentationPolicyIsReadOnly], () => {
void loadOrganizationAccess();
- });
- onCleanup(() => {
- unsubscribe();
- unsubscribeOrganizationsChanged();
- });
+ }),
+ );
+ onCleanup(() => {
+ disposed = true;
+ invalidateRequests();
+ unsubscribeOrg();
+ unsubscribeChanged();
});
return {
acceptInvitation,
canManageCurrentOrg,
+ canChangeAccess,
declineInvitation,
inviteMember,
inviteRole,
inviteUserID,
loading,
+ loadError,
+ loadOrganizationAccess,
members,
myInvitations,
org,
pendingInvitations,
+ readOnly: presentationPolicyIsReadOnly,
removeMember,
revokeInvitation,
saving,
+ selectedOrgID,
setInviteRole,
setInviteUserID,
updateRole,
diff --git a/frontend-modern/src/utils/organizationSettingsPresentation.ts b/frontend-modern/src/utils/organizationSettingsPresentation.ts
index 03c4abeac3..9a70822f12 100644
--- a/frontend-modern/src/utils/organizationSettingsPresentation.ts
+++ b/frontend-modern/src/utils/organizationSettingsPresentation.ts
@@ -4,6 +4,13 @@ import { formatOrgDate } from '@/utils/orgUtils';
export const ORGANIZATION_SETTINGS_UNAVAILABLE_MESSAGE =
'Organization settings are not available on this server.';
export const ORGANIZATION_SETTINGS_UNAVAILABLE_CLASS = 'p-4 text-sm text-slate-500';
+export const ORGANIZATION_ACCESS_UNCONFIRMED_CHANGE_MESSAGE =
+ 'The last access change could not be confirmed. Reload saved access before making another change.';
+export const ORGANIZATION_ACCESS_RELOAD_LABEL = 'Reload access';
+export const ORGANIZATION_ACCESS_UNAVAILABLE_TITLE = 'Organization access unavailable';
+export function getOrganizationAccessReloadMessage(orgId: string): string {
+ return `Reload checks saved members and invitations for ${orgId}. It does not repeat an access change.`;
+}
export type OrganizationSettingsLoadContext =
'access' | 'overview' | 'sharing' | 'billing' | 'billing-admin';
@@ -73,7 +80,8 @@ export function getOrganizationAccessOwnerTransferMemberRequiredMessage(): strin
return 'Ownership can only be transferred to an existing member.';
}
-export function getOrganizationAccessManageRequiredMessage(): string {
+export function getOrganizationAccessManageRequiredMessage(readOnly = false): string {
+ if (readOnly) return 'Organization access is read-only for this session.';
return 'Admin or owner role required to manage organization access.';
}