@astrale-domains/issues 0.1.2 → 0.1.3

package/dist/schema/issue/class.d.ts

@@ -52,11 +52,96 @@ export declare const Issue: import("@astrale-os/sdk/schema").NodeClass<{
     }, "kernel.astrale.ai:class.Node", readonly import("@astrale-os/sdk/schema").AnyResolvedClass[], never, never, never, never, never, never>, ...never[]], import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "createdAt", "kernel.astrale.ai:class.Timestamped.property.createdAt"> | import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, true, "updatedAt", "kernel.astrale.ai:class.Timestamped.property.updatedAt">, never, never>];
     readonly properties: {
         readonly reference: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "reference", "self">;
-        readonly status: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"canceled" | "in_progress" | "open" | "resolved", "canceled" | "in_progress" | "open" | "resolved", true, "status", "self">;
+        readonly reporterId: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "reporterId", "self">;
+        readonly assigneeId: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string | undefined, string | undefined, false, "assigneeId", "self">;
+        readonly status: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<unknown, "accepted" | "closed" | "deferred" | "open" | "resolved", false, "status", "self">;
         readonly priority: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<number, number, true, "priority", "self">;
+        readonly archived: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<boolean, boolean, true, "archived", "self">;
     };
-    readonly methods: Readonly<Record<never, never>>;
-    readonly effectiveProperties: (import("@astrale-os/sdk/schema").AuthoredPropertyProjection<number, number, true, "priority", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "reference", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<"canceled" | "in_progress" | "open" | "resolved", "canceled" | "in_progress" | "open" | "resolved", true, "status", "self">) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
+    readonly methods: {
+        readonly update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            title?: string | undefined;
+            description?: string | undefined;
+            priority?: number | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                reference: string;
+                title: string;
+                description: string;
+                status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                priority: number;
+                archived: boolean;
+            };
+        }, "authorized", false, "default">>;
+        readonly transition: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            event: unknown;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "transitioned";
+                issue: {
+                    id: string;
+                    reference: string;
+                    title: string;
+                    description: string;
+                    status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                    priority: number;
+                    archived: boolean;
+                };
+            } | {
+                kind: "rejected";
+                code: "STATE_TRANSITION_ILLEGAL";
+                from: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                event: "accept" | "close" | "defer" | "reopen" | "resolve";
+            };
+        }, "authorized", false, "default">>;
+        readonly assign: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            assigneeId: string | null;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                assigneeId?: string | undefined;
+            };
+        }, "authorized", false, "default">>;
+        readonly setTags: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            tagIds: string[];
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                tagIds: string[];
+            };
+        }, "authorized", false, "default">>;
+        readonly setParent: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            parentId: string | null;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                parentId?: string | undefined;
+            };
+        }, "authorized", false, "default">>;
+        readonly addComment: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            body: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                body: string;
+            };
+        }, "authorized", false, "default">>;
+        readonly archive: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                archived: true;
+            };
+        }, "authorized", false, "default">>;
+    };
+    readonly effectiveProperties: (import("@astrale-os/sdk/schema").AuthoredPropertyProjection<boolean, boolean, true, "archived", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string | undefined, string | undefined, false, "assigneeId", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<number, number, true, "priority", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "reference", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "reporterId", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<unknown, "accepted" | "closed" | "deferred" | "open" | "resolved", false, "status", "self">) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
         readonly name: "description";
         readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
     }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
@@ -69,6 +154,80 @@ export declare const Issue: import("@astrale-os/sdk/schema").NodeClass<{
         readonly name: "updatedAt";
         readonly key: "kernel.astrale.ai:class.Timestamped.property.updatedAt";
     });
-    readonly effectiveInstanceMethods: never;
+    readonly effectiveInstanceMethods: import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+        readonly mode: 'value';
+        readonly value: {
+            issueId: string;
+            archived: true;
+        };
+    }, "authorized", false, "default">>, "archive", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        title?: string | undefined;
+        description?: string | undefined;
+        priority?: number | undefined;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            reference: string;
+            title: string;
+            description: string;
+            status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+            priority: number;
+            archived: boolean;
+        };
+    }, "authorized", false, "default">>, "update", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        event: unknown;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            kind: "transitioned";
+            issue: {
+                id: string;
+                reference: string;
+                title: string;
+                description: string;
+                status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                priority: number;
+                archived: boolean;
+            };
+        } | {
+            kind: "rejected";
+            code: "STATE_TRANSITION_ILLEGAL";
+            from: "accepted" | "closed" | "deferred" | "open" | "resolved";
+            event: "accept" | "close" | "defer" | "reopen" | "resolve";
+        };
+    }, "authorized", false, "default">>, "transition", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        assigneeId: string | null;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            issueId: string;
+            assigneeId?: string | undefined;
+        };
+    }, "authorized", false, "default">>, "assign", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        tagIds: string[];
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            issueId: string;
+            tagIds: string[];
+        };
+    }, "authorized", false, "default">>, "setTags", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        parentId: string | null;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            issueId: string;
+            parentId?: string | undefined;
+        };
+    }, "authorized", false, "default">>, "setParent", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        body: string;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            body: string;
+        };
+    }, "authorized", false, "default">>, "addComment", "self">;
     readonly effectiveStaticMethods: never;
 }>;

package/dist/schema/issue/class.js

@@ -1,17 +1,29 @@
-import { K, nodeClass } from '@astrale-os/sdk/schema';
+import { K, nodeClass, property } from '@astrale-os/sdk/schema';
 import { z } from 'zod';
-const statuses = [
-    'open',
-    'in_progress',
-    'resolved',
-    'canceled',
-];
+import { nodeIdValue } from '../value/index.js';
+import { issueLifecycle } from '../.runtime/states/issue/index.js';
+import { ContributeToIssue } from './contribute-to-issue-policy.js';
+import { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './methods.js';
 export const Issue = nodeClass({
-    description: 'One numbered work item contained by exactly one Tracker.',
+    description: 'One immutable-reference work item contained by exactly one Project.',
+    icon: 'circle-dot',
     extends: [K.classes.Named, K.classes.Descriptable, K.classes.Timestamped],
     properties: {
         reference: z.string().min(1).max(32),
-        status: z.enum(statuses),
+        reporterId: property(nodeIdValue, { visibility: 'private' }),
+        assigneeId: property(nodeIdValue.optional(), { visibility: 'private' }),
+        status: issueLifecycle.stateSchema,
         priority: z.number().int().min(0).max(4),
+        archived: z.boolean(),
     },
+    methods: {
+        update: updateIssueMethod,
+        transition: transitionIssueMethod,
+        assign: assignIssueMethod,
+        setTags: setIssueTagsMethod,
+        setParent: setIssueParentMethod,
+        addComment: addIssueCommentMethod,
+        archive: archiveIssueMethod,
+    },
+    policies: { read: () => ContributeToIssue },
 });

package/dist/schema/issue/contribute-to-issue-policy.d.ts

@@ -0,0 +1 @@
+export declare const ContributeToIssue: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/issue/contribute-to-issue-policy.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_has_member, project_owned_by } from '../project/index.js';
+import { project_contains_issue } from './relationships.js';
+export const ContributeToIssue = policy({
+    description: 'The caller owns or belongs to the Project containing this Issue.',
+    match: ({ allOf, anyOf, edge, exists, object, subject }) => exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(anyOf(edge({ source: subject, class: () => project_owned_by, target: project }), edge({ source: subject, class: () => project_has_member, target: project })), edge({ source: project, class: () => project_contains_issue, target: object }));
+    }),
+});

package/dist/schema/issue/index.d.ts

@@ -1,2 +1,4 @@
 export { Issue } from './class.js';
-export { issue_assigned_to, issue_blocks, issue_duplicates, issue_relates_to, issue_reported_by, issue_subtask_of, tracker_contains_issue, } from './relationships.js';
+export { ContributeToIssue } from './contribute-to-issue-policy.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './relationships.js';
+export { TraverseIssueAssignee, TraverseIssueComment, TraverseIssueParent, TraverseIssueReporter, TraverseIssueTag, } from './traverse-issue-relationship-policy.js';

package/dist/schema/issue/index.js

@@ -1,2 +1,4 @@
 export { Issue } from './class.js';
-export { issue_assigned_to, issue_blocks, issue_duplicates, issue_relates_to, issue_reported_by, issue_subtask_of, tracker_contains_issue, } from './relationships.js';
+export { ContributeToIssue } from './contribute-to-issue-policy.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './relationships.js';
+export { TraverseIssueAssignee, TraverseIssueComment, TraverseIssueParent, TraverseIssueReporter, TraverseIssueTag, } from './traverse-issue-relationship-policy.js';

package/dist/schema/issue/methods.js

@@ -0,0 +1,66 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { commentValue, issueValue, nodeIdValue } from '../value/index.js';
+import { issueLifecycle } from '../.runtime/states/issue/index.js';
+import { ContributeToIssue } from './contribute-to-issue-policy.js';
+export const updateIssueMethod = method({
+    description: 'Update mutable Issue fields.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({
+        title: z.string().min(1).max(200).optional(),
+        description: z.string().max(50_000).optional(),
+        priority: z.number().int().min(0).max(4).optional(),
+    }),
+    output: issueValue,
+});
+export const transitionIssueMethod = method({
+    description: 'Apply one legal Issue lifecycle event.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ event: issueLifecycle.eventSchema }),
+    output: z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('transitioned'), issue: issueValue }),
+        z.strictObject({
+            kind: z.literal('rejected'),
+            code: z.literal('STATE_TRANSITION_ILLEGAL'),
+            from: issueLifecycle.stateSchema,
+            event: issueLifecycle.eventSchema,
+        }),
+    ]),
+});
+export const assignIssueMethod = method({
+    description: 'Assign this Issue to a Project participant or clear its assignee.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ assigneeId: nodeIdValue.nullable() }),
+    output: z.strictObject({ issueId: nodeIdValue, assigneeId: nodeIdValue.optional() }),
+});
+export const setIssueTagsMethod = method({
+    description: 'Replace this Issue Tag set with an exact Project-local set.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ tagIds: z.array(nodeIdValue).max(128) }),
+    output: z.strictObject({ issueId: nodeIdValue, tagIds: z.array(nodeIdValue) }),
+});
+export const setIssueParentMethod = method({
+    description: 'Set or clear this Issue parent inside the same Project.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ parentId: nodeIdValue.nullable() }),
+    output: z.strictObject({ issueId: nodeIdValue, parentId: nodeIdValue.optional() }),
+});
+export const addIssueCommentMethod = method({
+    description: 'Add one authored Comment to this Issue.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ body: z.string().min(1).max(50_000) }),
+    output: commentValue,
+});
+export const archiveIssueMethod = method({
+    description: 'Archive this Issue without deleting its discussion or relationships.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({}),
+    output: z.strictObject({ issueId: nodeIdValue, archived: z.literal(true) }),
+});

package/dist/schema/issue/relationships.d.ts

@@ -1,10 +1,10 @@
-export declare const tracker_contains_issue: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+export declare const project_contains_issue: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
     readonly depth: 0;
     readonly abstract: false;
     readonly extends: readonly [];
     readonly properties: never;
     readonly source: {
-        readonly as: "tracker";
+        readonly as: "project";
         readonly outgoing: "0..*";
     };
     readonly target: {
@@ -20,76 +20,28 @@ export declare const issue_reported_by: import("@astrale-os/sdk/schema").Directe
     readonly extends: readonly [];
     readonly properties: never;
     readonly source: {
-        readonly as: "issue";
-        readonly outgoing: "1";
-    };
-    readonly target: {
         readonly as: "reporter";
-        readonly incoming: "0..*";
-    };
-    readonly constraints: Record<never, never>;
-    readonly effectiveProperties: never;
-}>;
-export declare const issue_assigned_to: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly depth: 0;
-    readonly abstract: false;
-    readonly extends: readonly [];
-    readonly properties: never;
-    readonly source: {
-        readonly as: "issue";
-        readonly outgoing: "0..1";
-    };
-    readonly target: {
-        readonly as: "assignee";
-        readonly incoming: "0..*";
-    };
-    readonly constraints: Record<never, never>;
-    readonly effectiveProperties: never;
-}>;
-export declare const issue_blocks: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly depth: 0;
-    readonly abstract: false;
-    readonly extends: readonly [];
-    readonly properties: never;
-    readonly source: {
-        readonly as: "source";
-        readonly outgoing: "0..*";
-    };
-    readonly target: {
-        readonly as: "target";
-        readonly incoming: "0..*";
-    };
-    readonly constraints: Record<never, never>;
-    readonly effectiveProperties: never;
-}>;
-export declare const issue_duplicates: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
-    readonly depth: 0;
-    readonly abstract: false;
-    readonly extends: readonly [];
-    readonly properties: never;
-    readonly source: {
-        readonly as: "source";
         readonly outgoing: "0..*";
     };
     readonly target: {
-        readonly as: "target";
-        readonly incoming: "0..*";
+        readonly as: "issue";
+        readonly incoming: "1";
     };
     readonly constraints: Record<never, never>;
     readonly effectiveProperties: never;
 }>;
-export declare const issue_relates_to: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+export declare const issue_assigned_to: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
     readonly depth: 0;
     readonly abstract: false;
     readonly extends: readonly [];
     readonly properties: never;
     readonly source: {
-        readonly as: "source";
+        readonly as: "assignee";
         readonly outgoing: "0..*";
     };
     readonly target: {
-        readonly as: "target";
-        readonly incoming: "0..*";
+        readonly as: "issue";
+        readonly incoming: "0..1";
     };
     readonly constraints: Record<never, never>;
     readonly effectiveProperties: never;
@@ -100,13 +52,16 @@ export declare const issue_subtask_of: import("@astrale-os/sdk/schema").Directed
     readonly extends: readonly [];
     readonly properties: never;
     readonly source: {
-        readonly as: "source";
-        readonly outgoing: "0..*";
+        readonly as: "child";
+        readonly outgoing: "0..1";
     };
     readonly target: {
-        readonly as: "target";
+        readonly as: "parent";
         readonly incoming: "0..*";
     };
-    readonly constraints: Record<never, never>;
+    readonly constraints: {
+        readonly noSelf: true;
+        readonly acyclic: true;
+    };
     readonly effectiveProperties: never;
 }>;

package/dist/schema/issue/relationships.js

@@ -1,23 +1,29 @@
 import { K, edgeClass } from '@astrale-os/sdk/schema';
-import { Tracker } from '#schema/tracker';
+import { Project, TraverseProjectIssue } from '../project/index.js';
 import { Issue } from './class.js';
-export const tracker_contains_issue = edgeClass.directed({
-    source: { as: 'tracker', accepts: [Tracker], outgoing: '0..*' },
-    target: { as: 'issue', accepts: [Issue], incoming: '1' },
+import { TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, } from './traverse-issue-relationship-policy.js';
+export const project_contains_issue = edgeClass.directed({
+    description: 'One Project contains and numbers one Issue.',
+    source: { as: 'project', accepts: [() => Project], outgoing: '0..*' },
+    target: { as: 'issue', accepts: [() => Issue], incoming: '1' },
+    policies: { traverse: () => TraverseProjectIssue },
 });
 export const issue_reported_by = edgeClass.directed({
-    source: { as: 'issue', accepts: [Issue], outgoing: '1' },
-    target: { as: 'reporter', accepts: [K.classes.Identity], incoming: '0..*' },
+    description: 'The immutable reporter of one Issue.',
+    source: { as: 'reporter', accepts: [K.classes.Identity], outgoing: '0..*' },
+    target: { as: 'issue', accepts: [() => Issue], incoming: '1' },
+    policies: { traverse: () => TraverseIssueReporter },
 });
 export const issue_assigned_to = edgeClass.directed({
-    source: { as: 'issue', accepts: [Issue], outgoing: '0..1' },
-    target: { as: 'assignee', accepts: [K.classes.Identity], incoming: '0..*' },
+    description: 'The optional current assignee of one Issue.',
+    source: { as: 'assignee', accepts: [K.classes.Identity], outgoing: '0..*' },
+    target: { as: 'issue', accepts: [() => Issue], incoming: '0..1' },
+    policies: { traverse: () => TraverseIssueAssignee },
 });
-const relation = () => edgeClass.directed({
-    source: { as: 'source', accepts: [Issue], outgoing: '0..*' },
-    target: { as: 'target', accepts: [Issue], incoming: '0..*' },
+export const issue_subtask_of = edgeClass.directed({
+    description: 'One Issue is an acyclic subtask of at most one Issue in the same Project.',
+    source: { as: 'child', accepts: [() => Issue], outgoing: '0..1' },
+    target: { as: 'parent', accepts: [() => Issue], incoming: '0..*' },
+    constraints: { noSelf: true, acyclic: true },
+    policies: { traverse: () => TraverseIssueParent },
 });
-export const issue_blocks = relation();
-export const issue_duplicates = relation();
-export const issue_relates_to = relation();
-export const issue_subtask_of = relation();

package/dist/schema/issue/traverse-issue-relationship-policy.d.ts

@@ -0,0 +1,5 @@
+export declare const TraverseIssueReporter: import("@astrale-os/sdk/schema").Policy;
+export declare const TraverseIssueAssignee: import("@astrale-os/sdk/schema").Policy;
+export declare const TraverseIssueParent: import("@astrale-os/sdk/schema").Policy;
+export declare const TraverseIssueComment: import("@astrale-os/sdk/schema").Policy;
+export declare const TraverseIssueTag: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/issue/traverse-issue-relationship-policy.js

@@ -0,0 +1,55 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { issue_has_comment } from '../comment/index.js';
+import { Project, project_has_member, project_owned_by } from '../project/index.js';
+import { issue_tagged_with } from '../tag/index.js';
+import { issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './relationships.js';
+export const TraverseIssueReporter = policy({
+    description: 'Issue reporter relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_reported_by, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_reported_by, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});
+export const TraverseIssueAssignee = policy({
+    description: 'Issue assignment relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_assigned_to, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_assigned_to, target }), edge({ source: project, class: () => project_contains_issue, target }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});
+export const TraverseIssueParent = policy({
+    description: 'Issue parent relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_subtask_of, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_subtask_of, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});
+export const TraverseIssueComment = policy({
+    description: 'Issue Comment containment is visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_has_comment, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_has_comment, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});
+export const TraverseIssueTag = policy({
+    description: 'Issue Tag relationships are visible only inside the containing Project.',
+    match: ({ allOf, anyOf, edge, exists, source, subject, target }) => anyOf(exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_tagged_with, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_owned_by, target: project }));
+    }), exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source, class: () => issue_tagged_with, target }), edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: subject, class: () => project_has_member, target: project }));
+    })),
+});