@astrale-domains/shell 0.1.0-beta.8 → 0.1.1

package/dist/mutations/namespace/alias-write.js

@@ -0,0 +1,22 @@
+export const written = Object.freeze({ ok: true });
+/** Turn the Kernel refusals an alias write expects into its Namespace refusal; others propagate. */
+export function rejectAliasWrite(refusals) {
+    return (failure) => {
+        if (failure.outcomeKnown) {
+            if (refusals.name !== undefined &&
+                failure.code === 'MUTATION_POST_STATE_INVALID' &&
+                'rule' in failure &&
+                failure.rule === 'duplicate-key') {
+                return refused(refusals.name);
+            }
+            if (failure.code === 'MUTATION_PRECONDITION_FAILED')
+                return refused(refusals.edge);
+            if (failure.code === 'MUTATION_LOCATOR_INVALID')
+                return refused(refusals.node);
+        }
+        throw failure;
+    };
+}
+function refused(refusal) {
+    return Object.freeze({ ok: false, refusal });
+}

package/dist/mutations/namespace/index.js

@@ -0,0 +1,3 @@
+export { linkAlias } from './link-alias.js';
+export { unlinkAlias } from './unlink-alias.js';
+export { renameAlias } from './rename-alias.js';

package/dist/mutations/namespace/link-alias.js

@@ -0,0 +1,15 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+import { rejectAliasWrite, written } from './alias-write.js';
+/** Create the alias `name` from a Namespace to the one Node a Path reaches. */
+export const linkAlias = defineMutation()((domain) => ({
+    id: 'shell.namespace.alias.link',
+    build({ namespace, name, target }, mutation) {
+        mutation.createEdge({ class: domain.classes.alias, source: namespace, target, slug: name });
+    },
+    project: () => written,
+    reject: rejectAliasWrite({
+        name: 'NAME_TAKEN',
+        edge: 'TARGET_ALREADY_ALIASED',
+        node: 'TARGET_NOT_FOUND',
+    }),
+}));

package/dist/mutations/namespace/rename-alias.js

@@ -0,0 +1,13 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+import { rejectAliasWrite, written } from './alias-write.js';
+/** Rename the alias `name` of one Node in a Namespace to `to`; the Node it names stays the same. */
+export const renameAlias = defineMutation()((domain) => ({
+    id: 'shell.namespace.alias.rename',
+    build({ namespace, target, name, to }, mutation) {
+        const alias = { class: domain.classes.alias, source: namespace, target };
+        mutation.expect.edge({ ...alias, slug: name });
+        mutation.updateEdge({ ...alias, slug: to });
+    },
+    project: () => written,
+    reject: rejectAliasWrite({ name: 'NAME_TAKEN', edge: 'NAME_NOT_FOUND', node: 'NAME_NOT_FOUND' }),
+}));

package/dist/mutations/namespace/unlink-alias.js

@@ -0,0 +1,13 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+import { rejectAliasWrite, written } from './alias-write.js';
+/** Delete the alias `name` of one Node in a Namespace: Edge identity gives the Node at most one. */
+export const unlinkAlias = defineMutation()((domain) => ({
+    id: 'shell.namespace.alias.unlink',
+    build({ namespace, target, name }, mutation) {
+        const alias = { class: domain.classes.alias, source: namespace, target };
+        mutation.expect.edge({ ...alias, slug: name });
+        mutation.deleteEdge(alias);
+    },
+    project: () => written,
+    reject: rejectAliasWrite({ edge: 'NAME_NOT_FOUND', node: 'NAME_NOT_FOUND' }),
+}));

package/dist/mutations/user/index.js

@@ -1 +1 @@
-export { repairUser } from './repair.js';
+export { recordUserProfile } from './record-user-profile.js';

package/dist/mutations/user/record-user-profile.js

@@ -0,0 +1,13 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Set the email and display name an account recorded about itself. */
+export const recordUserProfile = defineMutation()((domain) => ({
+    id: 'shell.user.profile.record',
+    build({ user, set }, mutation) {
+        const props = {
+            ...(set.email === undefined ? {} : { claimedEmail: set.email }),
+            ...(set.displayName === undefined ? {} : { claimedName: set.displayName }),
+        };
+        mutation.updateNode({ node: { id: user }, class: domain.classes.User, props: { set: props } });
+    },
+    project: () => ({}),
+}));

package/dist/mutations/view-access/index.js

@@ -0,0 +1 @@
+export { setViewAccess } from './set-view-access.js';

package/dist/mutations/view-access/set-view-access.js

@@ -0,0 +1,29 @@
+import { defineMutation } from '@astrale-os/sdk/mutation';
+/** Give and withdraw `view_access` Edges in one guarded write. */
+export const setViewAccess = defineMutation()((domain) => ({
+    id: 'shell.view-access.set',
+    build(input, mutation) {
+        mutation.expect.query(input.guard);
+        const edge = ({ identity, view }) => ({
+            class: domain.classes.view_access,
+            source: identity,
+            target: view,
+        });
+        for (const access of input.give)
+            mutation.createEdge(edge(access));
+        for (const access of input.withdraw)
+            mutation.deleteEdge(edge(access));
+    },
+    project: () => ({ ok: true }),
+    reject: (failure) => {
+        if (failure.outcomeKnown) {
+            if (failure.code === 'MUTATION_PRECONDITION_FAILED' || failure.code === 'MUTATION_CONFLICT')
+                return { ok: false, refusal: 'CHANGED' };
+            // An endpoint reaches no Node of a Class view_access accepts.
+            if (failure.code === 'MUTATION_LOCATOR_INVALID')
+                return { ok: false, refusal: 'ENDPOINT_NOT_FOUND' };
+            throw failure;
+        }
+        return { ok: false, refusal: 'UNKNOWN' };
+    },
+}));

package/dist/providers/admin-enrollment/create-admin-enrollment-provider.js

@@ -0,0 +1,78 @@
+import { TransportError } from '@astrale-os/sdk/client';
+import { defineProvider } from '@astrale-os/sdk/integration';
+import { z } from 'zod';
+import { enrollment, InvitationRequestFailure } from '../../integrations/user-invitation/index.js';
+import { decodeAdminInvitationResponse } from './decode-admin-invitation-response.js';
+import { readReply } from './read-enrollment-response.js';
+// Environment is a representation boundary, unlike already-admitted handler input.
+const configuration = z.object({ ENROLLMENT_INGRESS_URL: z.string().url() });
+export function enrollmentProvider(environment) {
+    const input = configuration.parse(environment);
+    const endpoint = new URL(input.ENROLLMENT_INGRESS_URL);
+    if (endpoint.protocol !== 'https:' ||
+        endpoint.username ||
+        endpoint.password ||
+        endpoint.hash ||
+        endpoint.search) {
+        throw new TypeError('Enrollment ingress must be an HTTPS URL without credentials, query or hash.');
+    }
+    const audience = endpoint.href;
+    return defineProvider(enrollment, {
+        async invite(input, execution) {
+            if (execution.auth === undefined)
+                throw new Error('Authenticated Shell invocation required.');
+            // Mint per attempt, using only the current invocation's Domain-self identity.
+            const credential = await execution.auth.mint({ audience, ttlSeconds: 60 });
+            execution.signal.throwIfAborted();
+            const remaining = execution.deadline - Date.now();
+            if (remaining <= 0) {
+                throw TransportError.invocation('Enrollment deadline exceeded.', {
+                    phase: 'timeout',
+                    delivery: 'not-sent',
+                });
+            }
+            // No automatic HTTP retry. A timeout after send has an unknown effect.
+            const signal = AbortSignal.any([execution.signal, AbortSignal.timeout(remaining)]);
+            const response = await fetch(audience, {
+                method: 'POST',
+                // Workers reject redirect:error before sending. Manual preserves the refusal:
+                // every 3xx is rejected below, without forwarding the proof to its Location.
+                redirect: 'manual',
+                headers: {
+                    Authorization: `Bearer ${credential}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'Idempotency-Key': input.requestId,
+                },
+                body: JSON.stringify(input),
+                signal,
+            }).catch((cause) => {
+                if (!(cause instanceof TypeError) && !(cause instanceof DOMException))
+                    throw cause;
+                throw TransportError.invocation('Admin enrollment transport failed.', {
+                    phase: signal.aborted ? 'timeout' : 'unknown',
+                    delivery: 'unknown',
+                });
+            });
+            if (!response.ok) {
+                await response.body?.cancel();
+                if (response.status === 409)
+                    throw new InvitationRequestFailure('INVITATION_CONFLICT');
+                if (response.status === 400 || response.status === 422) {
+                    throw new InvitationRequestFailure('INVITATION_REJECTED');
+                }
+                // Shell admission already happened. A refused service credential is not a new
+                // authorization decision about the caller, and no upstream body is exposed.
+                throw TransportError.invocation('Admin enrollment request was not completed.', {
+                    phase: 'receive',
+                    delivery: 'unknown',
+                });
+            }
+            const result = decodeAdminInvitationResponse(await readReply(response));
+            if (result.requestId !== input.requestId || result.user !== input.user) {
+                throw new TypeError('Admin enrollment response does not match the request.');
+            }
+            return { invitationId: result.invitationId, user: result.user, state: result.state };
+        },
+    });
+}

package/dist/providers/admin-enrollment/decode-admin-invitation-response.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+// Codec du JSON HTTP entrant ; la valeur admise satisfait le contrat de l'Integration.
+const httpReply = z.object({
+    requestId: z.string().min(1),
+    invitationId: z.string().min(1),
+    user: z.string().min(1),
+    state: z.enum([
+        'pending',
+        'accepted',
+        'registering',
+        'registered',
+        'completed',
+        'cancelled',
+        'expired',
+        'failed',
+    ]),
+});
+export function decodeAdminInvitationResponse(value) {
+    return httpReply.parse(value);
+}

package/dist/providers/admin-enrollment/index.js

@@ -0,0 +1 @@
+export { enrollmentProvider } from './create-admin-enrollment-provider.js';

package/dist/providers/admin-enrollment/read-enrollment-response.js

@@ -0,0 +1,34 @@
+export async function readReply(response) {
+    if (!response.headers.get('content-type')?.toLowerCase().startsWith('application/json')) {
+        await response.body?.cancel();
+        throw new TypeError('Expected a JSON enrollment response.');
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new TypeError('Missing enrollment response body.');
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > 16384) {
+                await reader.cancel();
+                throw new TypeError('Enrollment response exceeds 16 KiB.');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+}

package/dist/queries/application/index.js

@@ -0,0 +1 @@
+export { readInstalledEntrypoints } from './read-installed-entrypoints.js';

package/dist/queries/application/read-installed-entrypoints.js

@@ -0,0 +1,28 @@
+import { defineQuery } from '@astrale-os/sdk/query';
+const VIEW_MEMBER = /^view\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/**
+ * Every installed Domain entrypoint this authority can read, in origin order: each View with an
+ * outgoing `entrypoint` Edge, through its `of_domain` locator, which names the View
+ * (`view.<name>`) and reaches its Domain, with the origin and the display name.
+ */
+export const readInstalledEntrypoints = defineQuery()('shell.application.entrypoints', {
+    build: (_, { kernel: { View, entrypoint, of_domain } }) => View.where((view) => [
+        view.via(entrypoint, { direction: 'outgoing' }).exists(),
+        view.via(of_domain, { direction: 'outgoing' }).exists(),
+    ])
+        .with((view) => ({
+        locator: view.via(of_domain, { direction: 'outgoing' }).withEdge().get(),
+    }))
+        // Shell may only traverse Views: their own values would come back withheld.
+        .pick()
+        .all({ max: 10_000 }),
+    output: (rows) => rows
+        .map(({ locator }) => {
+        const member = VIEW_MEMBER.exec(locator.$edge.member);
+        if (member === null)
+            throw new TypeError('Installed entrypoint locator names no View.');
+        const { origin, name } = locator;
+        return { origin, name, view: `${origin}:view.${member[1]}` };
+    })
+        .sort((left, right) => left.origin.localeCompare(right.origin)),
+});

package/dist/queries/group/index.js

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

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

@@ -0,0 +1,18 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+export const readGroupMembershipEndpoints = defineQuery()(() => ({
+    id: 'shell.group.membership.endpoints',
+    page: { size: 2 },
+    pagination: { maximumPages: 2 },
+    build: ({ member, group }) => Query.from({ nodes: [Path.id(member), Path.id(group)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'reference' },
+    }),
+    project(pages, input, { ast, complete }) {
+        const ids = queryResult.completeNodeIds(pages, 'Shell membership endpoints');
+        return {
+            visible: ids.includes(input.member) && ids.includes(input.group),
+            guard: { query: ast, equals: complete },
+        };
+    },
+}));

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

@@ -0,0 +1,35 @@
+import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+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],
+        });
+        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' },
+        });
+    },
+    pagination: { maximumPages: 4 },
+    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 } };
+    },
+}));

package/dist/queries/namespace/index.js

@@ -0,0 +1,2 @@
+export { readDesignatedNode } from './read-designated-node.js';
+export { readViewAliases, readViewsNamespace } from './read-view-aliases.js';

package/dist/queries/namespace/read-designated-node.js

@@ -0,0 +1,12 @@
+import { defineQuery, Query, queryResult } from '@astrale-os/sdk/query';
+/**
+ * The one Node a Path designates for the authority that reads it, or nothing: a Node it cannot
+ * see, and a name no alias holds, read the same.
+ */
+export const readDesignatedNode = defineQuery()(() => ({
+    id: 'shell.namespace.designated-node',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: ({ path }) => Query.from({ nodes: [path] }).select({ kind: 'nodes', projection: { kind: 'reference' } }),
+    project: (pages) => queryResult.completeNodeIds(pages, 'Shell designated Node')[0],
+}));

package/dist/queries/namespace/read-view-aliases.js

@@ -0,0 +1,46 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineQuery, Query, queryResult, } from '@astrale-os/sdk/query';
+/** `/:shell.astrale.ai:core.views`, the Namespace `/v/<name>` reads. */
+const viewsNamespace = (origin) => Path.project({ origin: origin, kind: 'core', name: 'views' });
+/**
+ * The `views` Namespace, which names are given in; nothing on a Shell release without it. It stays
+ * V6: its v7 target is a Core path, which a PostgreSQL Host refuses as a Path with layers.
+ */
+export const readViewsNamespace = defineQuery()((domain) => ({
+    id: 'shell.namespace.views',
+    page: { size: 1 },
+    pagination: { maximumPages: 1 },
+    build: () => Query.from({ nodes: [viewsNamespace(domain.origin)] }).select({
+        kind: 'nodes',
+        projection: { kind: 'reference' },
+    }),
+    project: (pages) => queryResult.completeNodeIds(pages, 'Shell views Namespace')[0],
+}));
+/** Every name of the `views` Namespace, with the View it opens, in name order. */
+export const readViewAliases = defineQuery()((domain) => ({
+    id: 'shell.namespace.view-aliases',
+    page: { size: 256 },
+    pagination: { maximumPages: 8 },
+    build: () => {
+        const named = Query.from({ nodes: [viewsNamespace(domain.origin)] }).expand({
+            via: [domain.classes.alias],
+            direction: 'outgoing',
+        });
+        return named.select({
+            kind: 'edges',
+            binding: named.edge,
+            projection: { edge: 'value', source: 'reference', target: 'reference' },
+        });
+    },
+    project(pages) {
+        const aliases = [];
+        for (const page of pages) {
+            for (const item of queryResult.edgeItems(page, 'Shell view aliases')) {
+                if (item.edge.kind !== 'value' || item.edge.value.slug === undefined)
+                    continue;
+                aliases.push({ view: item.edge.value.target, name: item.edge.value.slug });
+            }
+        }
+        return aliases.sort((a, b) => a.name.localeCompare(b.name));
+    },
+}));

package/dist/queries/user/index.js

@@ -1,5 +1 @@
-export { observeUserGroups } from './groups.js';
-export { observeHome } from './home.js';
-export { observeOwnedSpaces } from './owned-spaces.js';
-export { readUserProfile } from './profile.js';
-export { observeUserSetup } from './setup.js';
+export { readUserProfile } from './read-user-profile.js';

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

@@ -0,0 +1,9 @@
+import { defineQuery } from '@astrale-os/sdk/query';
+/** The email and display name one account recorded; nothing for an account it cannot read. */
+export const readUserProfile = defineQuery()('shell.user.profile', {
+    build: ({ user }, { User }) => User.where((account) => account.id.eq(user)).first(),
+    output: (account) => ({
+        ...(account?.claimedEmail === undefined ? {} : { email: account.claimedEmail }),
+        ...(account?.claimedName === undefined ? {} : { displayName: account.claimedName }),
+    }),
+});

package/dist/queries/view-access/index.js

@@ -0,0 +1 @@
+export { readViewAccess } from './read-view-access.js';

package/dist/queries/view-access/read-view-access.js

@@ -0,0 +1,35 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
+/** Every `view_access` Edge from the identities, kept whole as a guard for the write it decides. */
+export const readViewAccess = defineQuery()((domain) => ({
+    id: 'shell.view-access.read',
+    build({ identities }) {
+        const held = Query.from({
+            nodes: [Path.id(identities[0]), ...identities.slice(1).map((identity) => Path.id(identity))],
+        }).expand({
+            via: [domain.classes.view_access],
+            direction: 'outgoing',
+        });
+        return held.select({
+            kind: 'edges',
+            binding: held.edge,
+            projection: { edge: 'value', source: 'reference', target: 'reference' },
+        });
+    },
+    // A guard checks at most 4,096 Edges: 16 pages of 256.
+    pagination: { maximumPages: 16 },
+    project(pages, _input, { ast, complete }) {
+        const given = new Map();
+        for (const page of pages) {
+            for (const item of queryResult.edgeItems(page, 'Shell view access')) {
+                if (item.edge.kind !== 'value')
+                    throw new TypeError('Expected an Edge value.');
+                const { source, target } = item.edge.value;
+                const views = given.get(source) ?? new Set();
+                views.add(target);
+                given.set(source, views);
+            }
+        }
+        return { given, guard: { query: ast, equals: complete } };
+    },
+}));