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 role administration within the current reader

pulse-triage[bot]bd81fce1a778
diff --git a/docs/release-control/v6/internal/subsystems/organization-settings.md b/docs/release-control/v6/internal/subsystems/organization-settings.md
index b995793db4..fe8c33c02a 100644
--- a/docs/release-control/v6/internal/subsystems/organization-settings.md
+++ b/docs/release-control/v6/internal/subsystems/organization-settings.md
@@ -15,6 +15,35 @@
## Purpose
+### Role administration belongs to the current reader
+
+The existing Roles screen binds its accepted role inventory, unsaved permissions,
+editor, deletion confirmation and local action feedback to the selected
+organisation, authenticated principal and explicit Roles capability. Losing any
+of them, losing RBAC or disposing the panel aborts outstanding requests and
+withdraws that state. Returning to the same organisation or role ID does not
+readmit an earlier response. Obsolete successes, refusals and completions cannot
+replace current data, finish a newer loading state, refetch or announce an old
+role name to the next reader.
+
+Reads and writes use the existing API client with an expected organisation,
+cancellation signal and automatic retries disabled. Only accepted, structurally
+valid inventory enables actions. An unread or malformed response is unavailable,
+not an empty role list, and its inline Retry performs only a read. Built-in and
+obsolete row objects remain uneditable. Save and delete are serialised; deletion
+requires the current in-page confirmation, which is withdrawn on context loss.
+A failed save preserves the live draft with fixed inline feedback. Closing an
+editor erases its draft. Success feedback belongs to this panel rather than a
+global identity-bearing notification. Backend authorisation, endpoints and
+permission semantics remain unchanged.
+
+Normal `RolesReaderLifetime`, RBAC API, paywall and registry tests cover
+read/write races, revoked authority, licence loss, disposal, stale row IDs,
+malformed reads, exact request binding and explicit recovery. Browser proof
+exercises actual App/Settings/Role consumers at desktop and narrow widths using
+safe synthetic HTTP producers; it is not installed administrator or IdP recovery.
+
+
### Overview reads and name changes belong to the selected organization
Overview clears its accepted metadata, member list and unsaved name when a
diff --git a/frontend-modern/src/api/__tests__/rbac.test.ts b/frontend-modern/src/api/__tests__/rbac.test.ts
index 59f7db330c..ad37345cbc 100644
--- a/frontend-modern/src/api/__tests__/rbac.test.ts
+++ b/frontend-modern/src/api/__tests__/rbac.test.ts
@@ -213,6 +213,28 @@ describe('RBACAPI', () => {
},
);
});
+ it('binds role writes to the selected organisation without retries', async () => {
+ const controller = new AbortController();
+ const options = { signal: controller.signal, expectedOrgID: 'selected-org', retry: false };
+ const role = {
+ id: 'role/one',
+ name: 'One',
+ description: '',
+ permissions: [],
+ createdAt: '2026-01-01',
+ };
+ await RBACAPI.saveRole(role, options);
+ await RBACAPI.deleteRole(role.id, options);
+ expect(apiFetchJSON).toHaveBeenNthCalledWith(1, '/api/admin/roles/role%2Fone', {
+ ...options,
+ method: 'PUT',
+ body: JSON.stringify(role),
+ });
+ expect(apiFetchJSON).toHaveBeenNthCalledWith(2, '/api/admin/roles/role%2Fone', {
+ ...options,
+ method: 'DELETE',
+ });
+ });
it('forwards an exact abortable organisation and no-retry binding for User Access', async () => {
const controller = new AbortController();
const options = { signal: controller.signal, expectedOrgID: 'selected-org', retry: false };
diff --git a/frontend-modern/src/api/rbac.ts b/frontend-modern/src/api/rbac.ts
index d4a69d599a..ffea1bb1a4 100644
--- a/frontend-modern/src/api/rbac.ts
+++ b/frontend-modern/src/api/rbac.ts
@@ -9,17 +9,18 @@ export const RBACAPI = {
// Roles
getRoles: (options?: RBACAdminRequestOptions) => readRBAC<Role[]>('/api/admin/roles', options),
getRole: (id: string) => apiFetchJSON<Role>(`/api/admin/roles/${encodeURIComponent(id)}`),
- saveRole: (role: Role) => {
+ saveRole: (role: Role, options?: RBACAdminRequestOptions) => {
const method = role.createdAt ? 'PUT' : 'POST';
const url =
method === 'PUT' ? `/api/admin/roles/${encodeURIComponent(role.id)}` : '/api/admin/roles';
return apiFetchJSON<Role>(url, {
+ ...options,
method,
body: JSON.stringify(role),
});
},
- deleteRole: (id: string) =>
- apiFetchJSON(`/api/admin/roles/${encodeURIComponent(id)}`, { method: 'DELETE' }),
+ deleteRole: (id: string, options?: RBACAdminRequestOptions) =>
+ apiFetchJSON(`/api/admin/roles/${encodeURIComponent(id)}`, { ...options, method: 'DELETE' }),
// User Assignments
getUsers: (options?: RBACAdminRequestOptions) =>
diff --git a/frontend-modern/src/components/Settings/RolesEditorDialog.tsx b/frontend-modern/src/components/Settings/RolesEditorDialog.tsx
index d9a0b423aa..ff5b4ec05e 100644
--- a/frontend-modern/src/components/Settings/RolesEditorDialog.tsx
+++ b/frontend-modern/src/components/Settings/RolesEditorDialog.tsx
@@ -1,4 +1,5 @@
import { Component, For, Show } from 'solid-js';
+import { InlineNotice } from '@/components/shared/InlineNotice';
import { Dialog } from '@/components/shared/Dialog';
import { FormSelect } from '@/components/shared/FormSelect';
import type { Permission, Role } from '@/types/rbac';
@@ -8,6 +9,7 @@ import Trash2 from 'lucide-solid/icons/trash-2';
import X from 'lucide-solid/icons/x';
interface RolesEditorDialogProps {
+ actionError?: string | null;
editingRole: Role | null;
formDescription: string;
formId: string;
@@ -42,6 +44,7 @@ export const RolesEditorDialog: Component<RolesEditorDialogProps> = (props) => (
<button
type="button"
onClick={props.onClose}
+ disabled={props.saving}
aria-label="Close role editor"
title="Close"
class="p-1.5 rounded-md text-slate-500 hover:text-base-content hover:bg-surface-hover"
@@ -50,7 +53,10 @@ export const RolesEditorDialog: Component<RolesEditorDialogProps> = (props) => (
</button>
</div>
- <div class="px-4 sm:px-6 py-4 space-y-4 max-h-[70vh] overflow-y-auto">
+ <fieldset
+ disabled={props.saving}
+ class="px-4 sm:px-6 py-4 space-y-4 max-h-[70vh] overflow-y-auto"
+ >
<div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
<div class="space-y-1">
<label for="role-editor-id" class="block text-sm font-medium text-base-content">
@@ -157,12 +163,18 @@ export const RolesEditorDialog: Component<RolesEditorDialogProps> = (props) => (
</For>
</div>
</div>
- </div>
+ </fieldset>
+ <Show when={props.actionError}>
+ <InlineNotice tone="danger" role="alert" aria-live="polite">
+ {props.actionError}
+ </InlineNotice>
+ </Show>
<div class="grid grid-cols-1 sm:flex sm:items-center sm:justify-end gap-3 px-4 sm:px-6 py-4 border-t border-border">
<button
type="button"
onClick={props.onClose}
+ disabled={props.saving}
class="w-full sm:w-auto rounded-md px-4 py-2 text-sm font-medium text-base-content hover:bg-surface-hover"
>
Cancel
diff --git a/frontend-modern/src/components/Settings/RolesPanel.tsx b/frontend-modern/src/components/Settings/RolesPanel.tsx
index c63796477e..741340faa8 100644
--- a/frontend-modern/src/components/Settings/RolesPanel.tsx
+++ b/frontend-modern/src/components/Settings/RolesPanel.tsx
@@ -3,7 +3,8 @@ import { ActionIconButton, Button } from '@/components/shared/Button';
import SettingsPanel from '@/components/shared/SettingsPanel';
import { RBACFeatureGateSection } from './RBACFeatureGateSection';
import { RolesEditorDialog } from './RolesEditorDialog';
-import { useRolesPanelState } from './useRolesPanelState';
+import { useRolesPanelState, type RolesPanelProps } from './useRolesPanelState';
+import { Dialog } from '@/components/shared/Dialog';
import { LoadingSpinner } from '@/components/shared/LoadingSpinner';
import { getRolesEmptyState } from '@/utils/rbacPresentation';
import Plus from 'lucide-solid/icons/plus';
@@ -14,8 +15,8 @@ import { PulseDataGrid } from '@/components/shared/PulseDataGrid';
import { InlineNotice } from '@/components/shared/InlineNotice';
import TriangleAlert from 'lucide-solid/icons/triangle-alert';
-export const RolesPanel: Component = () => {
- const state = useRolesPanelState();
+export const RolesPanel: Component<RolesPanelProps> = (props) => {
+ const state = useRolesPanelState(props);
return (
<div class="space-y-6">
@@ -27,7 +28,7 @@ export const RolesPanel: Component = () => {
size="settingsAction"
class="w-full gap-2 sm:w-auto"
onClick={state.openCreateRole}
- disabled={!state.featureGate.rbacEnabled() || Boolean(state.loadError())}
+ disabled={!state.canEdit()}
>
<Plus class="w-4 h-4" />
New Role
@@ -36,6 +37,14 @@ export const RolesPanel: Component = () => {
noPadding
bodyClass="divide-y divide-border"
>
+ <Show when={state.successNotice()}>
+ {(message) => (
+ <InlineNotice tone="success" role="status" aria-live="polite">
+ {message()}
+ </InlineNotice>
+ )}
+ </Show>
+
<Show when={state.featureGate.paywallVisible()}>
<RBACFeatureGateSection
copy={state.featureGate.featureGateCopy()}
@@ -50,7 +59,13 @@ export const RolesPanel: Component = () => {
</div>
</Show>
- <Show when={!state.loading() && state.featureGate.rbacEnabled() && state.loadError()}>
+ <Show when={!state.loading() && state.featureGate.rbacEnabled() && !state.accessAllowed()}>
+ <InlineNotice tone="warning" role="status">
+ Roles are unavailable for this session.
+ </InlineNotice>
+ </Show>
+
+ <Show when={!state.loading() && state.accessAllowed() && state.loadError()}>
{(message) => (
<InlineNotice
role="alert"
@@ -66,7 +81,7 @@ export const RolesPanel: Component = () => {
)}
</Show>
- <Show when={!state.loading() && state.featureGate.rbacEnabled() && !state.loadError()}>
+ <Show when={!state.loading() && state.accessAllowed() && !state.loadError()}>
<PulseDataGrid
data={state.roles()}
columns={[
@@ -113,6 +128,7 @@ export const RolesPanel: Component = () => {
tone="accent"
size="sm"
class="-my-2 min-h-11 min-w-11 sm:my-0 sm:min-h-0 sm:min-w-0"
+ disabled={!state.canEdit()}
onClick={() => state.openEditRole(role)}
>
<Pencil class="w-4 h-4" />
@@ -122,7 +138,8 @@ export const RolesPanel: Component = () => {
tone="danger"
size="sm"
class="-my-2 min-h-11 min-w-11 sm:my-0 sm:min-h-0 sm:min-w-0"
- onClick={() => state.handleDeleteRole(role)}
+ disabled={!state.canEdit()}
+ onClick={() => state.openDeleteRole(role)}
>
<Trash2 class="w-4 h-4" />
</ActionIconButton>
@@ -143,6 +160,7 @@ export const RolesPanel: Component = () => {
</SettingsPanel>
<RolesEditorDialog
+ actionError={state.actionError()}
editingRole={state.editingRole()}
formDescription={state.formDescription()}
formId={state.formId()}
@@ -159,6 +177,45 @@ export const RolesPanel: Component = () => {
onSave={state.handleSaveRole}
onUpdatePermission={state.updatePermission}
/>
+ <Show when={state.rolePendingDeletion()}>
+ {(role) => (
+ <Dialog
+ isOpen={true}
+ onClose={state.closeDeleteRole}
+ closeOnBackdrop={false}
+ panelClass="max-w-lg"
+ ariaLabel={`Delete role: ${role().name}`}
+ >
+ <div class="space-y-5 p-6">
+ <div>
+ <h3 class="text-lg font-semibold text-base-content">Delete role?</h3>
+ <p class="mt-2 text-sm text-muted">
+ Are you sure you want to delete the role "{role().name}"?
+ </p>
+ </div>
+ <Show when={state.actionError()}>
+ {(message) => (
+ <InlineNotice tone="danger" role="alert" aria-live="polite">
+ {message()}
+ </InlineNotice>
+ )}
+ </Show>
+ <div class="flex flex-col-reverse gap-3 sm:flex-row sm:justify-end">
+ <Button onClick={state.closeDeleteRole} disabled={state.deleting()}>
+ Cancel
+ </Button>
+ <Button
+ variant="danger"
+ isLoading={state.deleting()}
+ onClick={state.handleDeleteRole}
+ >
+ Delete Role
+ </Button>
+ </div>
+ </div>
+ </Dialog>
+ )}
+ </Show>
</div>
);
};
diff --git a/frontend-modern/src/components/Settings/__tests__/RBACPaywallPanels.test.tsx b/frontend-modern/src/components/Settings/__tests__/RBACPaywallPanels.test.tsx
index e8ea4bbce0..f53637d28f 100644
--- a/frontend-modern/src/components/Settings/__tests__/RBACPaywallPanels.test.tsx
+++ b/frontend-modern/src/components/Settings/__tests__/RBACPaywallPanels.test.tsx
@@ -224,7 +224,7 @@ describe('RBAC paywall settings panels', () => {
expect(screen.getByRole('alert')).toHaveTextContent('Failed to load roles');
});
expect(screen.getByRole('button', { name: 'New Role' })).toBeDisabled();
- expect(notificationErrorMock).toHaveBeenCalledWith('Failed to load roles');
+ expect(notificationErrorMock).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole('button', { name: 'Retry' }));
await waitFor(() => {
diff --git a/frontend-modern/src/components/Settings/__tests__/RolesReaderLifetime.test.tsx b/frontend-modern/src/components/Settings/__tests__/RolesReaderLifetime.test.tsx
new file mode 100644
index 0000000000..f5b25c7c15
--- /dev/null
+++ b/frontend-modern/src/components/Settings/__tests__/RolesReaderLifetime.test.tsx
@@ -0,0 +1,361 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';
+import { createSignal } from 'solid-js';
+import { createStore } from 'solid-js/store';
+import { eventBus } from '@/stores/events';
+import { useRolesPanelState } from '../useRolesPanelState';
+import { RolesPanel } from '../RolesPanel';
+import type { Role } from '@/types/rbac';
+
+const mocks = vi.hoisted(() => ({
+ org: 'north',
+ getRoles: vi.fn(),
+ saveRole: vi.fn(),
+ deleteRole: vi.fn(),
+ success: vi.fn(),
+ error: vi.fn(),
+ log: vi.fn(),
+}));
+vi.mock('@/utils/apiClient', () => ({ getOrgID: () => mocks.org }));
+vi.mock('@/api/rbac', () => ({ RBACAPI: mocks }));
+vi.mock('@/stores/notifications', () => ({
+ notificationStore: { success: mocks.success, error: mocks.error },
+}));
+vi.mock('@/utils/logger', () => ({ logger: { error: mocks.log } }));
+let enabled: () => boolean;
+vi.mock('../useRBACFeatureGateState', () => ({
+ useRBACFeatureGateState: () => ({
+ licenseReady: () => true,
+ rbacEnabled: () => enabled(),
+ paywallVisible: () => false,
+ }),
+}));
+const north: Role = {
+ id: 'custom/reader',
+ name: 'North private role',
+ description: 'North private description',
+ permissions: [{ action: 'read', resource: 'north-private' }],
+ createdAt: '2026-01-01',
+};
+const south: Role = {
+ ...north,
+ name: 'South role',
+ description: 'South description',
+ permissions: [],
+};
+const pause = () => new Promise((resolve) => setTimeout(resolve, 0));
+function deferred<T>() {
+ let resolve!: (value: T) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<T>((res, rej) => {
+ resolve = res;
+ reject = rej;
+ });
+ return { resolve, reject, promise };
+}
+function mount() {
+ const [user, setUser] = createSignal<string | undefined>('reader-a');
+ const [allowed, setAllowed] = createSignal(true);
+ let state!: ReturnType<typeof useRolesPanelState>;
+ const view = render(() => {
+ state = useRolesPanelState({
+ get currentUser() {
+ return user();
+ },
+ get canManage() {
+ return allowed();
+ },
+ });
+ return <div />;
+ });
+ return { state, setUser, setAllowed, view };
+}
+const loaded = (state: ReturnType<typeof useRolesPanelState>) =>
+ waitFor(() => expect(state.loading()).toBe(false));
+function switchOrg(org = 'south') {
+ mocks.org = org;
+ eventBus.emit('org_switched', org);
+}
+
+describe('Roles reader lifetime', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ enabled = () => true;
+ mocks.org = 'north';
+ mocks.getRoles.mockReset().mockResolvedValue([north]);
+ mocks.saveRole.mockReset().mockResolvedValue(undefined);
+ mocks.deleteRole.mockReset().mockResolvedValue(undefined);
+ });
+ afterEach(cleanup);
+
+ it('withdraws roles, editor and draft on an organisation switch, even for the same role ID', async () => {
+ const { state } = mount();
+ await loaded(state);
+ state.openEditRole(north);
+ state.setFormName('Unsaved private draft');
+ const next = deferred<Role[]>();
+ mocks.getRoles.mockReturnValueOnce(next.promise);
+ switchOrg();
+ expect(state.roles()).toEqual([]);
+ expect(state.showModal()).toBe(false);
+ expect(state.editingRole()).toBeNull();
+ expect(state.formName()).toBe('');
+ expect(state.formPermissions()).toEqual([]);
+ expect(state.loading()).toBe(true);
+ expect(state.canEdit()).toBe(false);
+ next.resolve([south]);
+ await loaded(state);
+ state.openEditRole(north);
+ expect(state.showModal()).toBe(false);
+ state.openEditRole(south);
+ expect(state.formName()).toBe('South role');
+ });
+
+ it.each(['success', 'failure'] as const)(
+ 'ignores an obsolete %s after switching away and back',
+ async (outcome) => {
+ const old = deferred<Role[]>();
+ mocks.getRoles.mockReturnValueOnce(old.promise);
+ const { state } = mount();
+ await pause();
+ const options = mocks.getRoles.mock.calls[0][0];
+ switchOrg();
+ await loaded(state);
+ switchOrg('north');
+ await loaded(state);
+ if (outcome === 'success') old.resolve([south]);
+ else old.reject(new Error('PRIVATE OBSOLETE RESPONSE'));
+ await pause();
+ expect(options.signal.aborted).toBe(true);
+ expect(state.roles()).toEqual([north]);
+ expect(state.loadError()).toBeNull();
+ expect(mocks.log).not.toHaveBeenCalled();
+ expect(mocks.error).not.toHaveBeenCalled();
+ },
+ );
+
+ it('does not let an old completion finish a newer loading state', async () => {
+ const old = deferred<Role[]>(),
+ current = deferred<Role[]>();
+ mocks.getRoles.mockReturnValueOnce(old.promise).mockReturnValueOnce(current.promise);
+ const { state } = mount();
+ await pause();
+ switchOrg();
+ old.resolve([north]);
+ await pause();
+ expect(state.loading()).toBe(true);
+ expect(state.roles()).toEqual([]);
+ current.resolve([south]);
+ await loaded(state);
+ expect(state.roles()).toEqual([south]);
+ });
+
+ it.each(['authority', 'license', 'principal'] as const)(
+ 'withdraws confirmation and refuses stale actions on %s change',
+ async (kind) => {
+ const [feature, setFeature] = createSignal(true);
+ enabled = feature;
+ const { state, setUser, setAllowed } = mount();
+ await loaded(state);
+ state.openDeleteRole(north);
+ expect(state.rolePendingDeletion()).toBe(north);
+ if (kind === 'authority') setAllowed(false);
+ if (kind === 'license') setFeature(false);
+ if (kind === 'principal') setUser('reader-b');
+ await state.handleDeleteRole();
+ await state.handleSaveRole();
+ expect(state.rolePendingDeletion()).toBeNull();
+ expect(state.showModal()).toBe(false);
+ expect(mocks.deleteRole).not.toHaveBeenCalled();
+ expect(mocks.saveRole).not.toHaveBeenCalled();
+ if (kind !== 'principal') {
+ expect(state.roles()).toEqual([]);
+ expect(state.loading()).toBe(false);
+ }
+ },
+ );
+
+ it.each(['save', 'delete'] as const)(
+ 'ignores old %s feedback and refresh after a principal changes',
+ async (kind) => {
+ const old = deferred<void>();
+ const write = kind === 'save' ? mocks.saveRole : mocks.deleteRole;
+ write.mockReturnValueOnce(old.promise);
+ const { state, setUser } = mount();
+ await loaded(state);
+ state.openEditRole(north);
+ if (kind === 'delete') state.openDeleteRole(north);
+ const pending = kind === 'save' ? state.handleSaveRole() : state.handleDeleteRole();
+ expect(write).toHaveBeenCalledTimes(1);
+ const options = write.mock.calls[0][1];
+ setUser('reader-b');
+ await loaded(state);
+ const reads = mocks.getRoles.mock.calls.length;
+ old.resolve();
+ await pending;
+ expect(options.signal.aborted).toBe(true);
+ expect(options.expectedOrgID).toBe('north');
+ expect(options.retry).toBe(false);
+ expect(state.successNotice()).toBeNull();
+ expect(state.actionError()).toBeNull();
+ expect(mocks.getRoles).toHaveBeenCalledTimes(reads);
+ expect(mocks.success).not.toHaveBeenCalled();
+ },
+ );
+
+ it('keeps a denied save and draft local, serialises writes and permits only explicit retry', async () => {
+ const old = deferred<void>();
+ mocks.saveRole.mockReturnValueOnce(old.promise);
+ const { state } = mount();
+ await loaded(state);
+ state.openEditRole(north);
+ state.setFormName('Changed role');
+ const pending = state.handleSaveRole();
+ await state.handleSaveRole();
+ state.closeModal();
+ state.openDeleteRole(north);
+ expect(state.showModal()).toBe(true);
+ expect(state.rolePendingDeletion()).toBeNull();
+ expect(mocks.saveRole).toHaveBeenCalledTimes(1);
+ old.reject(new Error('PRIVATE WRITE DETAIL'));
+ await pending;
+ expect(state.formName()).toBe('Changed role');
+ expect(state.actionError()).toBe('Failed to save role');
+ expect(mocks.error).not.toHaveBeenCalled();
+ await state.handleSaveRole();
+ expect(mocks.saveRole).toHaveBeenCalledTimes(2);
+ expect(mocks.saveRole.mock.calls[1][0]).toEqual(mocks.saveRole.mock.calls[0][0]);
+ expect(state.showModal()).toBe(false);
+ expect(state.formName()).toBe('');
+ expect(state.successNotice()).toBe('Role "Changed role" saved');
+ switchOrg();
+ expect(state.successNotice()).toBeNull();
+ });
+
+ it('keeps delete failure in the live confirmation and never retries it on a read', async () => {
+ mocks.deleteRole.mockRejectedValueOnce(new Error('PRIVATE DELETE DETAIL'));
+ const { state } = mount();
+ await loaded(state);
+ state.openDeleteRole(north);
+ await state.handleDeleteRole();
+ expect(state.actionError()).toBe('Failed to delete role');
+ expect(state.rolePendingDeletion()).toBe(north);
+ state.closeDeleteRole();
+ await state.loadRoles();
+ expect(mocks.deleteRole).toHaveBeenCalledTimes(1);
+ expect(state.actionError()).toBeNull();
+ expect(mocks.error).not.toHaveBeenCalled();
+ });
+
+ it('requires accepted inventory and protects built-ins and stale row identities', async () => {
+ const pending = deferred<Role[]>();
+ mocks.getRoles.mockReturnValueOnce(pending.promise);
+ const { state } = mount();
+ state.openCreateRole();
+ state.openEditRole(north);
+ expect(state.showModal()).toBe(false);
+ const builtIn = { ...north, isBuiltIn: true };
+ pending.resolve([builtIn]);
+ await loaded(state);
+ state.openEditRole(builtIn);
+ state.openDeleteRole(builtIn);
+ state.openEditRole({ ...builtIn, isBuiltIn: false });
+ expect(state.showModal()).toBe(false);
+ expect(state.rolePendingDeletion()).toBeNull();
+ await state.handleSaveRole();
+ await state.handleDeleteRole();
+ expect(mocks.saveRole).not.toHaveBeenCalled();
+ expect(mocks.deleteRole).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ null,
+ {},
+ [null],
+ [{ ...north, permissions: null }],
+ [{ ...north, permissions: [{}] }],
+ [north, north],
+ ])('treats malformed inventory as unknown, not an empty directory: %j', async (value) => {
+ mocks.getRoles.mockResolvedValueOnce(value);
+ const { state } = mount();
+ await loaded(state);
+ expect(state.roles()).toEqual([]);
+ expect(state.loadError()).toBe('Failed to load roles');
+ expect(state.canEdit()).toBe(false);
+ await state.loadRoles();
+ expect(state.roles()).toEqual([north]);
+ expect(state.canEdit()).toBe(true);
+ expect(mocks.saveRole).not.toHaveBeenCalled();
+ });
+
+ it('accepts empty permission lists and future permission strings without changing them', async () => {
+ const role = { ...north, permissions: [{ action: 'future:read', resource: 'future/*' }] };
+ mocks.getRoles.mockResolvedValueOnce([role]);
+ const { state } = mount();
+ await loaded(state);
+ state.openEditRole(role);
+ await state.handleSaveRole();
+ expect(mocks.saveRole.mock.calls[0][0].permissions).toEqual(role.permissions);
+ mocks.getRoles.mockResolvedValueOnce([]);
+ await state.loadRoles();
+ expect(state.loadError()).toBeNull();
+ expect(state.canEdit()).toBe(true);
+ });
+
+ it('accepts reactive current rows without allowing draft changes to mutate their permissions', async () => {
+ const [role] = createStore(north);
+ mocks.getRoles.mockResolvedValueOnce([role]);
+ const { state } = mount();
+ await loaded(state);
+ state.openEditRole(role);
+ state.updatePermission(0, 'action', 'write');
+ expect(north.permissions[0].action).toBe('read');
+ expect(state.formPermissions()[0].action).toBe('write');
+ state.closeModal();
+ expect(state.formPermissions()).toEqual([]);
+ });
+
+ it('aborts pending reads and writes and unsubscribes on disposal without feedback', async () => {
+ const pending = deferred<void>();
+ mocks.saveRole.mockReturnValueOnce(pending.promise);
+ const { state, view } = mount();
+ await loaded(state);
+ state.openEditRole(north);
+ const writing = state.handleSaveRole();
+ const options = mocks.saveRole.mock.calls[0][1];
+ const reads = mocks.getRoles.mock.calls.length;
+ view.unmount();
+ switchOrg();
+ pending.reject(new Error('obsolete write'));
+ await writing;
+ expect(options.signal.aborted).toBe(true);
+ expect(state.formName()).toBe('');
+ expect(mocks.getRoles).toHaveBeenCalledTimes(reads);
+ expect(mocks.error).not.toHaveBeenCalled();
+ });
+
+ it('shows inline draft errors and a cancellable, withdrawable confirmation in the consuming panel', async () => {
+ const [allowed, setAllowed] = createSignal(true);
+ mocks.saveRole.mockRejectedValueOnce(new Error('PRIVATE DETAIL'));
+ render(() => <RolesPanel currentUser="reader-a" canManage={allowed()} />);
+ fireEvent.click(await screen.findByRole('button', { name: 'Edit role' }));
+ let dialog = await screen.findByRole('dialog', { name: 'Edit role' });
+ fireEvent.input(within(dialog).getByLabelText('Role Name'), {
+ target: { value: 'Private draft' },
+ });
+ fireEvent.click(within(dialog).getByRole('button', { name: 'Update Role' }));
+ expect(await within(dialog).findByRole('alert')).toHaveTextContent('Failed to save role');
+ expect(within(dialog).getByLabelText('Role Name')).toHaveValue('Private draft');
+ fireEvent.click(within(dialog).getByRole('button', { name: 'Cancel' }));
+ fireEvent.click(screen.getByRole('button', { name: 'Delete role' }));
+ dialog = await screen.findByRole('dialog', { name: 'Delete role: North private role' });
+ fireEvent.click(within(dialog).getByRole('button', { name: 'Cancel' }));
+ expect(mocks.deleteRole).not.toHaveBeenCalled();
+ fireEvent.click(screen.getByRole('button', { name: 'Delete role' }));
+ setAllowed(false);
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+ expect(screen.queryByText('North private role')).not.toBeInTheDocument();
+ expect(screen.getByRole('status')).toHaveTextContent('Roles are unavailable for this session.');
+ expect(screen.getByRole('button', { name: 'New Role' })).toBeDisabled();
+ });
+});
diff --git a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
index 0e373d075d..6d908ba556 100644
--- a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
@@ -2285,6 +2285,7 @@ describe('User Access reader projection', () => {
it('supplies live reader props through the canonical registry instead of an unscoped mount', async () => {
const { default: registry } = await import('../settingsPanelRegistry.ts?raw');
const { default: context } = await import('../settingsPanelRegistryContext.tsx?raw');
+ expect(registry).toMatch(/'security-roles':\s*\{[^}]*getProps: context.getRolesPanelProps/s);
expect(registry).toMatch(
/'security-users':\s*\{[^}]*getProps: context.getUserAssignmentsPanelProps/s,
);
diff --git a/frontend-modern/src/components/Settings/__tests__/settingsPanelRegistryContext.test.ts b/frontend-modern/src/components/Settings/__tests__/settingsPanelRegistryContext.test.ts
index 703bbe2a3e..0c835f802c 100644
--- a/frontend-modern/src/components/Settings/__tests__/settingsPanelRegistryContext.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/settingsPanelRegistryContext.test.ts
@@ -53,6 +53,7 @@ describe('buildSettingsPanelRegistryContext', () => {
expect(context.getOrganizationOverviewPanelProps().currentUser).toBe('org-owner');
expect(context.getApiAccessPanelProps().currentUser).toBe('org-owner');
expect(context.getUserAssignmentsPanelProps().currentUser).toBe('org-owner');
+ expect(context.getRolesPanelProps().currentUser).toBe('org-owner');
});
it('does not replace an explicitly empty principal with the configured admin', () => {
@@ -149,6 +150,24 @@ describe('buildSettingsPanelRegistryContext', () => {
expect(context.getOrganizationSharingPanelProps()).toMatchObject({ currentUser: undefined });
expect(context.getApiAccessPanelProps()).toMatchObject({ currentUser: undefined });
});
+ it('binds Roles to the live principal and explicit roles capability', () => {
+ const [status, setStatus] = createSignal<SecurityStatus | null>(null);
+ const context = buildSettingsPanelRegistryContext({
+ ...buildParams(null),
+ securityStatus: status,
+ });
+ expect(context.getRolesPanelProps()).toEqual({ currentUser: undefined, canManage: false });
+ setStatus({
+ currentUsername: 'role-reader',
+ settingsCapabilities: { roles: true, users: false },
+ } as SecurityStatus);
+ expect(context.getRolesPanelProps()).toEqual({ currentUser: 'role-reader', canManage: true });
+ setStatus({
+ currentUsername: 'other-reader',
+ settingsCapabilities: { roles: false, users: true },
+ } as SecurityStatus);
+ expect(context.getRolesPanelProps()).toEqual({ currentUser: 'other-reader', canManage: false });
+ });
it('binds User Access to the live principal and explicit users capability', () => {
const [status, setStatus] = createSignal<SecurityStatus | null>(null);
const context = buildSettingsPanelRegistryContext({
diff --git a/frontend-modern/src/components/Settings/settingsPanelRegistry.ts b/frontend-modern/src/components/Settings/settingsPanelRegistry.ts
index b695b7b189..28dc86812c 100644
--- a/frontend-modern/src/components/Settings/settingsPanelRegistry.ts
+++ b/frontend-modern/src/components/Settings/settingsPanelRegistry.ts
@@ -11,6 +11,7 @@ import type { SecurityOverviewPanel as SecurityOverviewPanelType } from './Secur
import type { SecurityAuthPanel as SecurityAuthPanelType } from './SecurityAuthPanel';
import type { RelaySettingsPanel as RelaySettingsPanelType } from './RelaySettingsPanel';
import type { AuditWebhookPanel as AuditWebhookPanelType } from './AuditWebhookPanel';
+import type { RolesPanel as RolesPanelType } from './RolesPanel';
import type { UserAssignmentsPanel as UserAssignmentsPanelType } from './UserAssignmentsPanel';
import type { InfrastructureWorkspace as InfrastructureWorkspaceType } from './InfrastructureWorkspace';
import type { SettingsTab } from './settingsNavigationModel';
@@ -45,6 +46,7 @@ export interface SettingsPanelRegistryContext {
getSecurityAuthPanelProps: () => Parameters<typeof SecurityAuthPanelType>[0];
getRelayPanelProps: () => Parameters<typeof RelaySettingsPanelType>[0];
getAuditWebhookPanelProps: () => Parameters<typeof AuditWebhookPanelType>[0];
+ getRolesPanelProps: () => Parameters<typeof RolesPanelType>[0];
getUserAssignmentsPanelProps: () => Parameters<typeof UserAssignmentsPanelType>[0];
}
@@ -137,6 +139,7 @@ export const createSettingsPanelRegistry = (
},
'security-roles': {
component: SETTINGS_PANEL_REGISTRY_LOADERS.RolesPanel,
+ getProps: context.getRolesPanelProps,
},
'security-users': {
component: SETTINGS_PANEL_REGISTRY_LOADERS.UserAssignmentsPanel,
diff --git a/frontend-modern/src/components/Settings/settingsPanelRegistryContext.tsx b/frontend-modern/src/components/Settings/settingsPanelRegistryContext.tsx
index 7c832cd89a..6324a08f1b 100644
--- a/frontend-modern/src/components/Settings/settingsPanelRegistryContext.tsx
+++ b/frontend-modern/src/components/Settings/settingsPanelRegistryContext.tsx
@@ -127,6 +127,10 @@ export function buildSettingsPanelRegistryContext(
getAuditWebhookPanelProps: () => ({
canManage: settingsCapabilities()?.auditWebhooksWrite === true,
}),
+ getRolesPanelProps: () => ({
+ currentUser: currentUser(),
+ canManage: settingsCapabilities()?.roles === true,
+ }),
getUserAssignmentsPanelProps: () => ({
currentUser: currentUser(),
canManage: settingsCapabilities()?.users === true,
diff --git a/frontend-modern/src/components/Settings/useRolesPanelState.ts b/frontend-modern/src/components/Settings/useRolesPanelState.ts
index 3e92fac5db..3fff8e3ed4 100644
--- a/frontend-modern/src/components/Settings/useRolesPanelState.ts
+++ b/frontend-modern/src/components/Settings/useRolesPanelState.ts
@@ -1,8 +1,9 @@
-import { createEffect, createSignal } from 'solid-js';
+import { batch, createEffect, createSignal, on, onCleanup } from 'solid-js';
+import { unwrap } from 'solid-js/store';
import { RBACAPI } from '@/api/rbac';
+import { getOrgID } from '@/utils/apiClient';
+import { eventBus } from '@/stores/events';
import type { Permission, Role } from '@/types/rbac';
-import { notificationStore } from '@/stores/notifications';
-import { logger } from '@/utils/logger';
import { createDefaultRBACPermission } from '@/utils/rbacPermissions';
import {
getRolesDeleteErrorMessage,
@@ -12,151 +13,285 @@ import {
} from '@/utils/rbacPresentation';
import { useRBACFeatureGateState } from './useRBACFeatureGateState';
-export function useRolesPanelState() {
+export interface RolesPanelProps {
+ currentUser?: string;
+ canManage?: boolean;
+}
+
+export function useRolesPanelState(props: RolesPanelProps = {}) {
const [roles, setRoles] = createSignal<Role[]>([]);
const [loading, setLoading] = createSignal(true);
const [showModal, setShowModal] = createSignal(false);
const [editingRole, setEditingRole] = createSignal<Role | null>(null);
const [saving, setSaving] = createSignal(false);
+ const [deleting, setDeleting] = createSignal(false);
+ const [rolePendingDeletion, setRolePendingDeletion] = createSignal<Role | null>(null);
const [formId, setFormId] = createSignal('');
const [formName, setFormName] = createSignal('');
const [formDescription, setFormDescription] = createSignal('');
const [formPermissions, setFormPermissions] = createSignal<Permission[]>([]);
const [loadError, setLoadError] = createSignal<string | null>(null);
+ const [actionError, setActionError] = createSignal<string | null>(null);
+ const [successNotice, setSuccessNotice] = createSignal<string | null>(null);
+ const [inventoryLoaded, setInventoryLoaded] = createSignal(false);
const featureGate = useRBACFeatureGateState({
kind: 'roles',
loading,
paywallLocation: 'settings_roles_panel',
});
+ const accessAllowed = () => featureGate.rbacEnabled() && props.canManage !== false;
+ const currentOrg = () => getOrgID() || 'default';
+ let context = { org: currentOrg(), user: props.currentUser, allowed: accessAllowed() };
+ let disposed = false;
+ let readController: AbortController | undefined;
+ let mutationController: AbortController | undefined;
+ const contextIsCurrent = () =>
+ !disposed &&
+ context.org === currentOrg() &&
+ context.user === props.currentUser &&
+ context.allowed === accessAllowed();
+ const canEdit = () =>
+ contextIsCurrent() &&
+ accessAllowed() &&
+ inventoryLoaded() &&
+ !loading() &&
+ !loadError() &&
+ !saving() &&
+ !deleting();
+ const isCurrentRole = (role: Role) => roles().some((current) => unwrap(current) === unwrap(role));
+ const requestOptions = (controller: AbortController) => ({
+ signal: controller.signal,
+ expectedOrgID: context.org,
+ retry: false,
+ });
+
+ const clearEditor = () => {
+ setShowModal(false);
+ setEditingRole(null);
+ setFormId('');
+ setFormName('');
+ setFormDescription('');
+ setFormPermissions([]);
+ setActionError(null);
+ };
+ const closeModal = () => {
+ if (!saving()) batch(clearEditor);
+ };
+ const closeDeleteRole = () => {
+ if (deleting()) return;
+ setRolePendingDeletion(null);
+ setActionError(null);
+ };
const loadRoles = async () => {
- if (!featureGate.rbacEnabled()) {
+ if (!contextIsCurrent() || !accessAllowed() || readController || mutationController) return;
+ const reader = context;
+ const controller = new AbortController();
+ readController = controller;
+ const isCurrentRead = () =>
+ contextIsCurrent() && reader === context && readController === controller;
+ batch(() => {
+ clearEditor();
+ setRolePendingDeletion(null);
setRoles([]);
+ setInventoryLoaded(false);
+ setLoading(true);
setLoadError(null);
- setLoading(false);
- return;
- }
-
- setLoading(true);
- setLoadError(null);
+ });
try {
- const data = await RBACAPI.getRoles();
- setRoles(data || []);
- } catch (err) {
- if (err instanceof Error && /feature not included in license/i.test(err.message)) {
- setRoles([]);
- setLoadError(null);
- return;
- }
- setRoles([]);
- setLoadError(getRolesLoadErrorMessage());
- logger.error('Failed to load roles', err);
- notificationStore.error(getRolesLoadErrorMessage());
+ const data = await RBACAPI.getRoles(requestOptions(controller));
+ if (!isCurrentRead()) return;
+ const ids = new Set<string>();
+ if (
+ !Array.isArray(data) ||
+ data.some((role) => {
+ if (
+ !role ||
+ typeof role.id !== 'string' ||
+ !role.id.trim() ||
+ ids.has(role.id) ||
+ typeof role.name !== 'string' ||
+ typeof role.description !== 'string' ||
+ (role.isBuiltIn !== undefined && typeof role.isBuiltIn !== 'boolean') ||
+ !Array.isArray(role.permissions) ||
+ role.permissions.some(
+ (permission) =>
+ !permission ||
+ typeof permission.action !== 'string' ||
+ !permission.action.trim() ||
+ typeof permission.resource !== 'string' ||
+ !permission.resource.trim(),
+ )
+ )
+ return true;
+ ids.add(role.id);
+ return false;
+ })
+ )
+ throw new Error('Invalid role inventory');
+ batch(() => {
+ setRoles(data);
+ setInventoryLoaded(true);
+ });
+ } catch {
+ if (isCurrentRead()) setLoadError(getRolesLoadErrorMessage());
} finally {
- setLoading(false);
+ if (isCurrentRead()) {
+ readController = undefined;
+ setLoading(false);
+ }
}
};
- createEffect(() => {
- if (!featureGate.licenseReady()) {
- setLoading(true);
- return;
- }
- if (!featureGate.rbacEnabled()) {
+ const resetContext = () => {
+ readController?.abort();
+ mutationController?.abort();
+ readController = mutationController = undefined;
+ // A new object also invalidates operations when returning to the same reader.
+ context = { org: currentOrg(), user: props.currentUser, allowed: accessAllowed() };
+ batch(() => {
+ clearEditor();
setRoles([]);
+ setRolePendingDeletion(null);
+ setInventoryLoaded(false);
+ setSuccessNotice(null);
setLoadError(null);
- setLoading(false);
- return;
- }
- void loadRoles();
- });
-
- const closeModal = () => {
- setShowModal(false);
+ setSaving(false);
+ setDeleting(false);
+ setLoading(!featureGate.licenseReady() || accessAllowed());
+ });
+ if (!disposed) void loadRoles();
};
+ createEffect(
+ on([featureGate.licenseReady, accessAllowed, () => props.currentUser], resetContext),
+ );
+ const unsubscribeOrg = eventBus.on('org_switched', resetContext);
+ onCleanup(() => {
+ disposed = true;
+ unsubscribeOrg();
+ resetContext();
+ });
const openCreateRole = () => {
- setEditingRole(null);
- setFormId('');
- setFormName('');
- setFormDescription('');
- setFormPermissions([createDefaultRBACPermission()]);
- setShowModal(true);
+ if (!canEdit()) return;
+ batch(() => {
+ clearEditor();
+ setRolePendingDeletion(null);
+ setSuccessNotice(null);
+ setFormPermissions([createDefaultRBACPermission()]);
+ setShowModal(true);
+ });
};
-
const openEditRole = (role: Role) => {
- if (role.isBuiltIn) return;
- setEditingRole(role);
- setFormId(role.id);
- setFormName(role.name);
- setFormDescription(role.description);
- setFormPermissions([...role.permissions]);
- setShowModal(true);
+ if (!canEdit() || !isCurrentRole(role) || role.isBuiltIn) return;
+ batch(() => {
+ clearEditor();
+ setRolePendingDeletion(null);
+ setSuccessNotice(null);
+ setEditingRole(role);
+ setFormId(role.id);
+ setFormName(role.name);
+ setFormDescription(role.description);
+ setFormPermissions(role.permissions.map((permission) => ({ ...permission })));
+ setShowModal(true);
+ });
+ };
+ const openDeleteRole = (role: Role) => {
+ if (!canEdit() || !isCurrentRole(role) || role.isBuiltIn) return;
+ batch(() => {
+ clearEditor();
+ setSuccessNotice(null);
+ setRolePendingDeletion(role);
+ });
};
- const handleDeleteRole = async (role: Role) => {
- if (role.isBuiltIn) return;
- if (!confirm(`Are you sure you want to delete the role "${role.name}"?`)) return;
-
+ const mutateRole = async (role: Role, remove: boolean) => {
+ const reader = context;
+ const controller = new AbortController();
+ mutationController = controller;
+ const isCurrentWrite = () =>
+ contextIsCurrent() && reader === context && mutationController === controller;
+ batch(() => {
+ setSaving(!remove);
+ setDeleting(remove);
+ setActionError(null);
+ setSuccessNotice(null);
+ });
+ let saved = false;
try {
- await RBACAPI.deleteRole(role.id);
- notificationStore.success(`Role "${role.name}" deleted`);
- await loadRoles();
- } catch (err) {
- logger.error('Failed to delete role', err);
- notificationStore.error(getRolesDeleteErrorMessage());
+ if (remove) await RBACAPI.deleteRole(role.id, requestOptions(controller));
+ else await RBACAPI.saveRole(role, requestOptions(controller));
+ if (!isCurrentWrite()) return;
+ batch(() => {
+ clearEditor();
+ setRolePendingDeletion(null);
+ setSuccessNotice(`Role "${role.name}" ${remove ? 'deleted' : 'saved'}`);
+ });
+ saved = true;
+ } catch {
+ if (isCurrentWrite())
+ setActionError(remove ? getRolesDeleteErrorMessage() : getRolesSaveErrorMessage());
+ } finally {
+ if (isCurrentWrite()) {
+ mutationController = undefined;
+ setSaving(false);
+ setDeleting(false);
+ }
}
+ if (saved && contextIsCurrent() && reader === context) await loadRoles();
+ };
+ const handleDeleteRole = async () => {
+ const role = rolePendingDeletion();
+ if (!canEdit() || !role || !isCurrentRole(role) || role.isBuiltIn) return;
+ await mutateRole(role, true);
};
-
const handleSaveRole = async () => {
- const id = formId().trim().toLowerCase().replace(/\s+/g, '-');
+ if (!canEdit() || !showModal()) return;
+ const existing = editingRole();
+ if (existing && (!isCurrentRole(existing) || existing.isBuiltIn)) return;
+ const id = existing?.id ?? formId().trim().toLowerCase().replace(/\s+/g, '-');
const name = formName().trim();
if (!id || !name) {
- notificationStore.error(getRolesRequiredFieldsMessage());
+ setActionError(getRolesRequiredFieldsMessage());
return;
}
-
- setSaving(true);
- try {
- const role: Role = {
+ await mutateRole(
+ {
id,
name,
description: formDescription(),
- permissions: formPermissions(),
- createdAt: editingRole()?.createdAt,
- };
- await RBACAPI.saveRole(role);
- notificationStore.success(`Role "${name}" saved`);
- closeModal();
- await loadRoles();
- } catch (err) {
- logger.error('Failed to save role', err);
- notificationStore.error(getRolesSaveErrorMessage());
- } finally {
- setSaving(false);
- }
+ permissions: formPermissions().map((permission) => ({ ...permission })),
+ createdAt: existing?.createdAt,
+ },
+ false,
+ );
};
-
const addPermission = () => {
- setFormPermissions([...formPermissions(), createDefaultRBACPermission()]);
+ if (canEdit() && showModal())
+ setFormPermissions([...formPermissions(), createDefaultRBACPermission()]);
};
-
const removePermission = (index: number) => {
- const nextPermissions = [...formPermissions()];
- nextPermissions.splice(index, 1);
- setFormPermissions(nextPermissions);
+ if (canEdit() && showModal())
+ setFormPermissions(formPermissions().filter((_, current) => current !== index));
};
-
const updatePermission = (index: number, field: keyof Permission, value: string) => {
- const nextPermissions = [...formPermissions()];
- nextPermissions[index] = { ...nextPermissions[index], [field]: value };
- setFormPermissions(nextPermissions);
+ if (canEdit() && showModal())
+ setFormPermissions(
+ formPermissions().map((permission, current) =>
+ current === index ? { ...permission, [field]: value } : permission,
+ ),
+ );
};
return {
+ accessAllowed,
+ actionError,
addPermission,
+ canEdit,
+ closeDeleteRole,
closeModal,
+ deleting,
editingRole,
featureGate,
formDescription,
@@ -169,14 +304,17 @@ export function useRolesPanelState() {
loadError,
loadRoles,
openCreateRole,
+ openDeleteRole,
openEditRole,
removePermission,
+ rolePendingDeletion,
roles,
saving,
setFormDescription,
setFormId,
setFormName,
showModal,
+ successNotice,
updatePermission,
};
}