@jini-ai/user-management 0.2.0

package/dist/admin/controllers/members.controller.js

@@ -0,0 +1,119 @@
+import { hasAdminGrant, describePeopleError } from '../people.rules.js';
+import { createControllerStore } from './controller-store.js';
+const emptyRow = Object.freeze({ disabling: false, resending: false, error: null, notice: null });
+/** Separate list and detail generations prevent stale errors/spinners from painting onto a
+ * different row, including collapse/reopen of the same row. Refresh invalidates cached detail. */
+export function createMembersController({ api }, { permissions = [], refresh } = {}) {
+    const grants = Object.freeze([...permissions]);
+    const store = createControllerStore({ initial: { members: null, error: null, rows: {}, expandedId: null, detailById: {}, detailError: null, detailLoadingId: null, pending: null, confirming: false } });
+    const read = store.getSnapshot, call = store.call, set = (patch) => store.set({ patch });
+    let listGeneration = 0, detailGeneration = 0;
+    const report = (error, fallback) => describePeopleError({ error, fallback });
+    const row = (id) => read({}).members?.find(m => m.id === id);
+    function stateFor({ id }, _optional = {}) { return read({}).rows[id] ?? emptyRow; }
+    function patchRow(id, patch) { set({ rows: Object.freeze({ ...read({}).rows, [id]: Object.freeze({ ...stateFor({ id }), ...patch }) }) }); }
+    const gate = () => store.active({}) && hasAdminGrant({ permissions: grants, permission: 'member.manage' });
+    async function loadDetail(id) {
+        const generation = ++detailGeneration;
+        set({ detailLoadingId: id, detailError: null });
+        try {
+            const { member } = await api.getMember({ id }, call);
+            if (generation === detailGeneration && read({}).expandedId === id)
+                set({ detailById: Object.freeze({ ...read({}).detailById, [id]: Object.freeze({ ...member }) }) });
+        }
+        catch (error) {
+            if (generation === detailGeneration && read({}).expandedId === id)
+                set({ detailError: report(error, 'Failed to load member detail.') });
+        }
+        finally {
+            if (generation === detailGeneration)
+                set({ detailLoadingId: null });
+        }
+    }
+    async function load(_required, _optional = {}) {
+        if (!store.active({}))
+            return;
+        const generation = ++listGeneration;
+        set({ error: null });
+        try {
+            const { members } = await api.listMembers({}, call);
+            if (generation !== listGeneration || !store.active({}))
+                return;
+            ++detailGeneration;
+            set({ members: Object.freeze(members.map(m => Object.freeze({ ...m }))), detailById: {}, detailError: null, detailLoadingId: null });
+            const id = read({}).expandedId;
+            if (id && row(id))
+                await loadDetail(id);
+            else if (id)
+                set({ expandedId: null });
+        }
+        catch (error) {
+            if (generation === listGeneration)
+                set({ error: report(error, 'failed to load members') });
+        }
+    }
+    async function toggleDetail({ id }, _optional = {}) {
+        if (!store.active({}) || !row(id))
+            return;
+        ++detailGeneration;
+        const next = read({}).expandedId === id ? null : id;
+        set({ expandedId: next, detailError: null, detailLoadingId: null });
+        if (next && !read({}).detailById[next])
+            await loadDetail(next);
+    }
+    async function resendSignInLink({ id }, _optional = {}) {
+        const member = row(id);
+        if (!member || !gate() || stateFor({ id }).resending)
+            return false;
+        patchRow(id, { resending: true, error: null, notice: null });
+        try {
+            await api.requestMemberMagicLink({ email: member.email }, call);
+            patchRow(id, { notice: 'Sign-in link sent.' });
+            return store.active({});
+        }
+        catch (error) {
+            patchRow(id, { error: report(error, 'Failed to send sign-in link.') });
+            return false;
+        }
+        finally {
+            patchRow(id, { resending: false });
+        }
+    }
+    async function confirmDestructive(_required, _optional = {}) {
+        const target = read({}).pending;
+        if (!target || !gate() || read({}).confirming || !row(target.id))
+            return false;
+        set({ confirming: true });
+        patchRow(target.id, { disabling: true, error: null, notice: null });
+        try {
+            const { member } = await api.disableMember({ id: target.id }, call);
+            // Invalidate older reads before applying the write response, including the cached detail.
+            ++listGeneration;
+            ++detailGeneration;
+            set({ members: Object.freeze((read({}).members ?? []).map(m => m.id === member.id ? Object.freeze({ ...member }) : m)),
+                detailById: Object.freeze({ ...read({}).detailById, [member.id]: Object.freeze({ ...member }) }), detailLoadingId: null });
+            patchRow(target.id, { notice: 'Member disabled.' });
+            return store.active({});
+        }
+        catch (error) {
+            patchRow(target.id, { error: report(error, 'Failed to disable member.') });
+            return false;
+        }
+        finally {
+            patchRow(target.id, { disabling: false });
+            if (read({}).pending === target)
+                set({ pending: null });
+            set({ confirming: false });
+        }
+    }
+    const unsubscribe = refresh?.subscribe({ onRefresh: () => { void load({}); } });
+    return {
+        getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, stateFor, toggleDetail, resendSignInLink, confirmDestructive,
+        requestDestructive({ id }, _optional = {}) { const member = row(id); if (gate() && member && member.status !== 'disabled' && !read({}).confirming)
+            set({ pending: Object.freeze({ ...member }) }); },
+        cancelDestructive(_required, _optional = {}) { if (!read({}).confirming)
+            set({ pending: null }); },
+        dispose(_required = {}, _optional = {}) { unsubscribe?.(); store.dispose({}); ++listGeneration; ++detailGeneration; },
+    };
+}
+//# sourceMappingURL=members.controller.js.map

package/dist/admin/controllers/roles.controller.d.ts

@@ -0,0 +1,47 @@
+import type { RolesApiPort } from '../ports.js';
+import type { RolesState, RolesDraft, RoleRecord, PolicyRecord, DestructiveTarget } from '../models.js';
+/** One controller backs both tabs: two hook calls would double reads and split shared errors.
+ * The lists always refresh together; permission edits only refresh the currently open panel.
+ * Controller methods use synchronous state, never React state updater side effects. */
+export declare function createRolesController({ api }: {
+    api: RolesApiPort;
+}, { permissions }?: {
+    permissions?: readonly string[];
+}): {
+    getSnapshot(_required?: Record<string, never>, _optional?: Record<string, never>): RolesState;
+    subscribe({ listener }: {
+        listener: () => void;
+    }, _optional?: Record<string, never>): () => void;
+    dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+    setDraft({ patch }: {
+        patch: Partial<RolesDraft>;
+    }, _optional?: Record<string, never>): void;
+    cancelEdit({ kind }: {
+        kind: "role" | "policy";
+    }, _optional?: Record<string, never>): void;
+    load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    loadPermissions: ({ policyId }: {
+        policyId: string;
+    }, _optional?: Record<string, never>) => Promise<void>;
+    togglePermissions: ({ policyId }: {
+        policyId: string;
+    }, _optional?: Record<string, never>) => Promise<void>;
+    createRole: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    createPolicy: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    editRole: ({ role: r }: {
+        role: RoleRecord;
+    }, _optional?: Record<string, never>) => void;
+    editPolicy: ({ policy: p }: {
+        policy: PolicyRecord;
+    }, _optional?: Record<string, never>) => void;
+    saveRole: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    savePolicy: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    writePermission: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    requestDestructive: ({ target }: {
+        target: DestructiveTarget;
+    }, _optional?: Record<string, never>) => void;
+    cancelDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => void;
+    confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+};
+export type RolesController = ReturnType<typeof createRolesController>;
+//# sourceMappingURL=roles.controller.d.ts.map

package/dist/admin/controllers/roles.controller.js

@@ -0,0 +1,282 @@
+import { canManageRoles, mutableRole, mutablePolicy, describeRolesError } from '../rules.js';
+import { rolesMessagesEn as m } from '../messages.en.js';
+const initial = {
+    roles: null, policies: null, error: null, rowError: null, roleError: null, policyError: null,
+    roleName: '', policyName: '', policyDescription: '', roleSaving: false, policySaving: false, rowSavingId: null,
+    editingRoleId: null, editingRoleName: '', editingPolicyId: null, editingPolicyName: '', editingPolicyDescription: '',
+    permissionPolicyId: null, permissionInput: '', resourceTypeInput: '', permissionRows: Object.freeze([]), permissionsLoading: false,
+    removingPermissionId: null, pending: null, confirming: false,
+};
+/** One controller backs both tabs: two hook calls would double reads and split shared errors.
+ * The lists always refresh together; permission edits only refresh the currently open panel.
+ * Controller methods use synchronous state, never React state updater side effects. */
+export function createRolesController({ api }, { permissions = [] } = {}) {
+    const grants = Object.freeze([...permissions]);
+    let state = Object.freeze({ ...initial }), disposed = false, listGeneration = 0, permissionGeneration = 0, panelGeneration = 0;
+    const listeners = new Set();
+    const abort = new AbortController();
+    const call = { signal: abort.signal };
+    const set = (patch) => {
+        if (disposed)
+            return;
+        const immutablePatch = patch.permissionRows ? { ...patch, permissionRows: Object.freeze([...patch.permissionRows]) } : patch;
+        state = Object.freeze({ ...state, ...immutablePatch });
+        for (const listener of listeners)
+            listener();
+    };
+    const report = (error, fallback) => describeRolesError({ error, fallback });
+    const gate = () => {
+        if (disposed || state.confirming)
+            return false;
+        if (!canManageRoles({ permissions: grants })) {
+            set({ rowError: m.forbidden });
+            return false;
+        }
+        return true;
+    };
+    const role = (id) => state.roles?.find(r => r.id === id);
+    const policy = (id) => state.policies?.find(p => p.id === id);
+    const roleGate = (r) => gate() && !!r && (mutableRole({ role: r }) || (set({ rowError: m.immutable }), false));
+    const policyGate = (p) => gate() && !!p && (mutablePolicy({ policy: p }) || (set({ rowError: m.immutable }), false));
+    const rows = (items) => Object.freeze(items.map(r => Object.freeze({ ...r })));
+    async function load(_required, _optional = {}) {
+        if (disposed)
+            return;
+        const generation = ++listGeneration;
+        set({ error: null });
+        try {
+            const [r, p] = await Promise.all([api.listRoles({}, call), api.listPolicies({}, call)]);
+            if (generation === listGeneration)
+                set({ roles: rows(r.roles), policies: rows(p.policies) });
+        }
+        catch (error) {
+            if (generation === listGeneration)
+                set({ error: report(error, 'Failed to load roles/policies.') });
+        }
+    }
+    async function loadPermissions({ policyId }, _optional = {}) {
+        if (disposed || state.permissionPolicyId !== policyId)
+            return;
+        // Start order, rather than completion order, owns rows AND failures. Closing also invalidates.
+        const generation = ++permissionGeneration;
+        set({ permissionsLoading: true });
+        try {
+            const result = await api.listPolicyPermissions({ policyId }, call);
+            if (generation === permissionGeneration && state.permissionPolicyId === policyId)
+                set({ permissionRows: rows(result.policyPermissions) });
+        }
+        catch (error) {
+            if (generation === permissionGeneration && state.permissionPolicyId === policyId)
+                set({ permissionRows: [], rowError: report(error, 'Failed to load permissions.') });
+        }
+        finally {
+            if (generation === permissionGeneration)
+                set({ permissionsLoading: false });
+        }
+    }
+    async function togglePermissions({ policyId }, _optional = {}) {
+        if (disposed || !policy(policyId))
+            return;
+        const next = state.permissionPolicyId === policyId ? null : policyId;
+        ++panelGeneration;
+        ++permissionGeneration;
+        // Clear first so reopening cannot flash the previous policy's permissions.
+        set({ permissionPolicyId: next, permissionRows: [], permissionsLoading: false, permissionInput: '', resourceTypeInput: '', rowError: null });
+        if (next)
+            await loadPermissions({ policyId: next });
+    }
+    async function createRole(_required, _optional = {}) {
+        if (!gate() || state.roleSaving)
+            return false;
+        const name = state.roleName;
+        set({ roleSaving: true, roleError: null });
+        try {
+            await api.createRole({ name }, call);
+            if (state.roleName === name)
+                set({ roleName: '' });
+            await load({});
+            return !disposed;
+        }
+        catch (error) {
+            set({ roleError: report(error, 'Failed to create role.') });
+            return false;
+        }
+        finally {
+            set({ roleSaving: false });
+        }
+    }
+    async function createPolicy(_required, _optional = {}) {
+        if (!gate() || state.policySaving)
+            return false;
+        const name = state.policyName, description = state.policyDescription;
+        set({ policySaving: true, policyError: null });
+        try {
+            await api.createPolicy({ name }, { ...call, ...(description ? { description } : {}) });
+            if (state.policyName === name && state.policyDescription === description)
+                set({ policyName: '', policyDescription: '' });
+            await load({});
+            return !disposed;
+        }
+        catch (error) {
+            set({ policyError: report(error, 'Failed to create policy.') });
+            return false;
+        }
+        finally {
+            set({ policySaving: false });
+        }
+    }
+    function editRole({ role: r }, _optional = {}) {
+        if (roleGate(role(r.id)))
+            set({ editingRoleId: r.id, editingRoleName: r.name, rowError: null });
+    }
+    function editPolicy({ policy: p }, _optional = {}) {
+        if (policyGate(policy(p.id)))
+            set({ editingPolicyId: p.id, editingPolicyName: p.name, editingPolicyDescription: p.description ?? '', rowError: null });
+    }
+    async function saveRole(_required, _optional = {}) {
+        const id = state.editingRoleId, name = state.editingRoleName;
+        if (!id || !roleGate(role(id)) || state.rowSavingId)
+            return false;
+        set({ rowSavingId: id, rowError: null });
+        try {
+            await api.updateRole({ roleId: id, name }, call);
+            // A late save must not close another row's newer edit.
+            if (state.editingRoleId === id && state.editingRoleName === name)
+                set({ editingRoleId: null });
+            await load({});
+            return !disposed;
+        }
+        catch (error) {
+            set({ rowError: report(error, 'Failed to rename role.') });
+            return false;
+        }
+        finally {
+            if (state.rowSavingId === id)
+                set({ rowSavingId: null });
+        }
+    }
+    async function savePolicy(_required, _optional = {}) {
+        const id = state.editingPolicyId, name = state.editingPolicyName, description = state.editingPolicyDescription;
+        if (!id || !policyGate(policy(id)) || state.rowSavingId)
+            return false;
+        set({ rowSavingId: id, rowError: null });
+        try {
+            await api.updatePolicy({ policyId: id }, { ...call, name, description });
+            if (state.editingPolicyId === id && state.editingPolicyName === name && state.editingPolicyDescription === description)
+                set({ editingPolicyId: null });
+            await load({});
+            return !disposed;
+        }
+        catch (error) {
+            set({ rowError: report(error, 'Failed to update policy.') });
+            return false;
+        }
+        finally {
+            if (state.rowSavingId === id)
+                set({ rowSavingId: null });
+        }
+    }
+    async function writePermission(_required, _optional = {}) {
+        const id = state.permissionPolicyId, permission = state.permissionInput, resourceType = state.resourceTypeInput;
+        if (!id || !permission || !policyGate(policy(id)) || state.rowSavingId)
+            return false;
+        const generation = panelGeneration;
+        set({ rowSavingId: id, rowError: null });
+        try {
+            await api.writePolicyPermission({ policyId: id, permission }, { ...call, ...(resourceType ? { resourceType } : {}) });
+            // Ordering alone cannot protect a trailing refresh: it always mints the newest generation.
+            // Check the CURRENT panel identity, and preserve a newer draft even on the same panel.
+            if (generation === panelGeneration && state.permissionInput === permission && state.resourceTypeInput === resourceType)
+                set({ permissionInput: '', resourceTypeInput: '' });
+            if (state.permissionPolicyId === id)
+                await loadPermissions({ policyId: id });
+            return !disposed;
+        }
+        catch (error) {
+            set({ rowError: report(error, 'Failed to add permission.') });
+            return false;
+        }
+        finally {
+            if (state.rowSavingId === id)
+                set({ rowSavingId: null });
+        }
+    }
+    function targetGate(target) {
+        if (target.kind === 'role')
+            return roleGate(role(target.role.id));
+        return policyGate(policy(target.kind === 'policy' ? target.policy.id : target.policyId));
+    }
+    function requestDestructive({ target }, _optional = {}) {
+        if (state.confirming || !targetGate(target))
+            return;
+        if (target.kind === 'permission' && (state.permissionPolicyId !== target.policyId || !state.permissionRows.some(r => r.id === target.row.id)))
+            return;
+        // The menu closes after one click; shell confirmation survives that closure. Revoke also
+        // needs confirmation: removing from an attached policy immediately changes live authority.
+        const captured = target.kind === 'role' ? Object.freeze({ kind: 'role', role: Object.freeze({ ...target.role }) }) : target.kind === 'policy' ? Object.freeze({ kind: 'policy', policy: Object.freeze({ ...target.policy }) }) : Object.freeze({ kind: 'permission', policyId: target.policyId, row: Object.freeze({ ...target.row }) });
+        set({ pending: captured, rowError: null });
+    }
+    function cancelDestructive(_required, _optional = {}) {
+        if (!state.confirming)
+            set({ pending: null });
+    }
+    async function confirmDestructive(_required, _optional = {}) {
+        const target = state.pending;
+        if (!target || state.confirming || state.rowSavingId || !targetGate(target))
+            return false;
+        set({ confirming: true, rowError: null });
+        try {
+            if (target.kind === 'role') {
+                await api.deleteRole({ roleId: target.role.id }, call);
+                await load({});
+            }
+            else if (target.kind === 'policy') {
+                await api.deletePolicy({ policyId: target.policy.id }, call);
+                if (state.permissionPolicyId === target.policy.id) {
+                    ++permissionGeneration;
+                    ++panelGeneration;
+                    set({ permissionPolicyId: null, permissionRows: [], permissionsLoading: false });
+                }
+                await load({});
+            }
+            else {
+                set({ removingPermissionId: target.row.id });
+                await api.removePolicyPermission({ policyId: target.policyId, policyPermissionId: target.row.id }, call);
+                if (state.permissionPolicyId === target.policyId)
+                    await loadPermissions({ policyId: target.policyId });
+            }
+            return !disposed;
+        }
+        catch (error) {
+            set({ rowError: report(error, target.kind === 'permission' ? 'Failed to remove permission.' : `Failed to delete ${target.kind}.`) });
+            return false;
+        }
+        finally {
+            if (state.pending === target)
+                set({ pending: null });
+            set({ confirming: false, removingPermissionId: null });
+        }
+    }
+    return {
+        getSnapshot(_required = {}, _optional = {}) { return state; },
+        subscribe({ listener }, _optional = {}) {
+            if (!disposed)
+                listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        dispose(_required = {}, _optional = {}) {
+            if (disposed)
+                return;
+            disposed = true;
+            abort.abort();
+            ++listGeneration;
+            ++permissionGeneration;
+            listeners.clear();
+        },
+        setDraft({ patch }, _optional = {}) { set(patch); },
+        cancelEdit({ kind }, _optional = {}) { set(kind === 'role' ? { editingRoleId: null } : { editingPolicyId: null }); },
+        load, loadPermissions, togglePermissions, createRole, createPolicy, editRole, editPolicy, saveRole, savePolicy, writePermission,
+        requestDestructive, cancelDestructive, confirmDestructive,
+    };
+}
+//# sourceMappingURL=roles.controller.js.map

package/dist/admin/controllers/users.controller.d.ts

@@ -0,0 +1,53 @@
+import type { UsersApiPort, UsersSafetyPort } from '../ports.js';
+import type { UsersState, UsersDraft, UserAction } from '../models.js';
+/** Users, roles and policies refresh together. Only the caller read is best-effort: failure keeps
+ * all caller-dependent actions closed. Each panel transition invalidates both success and error
+ * settlements, including close/reopen of the same row. Password resets do not refresh the table. */
+export declare function createUsersController({ api, safety }: {
+    api: UsersApiPort;
+    safety: UsersSafetyPort;
+}, { permissions, openOwnPasswordReset, onOwnPasswordResetClosed, }?: {
+    permissions?: readonly string[];
+    openOwnPasswordReset?: boolean;
+    onOwnPasswordResetClosed?: (required: Record<string, never>, optional?: Record<string, never>) => void;
+}): {
+    getSnapshot: (_required?: Record<string, never>, _optional?: Record<string, never>) => Readonly<UsersState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }, _optional?: Record<string, never>) => () => void;
+    allowed: ({ principalId, action }: {
+        principalId: string;
+        action: UserAction;
+    }, _optional?: Record<string, never>) => boolean;
+    load: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    loadCaller: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<void>;
+    createUser: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    toggleExpanded: ({ principalId }: {
+        principalId: string;
+    }, _optional?: Record<string, never>) => void;
+    savePanel: ({ principalId, kind }: {
+        principalId: string;
+        kind: "email" | "role" | "policy";
+    }, _optional?: Record<string, never>) => Promise<boolean>;
+    enableUser: ({ principalId }: {
+        principalId: string;
+    }, _optional?: Record<string, never>) => Promise<boolean>;
+    requestDestructive: ({ principalId, kind }: {
+        principalId: string;
+        kind: "disable" | "delete" | "reset";
+    }, _optional?: Record<string, never>) => void;
+    confirmDestructive: (_required: Record<string, never>, _optional?: Record<string, never>) => Promise<boolean>;
+    cancelDestructive(_required: Record<string, never>, _optional?: Record<string, never>): void;
+    setFormOpen({ open }: {
+        open: boolean;
+    }, _optional?: Record<string, never>): void;
+    setDraft({ patch }: {
+        patch: Partial<UsersDraft>;
+    }, _optional?: Record<string, never>): void;
+    togglePasswordVisible({ field }: {
+        field: "new" | "confirm";
+    }, _optional?: Record<string, never>): void;
+    dispose(_required?: Record<string, never>, _optional?: Record<string, never>): void;
+};
+export type UsersController = ReturnType<typeof createUsersController>;
+//# sourceMappingURL=users.controller.d.ts.map