@astrale-domains/shell 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/mutations/group/membership.js

@@ -1,21 +1,19 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineMutation } from '@astrale-os/sdk/mutation';
-export function changeGroupMembership(domain) {
-    return defineMutation({
-        id: 'shell.group.membership',
-        change(mutation, change) {
-            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 }),
-    });
-}
+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

@@ -1,25 +1,23 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineMutation } from '@astrale-os/sdk/mutation';
-export function changeSpaceAccess(domain) {
-    return defineMutation({
-        id: 'shell.space.access',
-        change(mutation, change) {
-            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 }),
-    });
-}
+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

@@ -1,25 +1,23 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { defineMutation } from '@astrale-os/sdk/mutation';
-export function changeDefaultSpace(domain) {
-    return defineMutation({
-        id: 'shell.space.default',
-        change(mutation, change) {
-            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({
+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.next),
+                target: Path.id(change.previous),
             });
-        },
-        project: () => Object.freeze({ ok: true }),
-        reject: (failure) => Object.freeze({ ok: false, code: failure.code, outcomeKnown: failure.outcomeKnown }),
-    });
-}
+        }
+        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/user/repair.js

@@ -2,84 +2,82 @@ 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 function repairUser(domain) {
-    return defineMutation({
-        id: 'shell.user.repair',
-        change(mutation, repair) {
-            mutation.expect.query(repair.guards.home);
-            mutation.expect.query(repair.guards.ownedSpaces);
-            mutation.expect.query(repair.guards.groups);
-            mutation.expect.node({
+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: repair.currentDisplayName === undefined
-                    ? { absent: ['displayName'] }
-                    : { equals: { displayName: repair.currentDisplayName } },
+                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),
             });
-            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 });
-        },
-    });
-}
+        }
+    },
+    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

@@ -1,14 +1,12 @@
 import { defineCompositeQuery } from '@astrale-os/sdk/query';
 import { observeAdminSpaces } from './admin.js';
 import { observeMemberSpaces } from './member.js';
-export function observeDirectSpaceAccess(domain) {
-    return defineCompositeQuery({
-        id: 'shell.space.direct-access',
-        compose({ combine, query }, user) {
-            return combine({
-                admin: query('admin', observeAdminSpaces(domain), user),
-                member: query('member', observeMemberSpaces(domain), user),
-            });
-        },
-    });
-}
+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

@@ -1,27 +1,20 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
-function adminSpacesQuery(domain) {
-    return {
-        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' } });
-        },
-    };
-}
-export function observeAdminSpaces(domain) {
-    return defineQuery({
-        id: 'shell.space.admin-access',
-        ...adminSpacesQuery(domain),
-        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 }),
-            });
-        },
-    });
-}
+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/member.js

@@ -1,24 +1,17 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
-function memberSpacesQuery(domain) {
-    return {
-        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' } });
-        },
-    };
-}
-export function observeMemberSpaces(domain) {
-    return defineQuery({
-        id: 'shell.space.member-access',
-        ...memberSpacesQuery(domain),
-        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 }),
-            });
-        },
-    });
-}
+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

@@ -1,24 +1,17 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
-function groupsQuery(domain) {
-    return {
-        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' } });
-        },
-    };
-}
-export function observeUserGroups(domain) {
-    return defineQuery({
-        id: 'shell.user.groups',
-        ...groupsQuery(domain),
-        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 }),
-            });
-        },
-    });
-}
+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

@@ -1,28 +1,21 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
-function homeQuery(domain) {
-    return {
-        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' } });
-        },
-    };
-}
-export function observeHome(domain) {
-    return defineQuery({
-        id: 'shell.user.home',
-        ...homeQuery(domain),
-        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 }),
-            });
-        },
-    });
-}
+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/owned-spaces.js

@@ -1,24 +1,17 @@
 import { Path } from '@astrale-os/sdk/graph/path';
 import { Query, defineQuery, queryResult } from '@astrale-os/sdk/query';
-function ownedSpacesQuery(domain) {
-    return {
-        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' } });
-        },
-    };
-}
-export function observeOwnedSpaces(domain) {
-    return defineQuery({
-        id: 'shell.user.owned-spaces',
-        ...ownedSpacesQuery(domain),
-        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 }),
-            });
-        },
-    });
-}
+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

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

package/dist/queries/user/setup.js

@@ -3,16 +3,14 @@ import { observeUserGroups } from './groups.js';
 import { observeHome } from './home.js';
 import { observeOwnedSpaces } from './owned-spaces.js';
 import { readUserProfile } from './profile.js';
-export function observeUserSetup(domain) {
-    return defineCompositeQuery({
-        id: 'shell.user.setup',
-        compose({ combine, query }, userId) {
-            return combine({
-                profile: query('profile', readUserProfile, userId),
-                home: query('home', observeHome(domain), userId),
-                ownedSpaces: query('owned-spaces', observeOwnedSpaces(domain), userId),
-                groups: query('groups', observeUserGroups(domain), userId),
-            });
-        },
-    });
-}
+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),
+        });
+    },
+}));