@astrale-domains/shell 0.1.0-beta.10

package/dist/application.js

@@ -0,0 +1,29 @@
+import { defineApplication, defineFrontend, external, requirements, } from '@astrale-os/sdk/application';
+import { K } from '@astrale-os/sdk/schema';
+import runtime from './runtime.js';
+import { ShellSchema } from './schema/index.js';
+export const frontend = defineFrontend({
+    schema: ShellSchema,
+    source: external('https://app.astrale.ai'),
+    routes: {
+        group: '/groups',
+        home: '/',
+        space: '/spaces',
+        user: '/users',
+    },
+    entrypoint: 'home',
+});
+export const application = defineApplication({
+    schema: ShellSchema,
+    runtime,
+    frontend,
+    requirements: requirements({
+        callables: [
+            K.classes.Identity.static.methods.whois,
+            K.functions.provision,
+            K.functions.query,
+            K.functions.mutate,
+        ],
+    }),
+});
+export default application;

package/dist/entrypoints/application.d.ts

@@ -0,0 +1 @@
+export { application, default } from '../application.js';

package/dist/entrypoints/application.js

@@ -0,0 +1 @@
+export { application, default } from '../application.js';

package/dist/entrypoints/runtime.js

@@ -0,0 +1 @@
+export { default } from '../runtime.js';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Group, ORIGIN, S, ShellCore, ShellSchema, Space, User, adminGroup, administers_space, belongsToSpace, default_space, defaultSpace, groupAssignUser, groupCore, groupUnassignUser, groupView, homeView, mayAdministerSpace, maySetupUsers, memberGroup, member_of_group, member_of_space, owns_space, ownsSpace, resolveHome, setupAdmin, setupMember, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, userView, type GroupMembershipInput, type GroupMembershipResult, type ResolveHomeResult, type SetDefaultSpaceInput, type SetDefaultSpaceResult, type SetupUserInput, type SetupUserResult, type Shell, type SpaceUserAccess, type SpaceUserAccessInput, type SpaceUserAccessResult, type SpaceUserInput, type SpaceUserResult, } from '#schema';
+export { application } from './application.js';
+export { default as runtime } from './runtime.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Group, ORIGIN, S, ShellCore, ShellSchema, Space, User, adminGroup, administers_space, belongsToSpace, default_space, defaultSpace, groupAssignUser, groupCore, groupUnassignUser, groupView, homeView, mayAdministerSpace, maySetupUsers, memberGroup, member_of_group, member_of_space, owns_space, ownsSpace, resolveHome, setupAdmin, setupMember, spaceAddUser, spaceCore, spaceRemoveUser, spaceSetDefault, spaceView, userView, } from '#schema';
+export { application } from './application.js';
+export { default as runtime } from './runtime.js';

package/dist/mutations/group/index.js

@@ -0,0 +1 @@
+export { changeGroupMembership, } from './membership.js';

package/dist/mutations/group/membership.js

@@ -0,0 +1,19 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeGroupMembership = defineMutation()((domain) => ({
+    id: 'shell.group.membership',
+    build(change, mutation) {
+        mutation.expect.query(change.guard);
+        const edge = {
+            class: domain.classes.member_of_group,
+            source: Path.parse(change.user),
+            target: Path.id(change.group),
+        };
+        if (change.present)
+            mutation.createEdge(edge);
+        else
+            mutation.deleteEdge(edge);
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/access.js

@@ -0,0 +1,23 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeSpaceAccess = defineMutation()((domain) => ({
+    id: 'shell.space.access',
+    build(change, mutation) {
+        mutation.expect.query(change.guards.member);
+        mutation.expect.query(change.guards.admin);
+        const source = Path.parse(change.user);
+        const target = Path.id(change.space);
+        const member = { class: domain.classes.member_of_space, source, target };
+        const admin = { class: domain.classes.administers_space, source, target };
+        if (change.removeMember)
+            mutation.deleteEdge(member);
+        if (change.removeAdmin)
+            mutation.deleteEdge(admin);
+        if (change.addMember)
+            mutation.createEdge(member);
+        if (change.addAdmin)
+            mutation.createEdge(admin);
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/default.js

@@ -0,0 +1,23 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+export const changeDefaultSpace = defineMutation()((domain) => ({
+    id: 'shell.space.default',
+    build(change, mutation) {
+        mutation.expect.query(change.guard);
+        const source = Path.id(change.user);
+        if (change.previous !== undefined) {
+            mutation.deleteEdge({
+                class: domain.classes.default_space,
+                source,
+                target: Path.id(change.previous),
+            });
+        }
+        mutation.createEdge({
+            class: domain.classes.default_space,
+            source,
+            target: Path.id(change.next),
+        });
+    },
+    project: () => Object.freeze({ ok: true }),
+    reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
+}));

package/dist/mutations/space/index.js

@@ -0,0 +1,2 @@
+export { changeSpaceAccess, } from './access.js';
+export { changeDefaultSpace, } from './default.js';

package/dist/mutations/user/index.js

@@ -0,0 +1 @@
+export { repairUser } from './repair.js';

package/dist/mutations/user/repair.js

@@ -0,0 +1,83 @@
+import { LocalBinding } from '@astrale-os/sdk/graph';
+import { Path } from '@astrale-os/sdk/graph/path';
+import { defineMutation } from '@astrale-os/sdk/mutation';
+const personalSpace = LocalBinding('personalSpace');
+export const repairUser = defineMutation()((domain) => ({
+    id: 'shell.user.repair',
+    build(repair, mutation) {
+        mutation.expect.query(repair.guards.home);
+        mutation.expect.query(repair.guards.ownedSpaces);
+        mutation.expect.query(repair.guards.groups);
+        mutation.expect.node({
+            node: Path.id(repair.userId),
+            class: domain.classes.User,
+            props: repair.currentDisplayName === undefined
+                ? { absent: ['displayName'] }
+                : { equals: { displayName: repair.currentDisplayName } },
+        });
+        if (repair.displayName !== undefined) {
+            mutation.updateNode({
+                node: Path.id(repair.userId),
+                class: domain.classes.User,
+                props: { set: { displayName: repair.displayName } },
+            });
+        }
+        const home = repair.home.kind === 'create'
+            ? mutation.createNode({
+                as: personalSpace,
+                class: domain.classes.Space,
+                props: { name: repair.home.name },
+            })
+            : Path.id(repair.home.id);
+        if (repair.home.kind === 'existing' && repair.home.name !== undefined) {
+            mutation.expect.node({
+                node: Path.id(repair.home.id),
+                class: domain.classes.Space,
+                props: { equals: { name: repair.home.currentName } },
+            });
+            mutation.updateNode({
+                node: Path.id(repair.home.id),
+                class: domain.classes.Space,
+                props: { set: { name: repair.home.name } },
+            });
+        }
+        if (repair.addOwnership) {
+            mutation.createEdge({
+                class: domain.classes.owns_space,
+                source: Path.id(repair.userId),
+                target: home,
+            });
+        }
+        if (repair.addDefault) {
+            mutation.createEdge({
+                class: domain.classes.default_space,
+                source: Path.id(repair.userId),
+                target: home,
+            });
+        }
+        if (repair.addMember) {
+            mutation.createEdge({
+                class: domain.classes.member_of_group,
+                source: Path.id(repair.userId),
+                target: Path.project(domain.core.nodes.member.ref),
+            });
+        }
+        if (repair.addAdmin) {
+            mutation.createEdge({
+                class: domain.classes.member_of_group,
+                source: Path.id(repair.userId),
+                target: Path.project(domain.core.nodes.admin.ref),
+            });
+        }
+    },
+    project(result, repair) {
+        const personalSpaceId = repair.home.kind === 'existing' ? repair.home.id : result.createdNodes[personalSpace];
+        if (personalSpaceId === undefined) {
+            throw new TypeError('Shell User repair omitted its created personal Space identity.');
+        }
+        return Object.freeze({ ok: true, personalSpaceId });
+    },
+    reject(failure) {
+        return Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown });
+    },
+}));

package/dist/queries/space/access.js

@@ -0,0 +1,12 @@
+import { defineCompositeQuery } from '@astrale-os/sdk/query';
+import { observeAdminSpaces } from './admin.js';
+import { observeMemberSpaces } from './member.js';
+export const observeDirectSpaceAccess = defineCompositeQuery()(() => ({
+    id: 'shell.space.direct-access',
+    compose({ combine, query }, user) {
+        return combine({
+            admin: query('admin', observeAdminSpaces, user),
+            member: query('member', observeMemberSpaces, user),
+        });
+    },
+}));

package/dist/queries/space/admin.js

@@ -0,0 +1,20 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeAdminSpaces = defineQuery()((domain) => ({
+    id: 'shell.space.admin-access',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({
+            via: [domain.classes.administers_space],
+            direction: 'outgoing',
+        });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'direct administered Spaces'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/space/index.js

@@ -0,0 +1,3 @@
+export { observeAdminSpaces } from './admin.js';
+export { observeDirectSpaceAccess } from './access.js';
+export { observeMemberSpaces } from './member.js';

package/dist/queries/space/member.js

@@ -0,0 +1,17 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeMemberSpaces = defineQuery()((domain) => ({
+    id: 'shell.space.member-access',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({ via: [domain.classes.member_of_space], direction: 'outgoing' });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'direct member Spaces'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/user/groups.js

@@ -0,0 +1,17 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeUserGroups = defineQuery()((domain) => ({
+    id: 'shell.user.groups',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const groups = source.expand({ via: [domain.classes.member_of_group], direction: 'outgoing' });
+        return groups.select({ kind: 'nodes', binding: groups.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            groups: queryResult.completeNodeValues(pages, 'Shell User Groups'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/user/home.js

@@ -0,0 +1,21 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeHome = defineQuery()((domain) => ({
+    id: 'shell.user.home',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({
+            via: [domain.classes.default_space],
+            direction: 'outgoing',
+        });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    page: { size: 2 },
+    pagination: { maximumPages: 2 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'Shell User home'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/user/index.js

@@ -0,0 +1,5 @@
+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';

package/dist/queries/user/owned-spaces.js

@@ -0,0 +1,17 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const observeOwnedSpaces = defineQuery()((domain) => ({
+    id: 'shell.user.owned-spaces',
+    build(user) {
+        const source = Query.from({ nodes: [Path.parse(user)] });
+        const spaces = source.expand({ via: [domain.classes.owns_space], direction: 'outgoing' });
+        return spaces.select({ kind: 'nodes', binding: spaces.node, projection: { kind: 'value' } });
+    },
+    pagination: { maximumPages: 64 },
+    project(pages, _user, { ast, complete }) {
+        return Object.freeze({
+            spaces: queryResult.completeNodeValues(pages, 'Shell User owned Spaces'),
+            guard: Object.freeze({ query: ast, equals: complete }),
+        });
+    },
+}));

package/dist/queries/user/profile.js

@@ -0,0 +1,14 @@
+import { Path } from '@astrale-os/sdk/graph/path';
+import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
+export const readUserProfile = defineQuery()(() => ({
+    id: 'shell.user.profile',
+    build(user) {
+        return Query.from({ nodes: [Path.parse(user)] }).select({
+            kind: 'nodes',
+            projection: { kind: 'value' },
+        });
+    },
+    project(result) {
+        return queryResult.exactlyOneNode(result, 'Shell User profile');
+    },
+}));

package/dist/queries/user/setup.js

@@ -0,0 +1,16 @@
+import { defineCompositeQuery } from '@astrale-os/sdk/query';
+import { observeUserGroups } from './groups.js';
+import { observeHome } from './home.js';
+import { observeOwnedSpaces } from './owned-spaces.js';
+import { readUserProfile } from './profile.js';
+export const observeUserSetup = defineCompositeQuery()(() => ({
+    id: 'shell.user.setup',
+    compose({ combine, query }, userId) {
+        return combine({
+            profile: query('profile', readUserProfile, userId),
+            home: query('home', observeHome, userId),
+            ownedSpaces: query('owned-spaces', observeOwnedSpaces, userId),
+            groups: query('groups', observeUserGroups, userId),
+        });
+    },
+}));

package/dist/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { Runtime } from '@astrale-os/sdk/runtime'
+
+declare const runtime: Runtime
+export default runtime

package/dist/runtime.js

@@ -0,0 +1,18 @@
+import { defineRuntime } from '@astrale-os/sdk/runtime';
+import { resolveHomeAction } from './actions/index.js';
+import { addSpaceUserWorkflow, assignGroupUserWorkflow, removeSpaceUserWorkflow, setDefaultSpaceWorkflow, setupAdminWorkflow, setupMemberWorkflow, unassignGroupUserWorkflow, } from './workflows/index.js';
+const runtime = defineRuntime()({
+    integrations: {},
+    initialize: () => ({ providers: {} }),
+    actions: [resolveHomeAction],
+    workflows: [
+        setupAdminWorkflow,
+        setupMemberWorkflow,
+        assignGroupUserWorkflow,
+        unassignGroupUserWorkflow,
+        addSpaceUserWorkflow,
+        removeSpaceUserWorkflow,
+        setDefaultSpaceWorkflow,
+    ],
+});
+export default runtime;