@astrale-domains/shell 0.1.7 → 0.1.8

package/dist/mutations/group/set-group-membership.js

@@ -1,6 +1,46 @@
 import { defineMutation } from '@astrale-os/sdk/mutation';
 // Seam L-SHELL-8: the legacy membership Edge a change may converge beside `extends_with`.
 import { legacyMembershipClass } from './legacy/index.js';
+const rejectChange = (failure) => {
+    if (failure.outcomeKnown &&
+        failure.code !== 'MUTATION_PRECONDITION_FAILED' &&
+        failure.code !== 'MUTATION_CONFLICT' &&
+        failure.code !== 'MUTATION_POST_STATE_INVALID')
+        throw failure;
+    return {
+        ok: false,
+        code: failure.code,
+        ...(failure.rule !== undefined ? { rule: failure.rule } : {}),
+        outcomeKnown: failure.outcomeKnown,
+    };
+};
+/**
+ * Create or delete membership Edges of several members of one group in one commit, under the few
+ * guards that cover all of them: every change is written, or none.
+ */
+export const setGroupMemberships = defineMutation()((domain) => ({
+    id: 'shell.group.memberships.set',
+    build(input, mutation) {
+        for (const guard of input.guards)
+            mutation.expect.query(guard);
+        for (const change of input.changes) {
+            const endpoints = { source: { id: change.member }, target: { id: input.group } };
+            const selected = change.edge === 'authority'
+                ? domain.dependencies.kernel.classes.extends_with
+                : legacyMembershipClass(domain);
+            if (change.present)
+                mutation.createEdge({ class: selected, ...endpoints });
+            else
+                mutation.deleteEdge({ class: selected, ...endpoints });
+        }
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => rejectChange({
+        outcomeKnown: failure.outcomeKnown,
+        code: failure.code,
+        ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+    }),
+}));
 /** Converge the membership Edges of one pair, guarded by what was observed of them. */
 export const setGroupMembership = defineMutation()((domain) => ({
     id: 'shell.group.membership.set',
@@ -22,17 +62,9 @@ export const setGroupMembership = defineMutation()((domain) => ({
         }
     },
     project: () => ({ ok: true }),
-    reject: (failure) => {
-        if (failure.outcomeKnown &&
-            failure.code !== 'MUTATION_PRECONDITION_FAILED' &&
-            failure.code !== 'MUTATION_CONFLICT' &&
-            failure.code !== 'MUTATION_POST_STATE_INVALID')
-            throw failure;
-        return {
-            ok: false,
-            code: failure.code,
-            ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
-            outcomeKnown: failure.outcomeKnown,
-        };
-    },
+    reject: (failure) => rejectChange({
+        outcomeKnown: failure.outcomeKnown,
+        code: failure.code,
+        ...('rule' in failure && failure.rule !== undefined ? { rule: failure.rule } : {}),
+    }),
 }));

package/dist/mutations/invitation/write-invitation.js

@@ -1,8 +1,23 @@
 import { defineMutation } from '@astrale-os/sdk/mutation';
-/** Record a pending invitation of one account, kept by one durable run. */
+/**
+ * Record a pending invitation of one account, kept by one durable run, and cancel in the same
+ * commit the pending invitations it replaces: an account has at most one.
+ */
 export const createInvitation = defineMutation()((domain) => ({
     id: 'shell.invitation.create',
     build(input, mutation) {
+        for (const previous of input.replaces ?? []) {
+            mutation.expect.node({
+                node: { id: previous },
+                class: domain.classes.Invitation,
+                props: { equals: { status: 'pending' } },
+            });
+            mutation.updateNode({
+                node: { id: previous },
+                class: domain.classes.Invitation,
+                props: { set: { status: 'cancelled' } },
+            });
+        }
         const invitation = mutation.createNode({
             as: 'invitation',
             class: domain.classes.Invitation,
@@ -11,6 +26,7 @@ export const createInvitation = defineMutation()((domain) => ({
                 expiresAt: input.expiresAt,
                 execution: input.execution,
                 round: 0,
+                email: input.email,
             },
         });
         mutation.createEdge({
@@ -26,7 +42,7 @@ export const createInvitation = defineMutation()((domain) => ({
         return { invitation };
     },
 }));
-/** Change an invitation's status or its round, while it is still pending. */
+/** Change an invitation's status, or its round and expiry, while it is still pending. */
 export const updateInvitation = defineMutation()((domain) => ({
     id: 'shell.invitation.update',
     build(input, mutation) {
@@ -42,6 +58,7 @@ export const updateInvitation = defineMutation()((domain) => ({
                 set: {
                     ...(input.status === undefined ? {} : { status: input.status }),
                     ...(input.round === undefined ? {} : { round: input.round }),
+                    ...(input.expiresAt === undefined ? {} : { expiresAt: input.expiresAt }),
                 },
             },
         });

package/dist/queries/composition/index.js

@@ -1,2 +1,2 @@
 export { readExtensions } from './read-extensions.js';
-export { readRoleNodes } from './read-role-nodes.js';
+export { readRoleKeys, readRoleNodes } from './read-role-nodes.js';

package/dist/queries/composition/read-role-nodes.js

@@ -1,3 +1,4 @@
+import { Path } from '@astrale-os/sdk/graph/path';
 import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
 const CORE = 'core.';
 /** Each Core Node of a Kernel Role Class, named by its `of_domain` locator. */
@@ -22,20 +23,54 @@ export const readRoleNodes = defineQuery()((domain) => {
         },
         project(pages) {
             const byKey = new Map();
-            for (const page of pages) {
-                for (const item of queryResult.edgeItems(page, 'Shell Roles')) {
-                    if (item.edge.kind !== 'value' || item.source.kind !== 'reference')
-                        continue;
-                    if (item.target.kind !== 'value')
-                        continue;
-                    const key = item.edge.value.props[member];
-                    const owner = item.target.value.props[origin];
-                    if (typeof key !== 'string' || !key.startsWith(CORE) || typeof owner !== 'string')
-                        continue;
-                    byKey.set(`${owner}:${key.slice(CORE.length)}`, item.source.value.id);
-                }
-            }
+            for (const [id, key] of roleKeys(pages, member, origin))
+                byKey.set(key, id);
             return { byKey, ids: new Set(byKey.values()) };
         },
     };
 });
+/** Each Core Role in pages of `of_domain` Edges: its Node, and `<origin>:<Core key>`. */
+function roleKeys(pages, member, origin) {
+    const keys = new Map();
+    for (const page of pages) {
+        for (const item of queryResult.edgeItems(page, 'Shell Roles')) {
+            if (item.edge.kind !== 'value' || item.source.kind !== 'reference')
+                continue;
+            if (item.target.kind !== 'value')
+                continue;
+            const key = item.edge.value.props[member];
+            const owner = item.target.value.props[origin];
+            if (typeof key !== 'string' || !key.startsWith(CORE) || typeof owner !== 'string')
+                continue;
+            keys.set(item.source.value.id, `${owner}:${key.slice(CORE.length)}`);
+        }
+    }
+    return keys;
+}
+/**
+ * The Core Roles among some Identities, by `<origin>:<Core key>`: what one composition holds, read
+ * without the catalogue of every installed Role.
+ */
+export const readRoleKeys = defineQuery()((domain) => {
+    const kernel = domain.dependencies.kernel.classes;
+    const member = kernel.of_domain.properties.member.key;
+    const origin = kernel.Domain.properties.origin.key;
+    return {
+        id: 'shell.composition.role-keys',
+        page: { size: 256 },
+        pagination: { maximumPages: 16 },
+        build: ({ identities }) => {
+            const locator = Query.from({
+                nodes: [Path.id(identities[0]), ...identities.slice(1).map((id) => Path.id(id))],
+            })
+                .filter({ class: kernel.Role })
+                .expand({ via: [kernel.of_domain], direction: 'outgoing' });
+            return locator.select({
+                kind: 'edges',
+                binding: locator.edge,
+                projection: { edge: 'value', source: 'reference', target: 'value' },
+            });
+        },
+        project: (pages) => roleKeys(pages, member, origin),
+    };
+});

package/dist/queries/group/index.js

@@ -1,2 +1,3 @@
 export { readGroupMembership, } from './read-group-membership.js';
 export { readGroupMembershipEndpoints, } from './read-group-membership-endpoints.js';
+export { readGroupMembers, readGroupMembersEndpoints, } from './read-group-members.js';

package/dist/queries/group/legacy/index.js

@@ -1,2 +1,3 @@
 export { legacyReadMemberOfGroup } from './read-member-of-group.js';
 export { legacyReadCoreGroups } from './read-core-groups.js';
+export { legacyReadMembersOfGroup } from './read-members-of-group.js';

package/dist/queries/group/legacy/read-members-of-group.js

@@ -0,0 +1,27 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, } from '@astrale-os/sdk/query';
+import { canonical, sources, } from '../read-group-members.js';
+/**
+ * @deprecated The legacy `member_of_group` Edges from the members to the group, in one read and
+ * kept whole as one guard (L-SHELL-8). Replaced by `readGroupMembers` (`extends_with`). Removal:
+ * Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyReadMembersOfGroup = defineQuery()((domain) => ({
+    id: 'shell.group.members.legacy',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build({ members, group }) {
+        const walk = Query.from({
+            nodes: [Path.id(members[0]), ...members.slice(1).map((id) => Path.id(id))],
+        }).expand({ via: [domain.classes.member_of_group], direction: 'outgoing' });
+        return walk.filter({ predicate: { kind: 'identity.equal', identity: group } }).select({
+            kind: 'edges',
+            binding: walk.edge,
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    project: (pages, _input, { ast, complete }) => ({
+        present: sources(pages, 'Shell legacy group members'),
+        guard: { query: ast, equals: canonical(complete) },
+    }),
+}));

package/dist/queries/group/read-group-members.js

@@ -0,0 +1,73 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+const anchors = (ids) => [Path.id(ids[0]), ...ids.slice(1).map((id) => Path.id(id))];
+/** Every member and the group, in one read whatever the number of members. */
+export const readGroupMembersEndpoints = defineQuery()(() => ({
+    id: 'shell.group.members.endpoints',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build: ({ members, group }) => Query.from({ nodes: [...anchors(members), Path.id(group)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'reference' },
+    }),
+    project(pages, input, { ast, complete }) {
+        const visible = new Set(queryResult.completeNodeIds(pages, 'Shell group members'));
+        let groupClass;
+        for (const page of pages) {
+            if (page.kind !== 'nodes')
+                continue;
+            for (const item of page.nodes) {
+                if (item.kind === 'reference' && item.value.id === input.group)
+                    groupClass = item.value.class;
+            }
+        }
+        return {
+            visible,
+            ...(groupClass === undefined ? {} : { groupClass }),
+            // The Kernel takes a guard's Nodes in canonical order.
+            guard: { query: ast, equals: { ...complete, ids: [...complete.ids].sort(order) } },
+        };
+    },
+}));
+/** The `extends_with` Edges from the members to the group: their memberships (G1), in one read. */
+export const readGroupMembers = defineQuery()((domain) => ({
+    id: 'shell.group.members.read',
+    page: { size: 256 },
+    pagination: { maximumPages: 2 },
+    build({ members, group }) {
+        const walk = Query.from({ nodes: anchors(members) }).expand({
+            via: [domain.dependencies.kernel.classes.extends_with],
+            direction: 'outgoing',
+        });
+        return walk.filter({ predicate: { kind: 'identity.equal', identity: group } }).select({
+            kind: 'edges',
+            binding: walk.edge,
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    project: (pages, _input, { ast, complete }) => ({
+        present: sources(pages, 'Shell group members'),
+        guard: { query: ast, equals: canonical(complete) },
+    }),
+}));
+/** The members an Edge read finds, by source. */
+export function sources(pages, label) {
+    const found = new Set();
+    for (const page of pages) {
+        for (const item of queryResult.edgeItems(page, label)) {
+            if (item.source.kind === 'reference')
+                found.add(item.source.value.id);
+        }
+    }
+    return found;
+}
+const order = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+/** A guard's Edges in the Kernel's canonical order: by source, then target, then Class. */
+export function canonical(selection) {
+    if (selection.kind !== 'edge')
+        return selection;
+    const keys = [...selection.keys].sort((left, right) => order(left.source, right.source) ||
+        order(left.target, right.target) ||
+        order(left.class, right.class));
+    return { ...selection, keys };
+}

package/dist/queries/invitation/index.js

@@ -1 +1 @@
-export { readInvitation } from './read-invitation.js';
+export { readInvitation, readPendingInvitations } from './read-invitation.js';

package/dist/queries/invitation/read-invitation.js

@@ -1,5 +1,17 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** An invitation Node as the methods and the run read it. */
+function toInvitation(node, keys) {
+    const props = node.props;
+    const email = props[keys.email.key];
+    return {
+        id: node.id,
+        status: String(props[keys.status.key]),
+        execution: String(props[keys.execution.key]),
+        round: Number(props[keys.round.key] ?? 0),
+        ...(typeof email === 'string' ? { email } : {}),
+    };
+}
 /** One invitation, or undefined when there is none the reader reads. */
 export const readInvitation = defineQuery()((domain) => ({
     id: 'shell.invitation.read',
@@ -13,13 +25,26 @@ export const readInvitation = defineQuery()((domain) => ({
         const node = queryResult.completeNodeValues(pages, 'Shell invitation')[0];
         if (node === undefined)
             return undefined;
-        const props = node.props;
-        const keys = domain.classes.Invitation.properties;
-        return {
-            id: node.id,
-            status: String(props[keys.status.key]),
-            execution: String(props[keys.execution.key]),
-            round: Number(props[keys.round.key] ?? 0),
-        };
+        return toInvitation(node, domain.classes.Invitation.properties);
     },
 }));
+/** The pending invitations of one account: at most one, unless recorded before that rule. */
+export const readPendingInvitations = defineQuery()((domain) => ({
+    id: 'shell.invitation.pending',
+    page: { size: 64 },
+    pagination: { maximumPages: 1 },
+    build: ({ user }) => Query.from({ nodes: [Path.id(user)] })
+        .expand({ via: [domain.classes.invitation_user], direction: 'incoming' })
+        .filter({ class: domain.classes.Invitation })
+        .filter({
+        predicate: {
+            kind: 'property.equal',
+            property: domain.classes.Invitation.properties.status.key,
+            value: 'pending',
+        },
+    })
+        .select({ kind: 'nodes', projection: { kind: 'value' } }),
+    project: (pages) => queryResult
+        .completeNodeValues(pages, 'Shell pending invitations')
+        .map((node) => toInvitation(node, domain.classes.Invitation.properties)),
+}));

package/dist/queries/role/index.js

@@ -1 +1 @@
-export { readRoleNode } from './read-role-node.js';
+export { readRoleId, readRoleNode } from './read-role-node.js';

package/dist/queries/role/read-role-node.js

@@ -11,3 +11,11 @@ export const readRoleNode = defineQuery()(() => ({
     build: ({ role }) => Query.from({ nodes: [role] }).select({ kind: 'nodes', projection: { kind: 'value' } }),
     project: (pages) => queryResult.completeNodeValues(pages, 'Shell Role').length === 1,
 }));
+/** One Role's Node, read by its Core target; nothing when it is not installed. */
+export const readRoleId = defineQuery()(() => ({
+    id: 'shell.role.id',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ role }) => Query.from({ nodes: [role] }).select({ kind: 'nodes', projection: { kind: 'reference' } }),
+    project: (pages) => queryResult.completeNodeIds(pages, 'Shell Role')[0],
+}));