@astrale-domains/issues 0.1.2 → 0.1.4

package/dist/schema/modules/issue/classes/issue-assigned-to.js

@@ -0,0 +1,9 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseIssueAssignee } from '../policies/traverse-issue-assignee.js';
+import { Issue } from './issue.js';
+export const issue_assigned_to = edgeClass.directed({
+    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 },
+});

package/dist/schema/modules/issue/classes/issue-reported-by.d.ts

@@ -0,0 +1,16 @@
+export declare const issue_reported_by: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "reporter";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "issue";
+        readonly incoming: "1";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/issue/classes/issue-reported-by.js

@@ -0,0 +1,9 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseIssueReporter } from '../policies/traverse-issue-reporter.js';
+import { Issue } from './issue.js';
+export const issue_reported_by = edgeClass.directed({
+    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 },
+});

package/dist/schema/modules/issue/classes/issue-subtask-of.d.ts

@@ -0,0 +1,19 @@
+export declare const issue_subtask_of: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "child";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "parent";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
+        readonly acyclic: true;
+    };
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/issue/classes/issue-subtask-of.js

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseIssueParent } from '../policies/traverse-issue-parent.js';
+import { Issue } from './issue.js';
+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 },
+});

package/dist/schema/modules/issue/classes/issue.d.ts

@@ -0,0 +1,258 @@
+export declare const Issue: import("@astrale-os/sdk/schema").NodeClass<{
+    readonly depth: 1;
+    readonly abstract: false;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Named", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "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, "name", "kernel.astrale.ai:class.Named.property.name">, 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, "name", "kernel.astrale.ai:class.Named.property.name">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Descriptable", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "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, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never, import("@astrale-os/sdk/schema").PropertyProjection<string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null, false, "description", "kernel.astrale.ai:class.Descriptable.property.description">, never, never>, import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Timestamped"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "kernel.astrale.ai:class.Timestamped", readonly [import("@astrale-os/sdk/schema").ClassProjection<"node", import("@astrale-os/sdk/schema").NodeClassDefinition & {
+        readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+            readonly origin: "kernel.astrale.ai";
+        };
+        readonly kind: 'node';
+        readonly abstract: true;
+    }, import("@astrale-os/sdk/schema").ClassRef & import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
+        readonly origin: "kernel.astrale.ai";
+    }, "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 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", true, "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 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", true, "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> & {
+        readonly name: "createdAt";
+        readonly key: "kernel.astrale.ai:class.Timestamped.property.createdAt";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "name";
+        readonly key: "kernel.astrale.ai:class.Named.property.name";
+    }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
+        readonly name: "updatedAt";
+        readonly key: "kernel.astrale.ai:class.Timestamped.property.updatedAt";
+    });
+    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;
+}> & import("@astrale-os/sdk/schema").StateClass<Readonly<Omit<Readonly<Record<never, never>>, "status"> & {
+    readonly status: import("@astrale-os/sdk/state").StateMachine<{
+        readonly open: {
+            readonly accept: "accepted";
+            readonly defer: "deferred";
+            readonly close: "closed";
+        };
+        readonly accepted: {
+            readonly resolve: "resolved";
+            readonly defer: "deferred";
+            readonly close: "closed";
+        };
+        readonly deferred: {
+            readonly reopen: "open";
+            readonly accept: "accepted";
+            readonly close: "closed";
+        };
+        readonly resolved: {
+            readonly reopen: "open";
+            readonly close: "closed";
+        };
+        readonly closed: {
+            readonly reopen: "open";
+        };
+    }, "open">;
+}>>;

package/dist/schema/modules/issue/classes/issue.js

@@ -0,0 +1,35 @@
+import { K, nodeClass, property, stateProperty } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { issueStatus } from '../../../.runtime/states/issue/index.js';
+import { addIssueCommentMethod } from '../functions/add-issue-comment.js';
+import { archiveIssueMethod } from '../functions/archive-issue.js';
+import { assignIssueMethod } from '../functions/assign-issue.js';
+import { setIssueParentMethod } from '../functions/set-issue-parent.js';
+import { setIssueTagsMethod } from '../functions/set-issue-tags.js';
+import { transitionIssueMethod } from '../functions/transition-issue.js';
+import { updateIssueMethod } from '../functions/update-issue.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+export const Issue = nodeClass({
+    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),
+        reporterId: property(nodeIdValue, {}),
+        assigneeId: property(nodeIdValue.optional(), {}),
+        status: stateProperty(issueStatus),
+        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/modules/issue/classes/project-contains-issue.d.ts

@@ -0,0 +1,16 @@
+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: "project";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "issue";
+        readonly incoming: "1";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/issue/classes/project-contains-issue.js

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { Project } from '../../project/index.js';
+import { TraverseProjectIssue } from '../policies/traverse-project-issue.js';
+import { Issue } from './issue.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 },
+});

package/dist/schema/modules/issue/functions/add-issue-comment.d.ts

@@ -0,0 +1,9 @@
+export declare const addIssueCommentMethod: 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">>;

package/dist/schema/modules/issue/functions/add-issue-comment.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { commentValue } from '../../comment/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+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,
+});

package/dist/schema/modules/issue/functions/archive-issue.d.ts

@@ -0,0 +1,7 @@
+export declare const archiveIssueMethod: 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">>;

package/dist/schema/modules/issue/functions/archive-issue.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+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/modules/issue/functions/assign-issue.d.ts

@@ -0,0 +1,9 @@
+export declare const assignIssueMethod: 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">>;

package/dist/schema/modules/issue/functions/assign-issue.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+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() }),
+});

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

@@ -0,0 +1,7 @@
+export { addIssueCommentMethod } from './add-issue-comment.js';
+export { archiveIssueMethod } from './archive-issue.js';
+export { assignIssueMethod } from './assign-issue.js';
+export { setIssueParentMethod } from './set-issue-parent.js';
+export { setIssueTagsMethod } from './set-issue-tags.js';
+export { transitionIssueMethod } from './transition-issue.js';
+export { updateIssueMethod } from './update-issue.js';

package/dist/schema/modules/issue/functions/index.js

@@ -0,0 +1,7 @@
+export { addIssueCommentMethod } from './add-issue-comment.js';
+export { archiveIssueMethod } from './archive-issue.js';
+export { assignIssueMethod } from './assign-issue.js';
+export { setIssueParentMethod } from './set-issue-parent.js';
+export { setIssueTagsMethod } from './set-issue-tags.js';
+export { transitionIssueMethod } from './transition-issue.js';
+export { updateIssueMethod } from './update-issue.js';

package/dist/schema/modules/issue/functions/set-issue-parent.d.ts

@@ -0,0 +1,9 @@
+export declare const setIssueParentMethod: 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">>;

package/dist/schema/modules/issue/functions/set-issue-parent.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+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() }),
+});

package/dist/schema/modules/issue/functions/set-issue-tags.d.ts

@@ -0,0 +1,9 @@
+export declare const setIssueTagsMethod: 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">>;

package/dist/schema/modules/issue/functions/set-issue-tags.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+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) }),
+});

package/dist/schema/modules/issue/functions/transition-issue.d.ts

@@ -0,0 +1,22 @@
+export declare const transitionIssueMethod: 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">>;

package/dist/schema/modules/issue/functions/transition-issue.js

@@ -0,0 +1,20 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { issueStatus } from '../../../.runtime/states/issue/index.js';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+import { issueValue } from '../types/issue.js';
+export const transitionIssueMethod = method({
+    description: 'Apply one legal Issue status event.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ContributeToIssue, self),
+    input: z.strictObject({ event: issueStatus.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: issueStatus.stateSchema,
+            event: issueStatus.eventSchema,
+        }),
+    ]),
+});

package/dist/schema/modules/issue/functions/update-issue.d.ts

@@ -0,0 +1,16 @@
+export declare const updateIssueMethod: 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">>;

package/dist/schema/modules/issue/functions/update-issue.js

@@ -0,0 +1,15 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ContributeToIssue } from '../policies/contribute-to-issue.js';
+import { issueValue } from '../types/issue.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,
+});

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

@@ -0,0 +1,4 @@
+export { issueValue } from './types/index.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
+export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

package/dist/schema/modules/issue/index.js

@@ -0,0 +1,4 @@
+export { issueValue } from './types/index.js';
+export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
+export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

package/dist/schema/modules/issue/policies/contribute-to-issue.d.ts

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