@astrale-domains/issues 0.1.2 → 0.1.4

package/dist/schema/modules/project/functions/create-project-tag.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { tagValue } from '../../tag/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const createProjectTagMethod = method({
+    description: 'Create one Project-local Tag.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        name: z.string().min(1).max(64),
+        color: z.string().optional(),
+    }),
+    output: tagValue,
+});

package/dist/schema/modules/project/functions/create-project.d.ts

@@ -0,0 +1,14 @@
+export declare const createProjectMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    key: string;
+    name: string;
+    description?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        key: string;
+        name: string;
+        description: string;
+        archived: boolean;
+    };
+}, "authenticated", true, "default">>;

package/dist/schema/modules/project/functions/create-project.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { projectValue } from '../types/project.js';
+export const createProjectMethod = method({
+    description: 'Create one Project owned by the authenticated caller.',
+    static: true,
+    auth: 'authenticated',
+    input: z.strictObject({
+        key: z.string().min(1).max(40),
+        name: z.string().min(1).max(120),
+        description: z.string().max(5_000).optional(),
+    }),
+    output: projectValue,
+});

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

@@ -0,0 +1,8 @@
+export { addProjectMemberMethod } from './add-project-member.js';
+export { archiveProjectMethod } from './archive-project.js';
+export { createProjectIssueMethod } from './create-project-issue.js';
+export { createProjectTagMethod } from './create-project-tag.js';
+export { createProjectMethod } from './create-project.js';
+export { listProjectsMethod } from './list-projects.js';
+export { removeProjectMemberMethod } from './remove-project-member.js';
+export { updateProjectMethod } from './update-project.js';

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

@@ -0,0 +1,8 @@
+export { addProjectMemberMethod } from './add-project-member.js';
+export { archiveProjectMethod } from './archive-project.js';
+export { createProjectIssueMethod } from './create-project-issue.js';
+export { createProjectTagMethod } from './create-project-tag.js';
+export { createProjectMethod } from './create-project.js';
+export { listProjectsMethod } from './list-projects.js';
+export { removeProjectMemberMethod } from './remove-project-member.js';
+export { updateProjectMethod } from './update-project.js';

package/dist/schema/modules/project/functions/list-projects.d.ts

@@ -0,0 +1,25 @@
+export declare const listProjectsMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        projects: {
+            id: string;
+            key: string;
+            name: string;
+            description: string;
+            archived: boolean;
+            issues: {
+                id: string;
+                reference: string;
+                title: string;
+                description: string;
+                status: "accepted" | "closed" | "deferred" | "open" | "resolved";
+                priority: number;
+                archived: boolean;
+                comments: {
+                    id: string;
+                    body: string;
+                }[];
+            }[];
+        }[];
+    };
+}, "authenticated", true, "default">>;

package/dist/schema/modules/project/functions/list-projects.js

@@ -0,0 +1,16 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { commentValue } from '../../comment/index.js';
+import { issueValue } from '../../issue/index.js';
+import { projectValue } from '../types/project.js';
+export const listProjectsMethod = method({
+    description: 'List the caller-visible Projects with their Issues.',
+    static: true,
+    auth: 'authenticated',
+    input: z.strictObject({}),
+    output: z.strictObject({
+        projects: z.array(projectValue.extend({
+            issues: z.array(issueValue.extend({ comments: z.array(commentValue) })),
+        })),
+    }),
+});

package/dist/schema/modules/project/functions/remove-project-member.d.ts

@@ -0,0 +1,10 @@
+export declare const removeProjectMemberMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    memberId: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        projectId: string;
+        memberId: string;
+        changed: boolean;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/project/functions/remove-project-member.js

@@ -0,0 +1,12 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+import { membershipChangeValue } from '../types/membership-change.js';
+export const removeProjectMemberMethod = method({
+    description: 'Remove one unassigned Identity from Project membership.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({ memberId: nodeIdValue }),
+    output: membershipChangeValue,
+});

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

@@ -0,0 +1,13 @@
+export declare const updateProjectMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        key: string;
+        name: string;
+        description: string;
+        archived: boolean;
+    };
+}, "authorized", false, "default">>;

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

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ManageProject } from '../policies/manage-project.js';
+import { projectValue } from '../types/project.js';
+export const updateProjectMethod = method({
+    description: 'Update mutable Project metadata.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        name: z.string().min(1).max(120).optional(),
+        description: z.string().max(5_000).optional(),
+    }),
+    output: projectValue,
+});

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

@@ -0,0 +1,4 @@
+export { membershipChangeValue, projectValue } from './types/index.js';
+export { project_has_member, project_owned_by, Project } from './classes/index.js';
+export { addProjectMemberMethod, archiveProjectMethod, createProjectIssueMethod, createProjectTagMethod, createProjectMethod, listProjectsMethod, removeProjectMemberMethod, updateProjectMethod, } from './functions/index.js';
+export { ContributeToProject, ManageProject, TraverseProjectMember, TraverseProjectOwner, } from './policies/index.js';

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

@@ -0,0 +1,4 @@
+export { membershipChangeValue, projectValue } from './types/index.js';
+export { project_has_member, project_owned_by, Project } from './classes/index.js';
+export { addProjectMemberMethod, archiveProjectMethod, createProjectIssueMethod, createProjectTagMethod, createProjectMethod, listProjectsMethod, removeProjectMemberMethod, updateProjectMethod, } from './functions/index.js';
+export { ContributeToProject, ManageProject, TraverseProjectMember, TraverseProjectOwner, } from './policies/index.js';

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

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

package/dist/schema/modules/project/policies/contribute-to-project.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member } from '../classes/project-has-member.js';
+import { project_owned_by } from '../classes/project-owned-by.js';
+export const ContributeToProject = policy({
+    description: 'The caller owns or is a member of this Project.',
+    match: ({ anyOf, edge, object, subject }) => anyOf(edge({ source: subject, class: () => project_owned_by, target: object }), edge({ source: subject, class: () => project_has_member, target: object })),
+});

package/dist/schema/modules/project/policies/index.d.ts

@@ -0,0 +1,4 @@
+export { ContributeToProject } from './contribute-to-project.js';
+export { ManageProject } from './manage-project.js';
+export { TraverseProjectMember } from './traverse-project-member.js';
+export { TraverseProjectOwner } from './traverse-project-owner.js';

package/dist/schema/modules/project/policies/index.js

@@ -0,0 +1,4 @@
+export { ContributeToProject } from './contribute-to-project.js';
+export { ManageProject } from './manage-project.js';
+export { TraverseProjectMember } from './traverse-project-member.js';
+export { TraverseProjectOwner } from './traverse-project-owner.js';

package/dist/schema/modules/project/policies/manage-project.d.ts

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

package/dist/schema/modules/project/policies/manage-project.js

@@ -0,0 +1,6 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_owned_by } from '../classes/project-owned-by.js';
+export const ManageProject = policy({
+    description: 'The caller is the exact owner of this Project.',
+    match: ({ edge, object, subject }) => edge({ source: subject, class: () => project_owned_by, target: object }),
+});

package/dist/schema/modules/project/policies/traverse-project-member.d.ts

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

package/dist/schema/modules/project/policies/traverse-project-member.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member } from '../classes/project-has-member.js';
+import { project_owned_by } from '../classes/project-owned-by.js';
+export const TraverseProjectMember = policy({
+    description: 'Project membership is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_has_member, target }), edge({ source: subject, class: () => project_owned_by, target })), allOf(edge({ source, class: () => project_has_member, target }), edge({ source: subject, class: () => project_has_member, target }))),
+});

package/dist/schema/modules/project/policies/traverse-project-owner.d.ts

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

package/dist/schema/modules/project/policies/traverse-project-owner.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member } from '../classes/project-has-member.js';
+import { project_owned_by } from '../classes/project-owned-by.js';
+export const TraverseProjectOwner = policy({
+    description: 'Project ownership is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_owned_by, target }), edge({ source: subject, class: () => project_owned_by, target })), allOf(edge({ source, class: () => project_owned_by, target }), edge({ source: subject, class: () => project_has_member, target }))),
+});

package/dist/schema/modules/project/types/index.d.ts

@@ -0,0 +1,2 @@
+export { membershipChangeValue } from './membership-change.js';
+export { projectValue } from './project.js';

package/dist/schema/modules/project/types/index.js

@@ -0,0 +1,2 @@
+export { membershipChangeValue } from './membership-change.js';
+export { projectValue } from './project.js';

package/dist/schema/modules/project/types/membership-change.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const membershipChangeValue: z.ZodObject<{
+    projectId: z.ZodString;
+    memberId: z.ZodString;
+    changed: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/schema/modules/project/types/membership-change.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+export const membershipChangeValue = z.strictObject({
+    projectId: nodeIdValue,
+    memberId: nodeIdValue,
+    changed: z.boolean(),
+});

package/dist/schema/modules/project/types/project.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const projectValue: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    archived: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/schema/modules/project/types/project.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+export const projectValue = z.strictObject({
+    id: nodeIdValue,
+    key: z.string().min(2).max(10),
+    name: z.string().min(1).max(120),
+    description: z.string().max(5_000),
+    archived: z.boolean(),
+});

package/dist/schema/modules/tag/classes/index.d.ts

@@ -0,0 +1,3 @@
+export { issue_tagged_with } from './issue-tagged-with.js';
+export { project_contains_tag } from './project-contains-tag.js';
+export { Tag } from './tag.js';

package/dist/schema/modules/tag/classes/index.js

@@ -0,0 +1,3 @@
+export { issue_tagged_with } from './issue-tagged-with.js';
+export { project_contains_tag } from './project-contains-tag.js';
+export { Tag } from './tag.js';

package/dist/schema/modules/tag/classes/issue-tagged-with.d.ts

@@ -0,0 +1,16 @@
+export declare const issue_tagged_with: 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..*";
+    };
+    readonly target: {
+        readonly as: "tag";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/tag/classes/issue-tagged-with.js

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { Issue } from '../../issue/index.js';
+import { TraverseIssueTag } from '../policies/traverse-issue-tag.js';
+import { Tag } from './tag.js';
+export const issue_tagged_with = edgeClass.directed({
+    description: 'One Issue is classified by one Tag from the same Project.',
+    source: { as: 'issue', accepts: [() => Issue], outgoing: '0..*' },
+    target: { as: 'tag', accepts: [() => Tag], incoming: '0..*' },
+    policies: { traverse: () => TraverseIssueTag },
+});

package/dist/schema/modules/tag/classes/project-contains-tag.d.ts

@@ -0,0 +1,16 @@
+export declare const project_contains_tag: 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: "tag";
+        readonly incoming: "1";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

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

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { Project } from '../../project/index.js';
+import { TraverseProjectTag } from '../policies/traverse-project-tag.js';
+import { Tag } from './tag.js';
+export const project_contains_tag = edgeClass.directed({
+    description: 'One Project owns one local Tag vocabulary entry.',
+    source: { as: 'project', accepts: [() => Project], outgoing: '0..*' },
+    target: { as: 'tag', accepts: [() => Tag], incoming: '1' },
+    policies: { traverse: () => TraverseProjectTag },
+});

package/dist/schema/{tag/class.d.ts → modules/tag/classes/tag.d.ts}

@@ -38,7 +38,27 @@ export declare const Tag: import("@astrale-os/sdk/schema").NodeClass<{
         readonly slug: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "slug", "self">;
         readonly color: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "color", "self">;
     };
-    readonly methods: Readonly<Record<never, never>>;
+    readonly methods: {
+        readonly edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            name?: string | undefined;
+            color?: string | null | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                name: string;
+                slug: string;
+                color?: string | undefined;
+            };
+        }, "authorized", false, "default">>;
+        readonly delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                tagId: string;
+                deleted: true;
+            };
+        }, "authorized", false, "default">>;
+    };
     readonly effectiveProperties: (import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, false, "color", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "slug", "self">) | (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";
@@ -49,6 +69,23 @@ export declare const Tag: 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: {
+            tagId: string;
+            deleted: true;
+        };
+    }, "authorized", false, "default">>, "delete", "self"> | import("@astrale-os/sdk/schema").AuthoredMethodProjection<import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+        name?: string | undefined;
+        color?: string | null | undefined;
+    }, {
+        readonly mode: 'value';
+        readonly value: {
+            id: string;
+            name: string;
+            slug: string;
+            color?: string | undefined;
+        };
+    }, "authorized", false, "default">>, "edit", "self">;
     readonly effectiveStaticMethods: never;
-}>;
+}> & import("@astrale-os/sdk/schema").StateClass<Readonly<Omit<Readonly<Record<never, never>>, never> & {}>>;

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

@@ -0,0 +1,16 @@
+import { K, nodeClass, property } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { deleteTagMethod } from '../functions/delete-tag.js';
+import { editTagMethod } from '../functions/edit-tag.js';
+import { ContributeToTag } from '../policies/contribute-to-tag.js';
+export const Tag = nodeClass({
+    description: 'One Project-local label with a canonical slug.',
+    icon: 'tag',
+    extends: [K.classes.Named, K.classes.Timestamped],
+    properties: {
+        slug: z.string().min(1).max(80),
+        color: property(z.string().min(7).max(7), { required: false }),
+    },
+    methods: { edit: editTagMethod, delete: deleteTagMethod },
+    policies: { read: () => ContributeToTag },
+});

package/dist/schema/modules/tag/functions/delete-tag.d.ts

@@ -0,0 +1,7 @@
+export declare const deleteTagMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: {
+        tagId: string;
+        deleted: true;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/tag/functions/delete-tag.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ManageTag } from '../policies/manage-tag.js';
+export const deleteTagMethod = method({
+    description: 'Detach and delete this Project-local Tag when it labels at most 2,046 Issues; unlink larger sets first.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageTag, self),
+    input: z.strictObject({}),
+    output: z.strictObject({ tagId: nodeIdValue, deleted: z.literal(true) }),
+});

package/dist/schema/modules/tag/functions/edit-tag.d.ts

@@ -0,0 +1,12 @@
+export declare const editTagMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name?: string | undefined;
+    color?: string | null | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        name: string;
+        slug: string;
+        color?: string | undefined;
+    };
+}, "authorized", false, "default">>;

package/dist/schema/modules/tag/functions/edit-tag.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { ManageTag } from '../policies/manage-tag.js';
+import { tagValue } from '../types/tag.js';
+export const editTagMethod = method({
+    description: 'Edit this Project-local Tag.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageTag, self),
+    input: z.strictObject({
+        name: z.string().min(1).max(64).optional(),
+        color: z.string().nullable().optional(),
+    }),
+    output: tagValue,
+});

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

@@ -0,0 +1,2 @@
+export { deleteTagMethod } from './delete-tag.js';
+export { editTagMethod } from './edit-tag.js';

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

@@ -0,0 +1,2 @@
+export { deleteTagMethod } from './delete-tag.js';
+export { editTagMethod } from './edit-tag.js';

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

@@ -0,0 +1,4 @@
+export { tagValue } from './types/index.js';
+export { issue_tagged_with, project_contains_tag, Tag } from './classes/index.js';
+export { deleteTagMethod, editTagMethod } from './functions/index.js';
+export { ContributeToTag, ManageTag, TraverseIssueTag, TraverseProjectTag, } from './policies/index.js';

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

@@ -0,0 +1,4 @@
+export { tagValue } from './types/index.js';
+export { issue_tagged_with, project_contains_tag, Tag } from './classes/index.js';
+export { deleteTagMethod, editTagMethod } from './functions/index.js';
+export { ContributeToTag, ManageTag, TraverseIssueTag, TraverseProjectTag, } from './policies/index.js';

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

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

package/dist/schema/modules/tag/policies/contribute-to-tag.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_tag } from '../classes/project-contains-tag.js';
+export const ContributeToTag = policy({
+    description: 'The caller owns or belongs to the Project containing this Tag.',
+    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_tag, target: object }));
+    }),
+});

package/dist/schema/modules/tag/policies/index.d.ts

@@ -0,0 +1,4 @@
+export { ContributeToTag } from './contribute-to-tag.js';
+export { ManageTag } from './manage-tag.js';
+export { TraverseIssueTag } from './traverse-issue-tag.js';
+export { TraverseProjectTag } from './traverse-project-tag.js';

package/dist/schema/modules/tag/policies/index.js

@@ -0,0 +1,4 @@
+export { ContributeToTag } from './contribute-to-tag.js';
+export { ManageTag } from './manage-tag.js';
+export { TraverseIssueTag } from './traverse-issue-tag.js';
+export { TraverseProjectTag } from './traverse-project-tag.js';

package/dist/schema/modules/tag/policies/manage-tag.d.ts

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

package/dist/schema/modules/tag/policies/manage-tag.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_owned_by } from '../../project/index.js';
+import { project_contains_tag } from '../classes/project-contains-tag.js';
+export const ManageTag = policy({
+    description: 'The caller owns the Project containing this Tag.',
+    match: ({ allOf, edge, exists, object, subject }) => exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source: subject, class: () => project_owned_by, target: project }), edge({ source: project, class: () => project_contains_tag, target: object }));
+    }),
+});

package/dist/schema/modules/tag/policies/traverse-issue-tag.d.ts

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

package/dist/schema/modules/tag/policies/traverse-issue-tag.js

@@ -0,0 +1,14 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_contains_issue } from '../../issue/index.js';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { issue_tagged_with } from '../classes/issue-tagged-with.js';
+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 }));
+    })),
+});

package/dist/schema/modules/tag/policies/traverse-project-tag.d.ts

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

package/dist/schema/modules/tag/policies/traverse-project-tag.js

@@ -0,0 +1,7 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { project_has_member, project_owned_by } from '../../project/index.js';
+import { project_contains_tag } from '../classes/project-contains-tag.js';
+export const TraverseProjectTag = policy({
+    description: 'Project Tag containment is visible only to that Project owner and members.',
+    match: ({ allOf, anyOf, edge, source, subject, target }) => anyOf(allOf(edge({ source, class: () => project_contains_tag, target }), edge({ source: subject, class: () => project_owned_by, target: source })), allOf(edge({ source, class: () => project_contains_tag, target }), edge({ source: subject, class: () => project_has_member, target: source }))),
+});

package/dist/schema/modules/tag/types/index.d.ts

@@ -0,0 +1 @@
+export { tagValue } from './tag.js';

package/dist/schema/modules/tag/types/index.js

@@ -0,0 +1 @@
+export { tagValue } from './tag.js';

package/dist/schema/modules/tag/types/tag.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const tagValue: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/schema/modules/tag/types/tag.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+export const tagValue = z.strictObject({
+    id: nodeIdValue,
+    name: z.string().min(1).max(64),
+    slug: z.string().min(1).max(80),
+    color: z.string().min(7).max(7).optional(),
+});