@astrale-domains/shell 0.1.5 → 0.1.7

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

@@ -0,0 +1,41 @@
+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. */
+export const readRoleNodes = 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.roles',
+        page: { size: 256 },
+        pagination: { maximumPages: 16 },
+        build: () => {
+            const locator = Query.from({ nodes: [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) {
+            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);
+                }
+            }
+            return { byKey, ids: new Set(byKey.values()) };
+        },
+    };
+});

package/dist/queries/group/index.js

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

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

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

package/dist/queries/group/legacy/read-core-groups.js

@@ -0,0 +1,46 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+const CORE = 'core.';
+/**
+ * @deprecated Shell's own Core groups, each named by its `of_domain` locator (`core.<name>`)
+ * (L-SHELL-7): the legacy groups a membership write keeps `member_of_group` for. Replaced by the
+ * profile Roles. Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyReadCoreGroups = 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.access.core-groups',
+        page: { size: 256 },
+        pagination: { maximumPages: 8 },
+        build: () => {
+            const locator = Query.from({ nodes: [domain.classes.Group] }).expand({
+                via: [kernel.of_domain],
+                direction: 'outgoing',
+            });
+            return locator.select({
+                kind: 'edges',
+                binding: locator.edge,
+                projection: { edge: 'value', source: 'reference', target: 'value' },
+            });
+        },
+        project(pages) {
+            const groups = {};
+            for (const page of pages) {
+                for (const item of queryResult.edgeItems(page, 'Shell Core groups')) {
+                    if (item.edge.kind !== 'value' || item.source.kind !== 'reference')
+                        continue;
+                    if (item.target.kind !== 'value')
+                        continue;
+                    if (item.target.value.props[origin] !== domain.origin)
+                        continue;
+                    const key = item.edge.value.props[member];
+                    if (typeof key === 'string' && key.startsWith(CORE)) {
+                        groups[key.slice(CORE.length)] = item.source.value.id;
+                    }
+                }
+            }
+            return groups;
+        },
+    };
+});

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

@@ -0,0 +1,24 @@
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+/**
+ * @deprecated The legacy `member_of_group` Edge from the member to the group, kept whole as a guard
+ * (L-SHELL-8). Replaced by `readGroupMembership` (`extends_with`). Removal: Shell major (delivery
+ * step 5) after 1Pact step 4.
+ */
+export const legacyReadMemberOfGroup = defineQuery()((domain) => ({
+    id: 'shell.group.membership.legacy',
+    build({ member, group }) {
+        const edges = Query.from({ edges: [domain.classes.member_of_group] });
+        return edges
+            .filter({ binding: edges.source, predicate: { kind: 'identity.equal', identity: member } })
+            .filter({ binding: edges.target, predicate: { kind: 'identity.equal', identity: group } })
+            .select({
+            kind: 'edges',
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
+        });
+    },
+    pagination: { maximumPages: 2 },
+    project(pages, _input, { ast, complete }) {
+        const present = pages.some((page) => queryResult.edgeItems(page, 'Shell legacy membership').length > 0);
+        return { present, guard: { query: ast, equals: complete } };
+    },
+}));

package/dist/queries/group/read-group-membership-endpoints.js

@@ -1,5 +1,6 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** Both membership endpoints, kept whole as a guard: neither is replaced while Shell decides. */
 export const readGroupMembershipEndpoints = defineQuery()(() => ({
     id: 'shell.group.membership.endpoints',
     page: { size: 2 },
@@ -10,8 +11,18 @@ export const readGroupMembershipEndpoints = defineQuery()(() => ({
     }),
     project(pages, input, { ast, complete }) {
         const ids = queryResult.completeNodeIds(pages, 'Shell membership endpoints');
+        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: ids.includes(input.member) && ids.includes(input.group),
+            ...(groupClass === undefined ? {} : { groupClass }),
             guard: { query: ast, equals: complete },
         };
     },

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

@@ -1,35 +1,20 @@
 import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+/** The `extends_with` Edge from the member to the group: the membership itself (G1). */
 export const readGroupMembership = defineQuery()((domain) => ({
     id: 'shell.group.membership.read',
     build({ member, group }) {
-        const edges = Query.from({
-            edges: [domain.classes.member_of_group, domain.dependencies.kernel.classes.extends_with],
-        });
+        const edges = Query.from({ edges: [domain.dependencies.kernel.classes.extends_with] });
         return edges
             .filter({ binding: edges.source, predicate: { kind: 'identity.equal', identity: member } })
             .filter({ binding: edges.target, predicate: { kind: 'identity.equal', identity: group } })
             .select({
             kind: 'edges',
-            projection: { edge: 'value', source: 'reference', target: 'reference' },
+            projection: { edge: 'reference', source: 'reference', target: 'reference' },
         });
     },
-    pagination: { maximumPages: 4 },
+    pagination: { maximumPages: 2 },
     project(pages, _input, { ast, complete }) {
-        let membership = false;
-        let authority = false;
-        for (const page of pages) {
-            for (const item of queryResult.edgeItems(page, 'Shell group membership')) {
-                if (item.edge.kind !== 'value')
-                    throw new TypeError('Expected an Edge value.');
-                if (item.edge.value.class === domain.classes.member_of_group.key)
-                    membership = true;
-                else if (item.edge.value.class === domain.dependencies.kernel.classes.extends_with.key) {
-                    authority = true;
-                }
-                else
-                    throw new TypeError('Unexpected Edge Class.');
-            }
-        }
-        return { membership, authority, guard: { query: ast, equals: complete } };
+        const present = pages.some((page) => queryResult.edgeItems(page, 'Shell group membership').length > 0);
+        return { present, guard: { query: ast, equals: complete } };
     },
 }));

package/dist/queries/identity/index.js

@@ -0,0 +1 @@
+export { readIdentities } from './read-identities.js';

package/dist/queries/identity/read-identities.js

@@ -0,0 +1,29 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/**
+ * The accounts or groups a selection names that Shell reads, as stored: a Class extent includes a
+ * foreign subclass, and a Node of another Class is left out.
+ */
+export const readIdentities = defineQuery()((domain) => ({
+    id: 'shell.identities.read',
+    page: { size: 256 },
+    pagination: { maximumPages: 16 },
+    build(selection) {
+        const selected = domain.classes[selection.kind];
+        if ('ids' in selection) {
+            const [first, ...others] = selection.ids;
+            return Query.from({ nodes: [Path.id(first), ...others.map((id) => Path.id(id))] })
+                .filter({ class: selected })
+                .select({ kind: 'nodes', projection: { kind: 'value' } });
+        }
+        let query = Query.from({ nodes: [selected] });
+        for (const [name, value] of Object.entries(selection.where)) {
+            const property = selected.properties[name];
+            if (property === undefined)
+                throw new TypeError(`${selection.kind} has no ${name}.`);
+            query = query.filter({ predicate: { kind: 'property.equal', property: property.key, value } });
+        }
+        return query.select({ kind: 'nodes', projection: { kind: 'value' } });
+    },
+    project: (pages) => queryResult.completeNodeValues(pages, 'Shell identities'),
+}));

package/dist/queries/invitation/index.js

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

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

@@ -0,0 +1,25 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** One invitation, or undefined when there is none the reader reads. */
+export const readInvitation = defineQuery()((domain) => ({
+    id: 'shell.invitation.read',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ invitation }) => Query.from({ nodes: [Path.id(invitation)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'value' },
+    }),
+    project: (pages) => {
+        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),
+        };
+    },
+}));

package/dist/queries/profile/index.js

@@ -0,0 +1 @@
+export { readProfile } from './read-profile.js';

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

@@ -0,0 +1,15 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** The profile Node of one account or group, or undefined for one stored before profiles. */
+export const readProfile = defineQuery()((domain) => ({
+    id: 'shell.profile.read',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ kind, node }) => Query.from({ nodes: [Path.id(node)] })
+        .expand({
+        via: [kind === 'User' ? domain.classes.user_profile : domain.classes.group_profile],
+        direction: 'outgoing',
+    })
+        .select({ kind: 'nodes', projection: { kind: 'value' } }),
+    project: (pages) => queryResult.completeNodeValues(pages, 'Shell profile')[0]?.id,
+}));

package/dist/queries/role/index.js

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

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

@@ -0,0 +1,13 @@
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/**
+ * Whether the reader reads one Role Node. A Shell Role reads by its holders and by Kernel
+ * `authority.reader` (R7), so read under a caller's authority it tells whether the Kernel finds the
+ * Role in that caller's live composition, at any depth; Root reads every Role.
+ */
+export const readRoleNode = defineQuery()(() => ({
+    id: 'shell.role.read',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ role }) => Query.from({ nodes: [role] }).select({ kind: 'nodes', projection: { kind: 'value' } }),
+    project: (pages) => queryResult.completeNodeValues(pages, 'Shell Role').length === 1,
+}));

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

@@ -0,0 +1 @@
+export { legacyReadUserProfile } from './read-user-profile.js';

package/dist/queries/user/legacy/read-user-profile.js

@@ -0,0 +1,27 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/**
+ * @deprecated The email and display name one account recorded about itself (L-SHELL-5). Replaced
+ * by the account's `email` and `name`. Removal: Shell major (delivery step 5) after 1Pact step 4.
+ */
+export const legacyReadUserProfile = defineQuery()((domain) => {
+    const { claimedEmail: email, claimedName: displayName } = domain.classes.User.properties;
+    return {
+        id: 'shell.user.profile',
+        page: { size: 1 },
+        pagination: { maximumPages: 1 },
+        build: ({ user }) => Query.from({ nodes: [Path.id(user)] }).select({
+            kind: 'nodes',
+            projection: { kind: 'value' },
+        }),
+        project(pages) {
+            const [node] = queryResult.completeNodeValues(pages, 'Shell user profile');
+            const text = (value) => (typeof value === 'string' ? value : undefined);
+            const recorded = {
+                email: text(node?.props[email.key]),
+                displayName: text(node?.props[displayName.key]),
+            };
+            return Object.fromEntries(Object.entries(recorded).filter(([, value]) => value !== undefined));
+        },
+    };
+});