@astrale-domains/shell 0.1.0-beta.26 → 0.1.0-beta.28

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

@@ -4,14 +4,14 @@ export const readGroupMembershipEndpoints = defineQuery()(() => ({
     id: 'shell.group.membership.endpoints',
     page: { size: 2 },
     pagination: { maximumPages: 2 },
-    build: ({ user, group }) => Query.from({ nodes: [Path.id(user), Path.id(group)] }).select({
+    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.user) && ids.includes(input.group),
+            visible: ids.includes(input.member) && ids.includes(input.group),
             guard: { query: ast, equals: complete },
         };
     },

package/dist/queries/group/read-group-membership.d.ts

@@ -0,0 +1,90 @@
+import type { NodeId } from '@astrale-os/sdk/graph/node';
+import type { QueryPrecondition } from '@astrale-os/sdk/mutation';
+import { type QueryEdgeAST } from '@astrale-os/sdk/query';
+export interface GroupMembership {
+    readonly member: NodeId;
+    readonly group: NodeId;
+}
+export interface GroupMembershipState {
+    readonly membership: boolean;
+    readonly authority: boolean;
+}
+export interface GroupMembershipObservation extends GroupMembershipState {
+    readonly guard: QueryPrecondition<QueryEdgeAST>;
+}
+export declare const readGroupMembership: import("@astrale-os/sdk/query").SingleQueryDefinition<import("@astrale-os/sdk/schema").AuthoredDomain<"shell.astrale.ai", readonly ["kernel.astrale.ai", import("@astrale-os/sdk/schema").KernelSchema] | readonly ["shell.astrale.ai", {
+    readonly classes: {
+        readonly User: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">];
+            readonly properties: {
+                readonly creationKey: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            readonly methods: {
+                readonly invite: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    user: string;
+                    email: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        invitationId: string;
+                        user: string;
+                        state: "accepted" | "cancelled" | "completed" | "expired" | "failed" | "pending" | "registered" | "registering";
+                    };
+                }, "authorized", true, false>>;
+            };
+        }>;
+        readonly Group: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+            readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+            readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Identity">, import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">];
+            readonly methods: {
+                readonly assignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false>>;
+                readonly unassignMember: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    member: string;
+                    group: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: Record<string, never>;
+                }, "authorized", true, false>>;
+            };
+        }>;
+        readonly member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "member";
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "group";
+                readonly incoming: "0..*";
+            };
+            readonly constraints: Record<never, never>;
+            readonly effectiveProperties: never;
+        }>;
+    };
+    readonly policies: {
+        readonly belongsToGroup: import("@astrale-os/sdk/schema").Policy;
+        readonly ownsClass: import("@astrale-os/sdk/schema").Policy;
+        readonly administersShellClass: import("@astrale-os/sdk/schema").Policy;
+    };
+    readonly views: {
+        readonly application: import("@astrale-os/sdk/schema").View;
+    };
+    readonly core: {
+        readonly nodes: {
+            readonly admin: import("@astrale-os/sdk/schema").CoreNode;
+            readonly member: import("@astrale-os/sdk/schema").CoreNode;
+        };
+    };
+}, {
+    readonly kernel: "kernel.astrale.ai";
+}]>, GroupMembership, GroupMembershipObservation>;

package/dist/queries/group/{read-user-group-membership.js → read-group-membership.js}

@@ -1,12 +1,12 @@
 import { Query, defineQuery, queryResult, } from '@astrale-os/sdk/query';
 export const readGroupMembership = defineQuery()((domain) => ({
     id: 'shell.group.membership.read',
-    build({ user, group }) {
+    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: user } })
+            .filter({ binding: edges.source, predicate: { kind: 'identity.equal', identity: member } })
             .filter({ binding: edges.target, predicate: { kind: 'identity.equal', identity: group } })
             .select({
             kind: 'edges',