@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/task/mutation-result.js

@@ -1,6 +1,7 @@
-import { isTaskSegment, canonicalTaskId, parseTaskId } from "./identity.js";
+import { taskIdSchema as taskMutationIdSchema, taskIdsSchema, taskNamespaceSchema, parseTaskId } from "./identity.js";
+import { taskNonblankTextSchema, taskStateSchema, taskPrioritySchema } from "./document.js";
 import { z } from "zod";
-const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+export { taskIdSchema as taskMutationIdSchema } from "./identity.js";
 function withoutUndefined(value, keys) {
     const result = { ...value };
     for (const key of keys) {
@@ -15,32 +16,17 @@ const timestampSchema = z.string().refine((value) => {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
 }, "expected canonical UTC timestamp");
-export const taskMutationIdSchema = z.string().transform((value, context) => {
-    try {
-        return canonicalTaskId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected canonical TaskId" });
-        return z.NEVER;
-    }
-});
-const taskIdsSchema = z.array(taskMutationIdSchema).superRefine((ids, context) => {
-    if (new Set(ids).size !== ids.length)
-        context.addIssue({ code: "custom", message: "TaskIds must be unique" });
-});
-const taskStateSchema = z.enum(["open", "in_progress", "on_hold", "done", "drop"]);
-const taskPrioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]);
 const taskRetrySchema = z
     .object({ kind: z.literal("retry"), reason: z.enum(["busy", "concurrent-modification"]) })
     .strict();
 const taskCleanupFailureSchema = z
-    .object({ kind: z.literal("lock-release-failed"), diagnostics: z.array(z.string()) })
+    .object({ kind: z.literal("lock-release-failed"), diagnostics: z.array(z.string()).readonly() })
     .strict();
 const taskViewSchema = z
     .object({
     id: taskMutationIdSchema,
-    namespace: z.array(z.string().refine(isTaskSegment)),
-    title: nonblankTextSchema,
+    namespace: taskNamespaceSchema,
+    title: taskNonblankTextSchema,
     state: taskStateSchema,
     priority: taskPrioritySchema,
     needs: taskIdsSchema,
@@ -48,7 +34,7 @@ const taskViewSchema = z
     supersedes: taskIdsSchema,
     relates: taskIdsSchema,
     note: z.string(),
-    createdBy: nonblankTextSchema.optional(),
+    createdBy: taskNonblankTextSchema.optional(),
     createdAt: timestampSchema,
     updatedAt: timestampSchema,
     body: z.string(),
@@ -58,11 +44,14 @@ const taskViewSchema = z
     if (task.namespace.join("/") !== parseTaskId(task.id).namespace.join("/"))
         context.addIssue({ code: "custom", path: ["namespace"], message: "namespace must agree with task ID" });
 })
-    .transform(({ createdBy, ...task }) => createdBy === undefined ? task : { ...task, createdBy });
+    .transform(({ createdBy, ...task }) => withoutUndefined({ ...task, createdBy }, ["createdBy"]));
 const compositionDiagnosticSchema = z
     .object({ line: z.number().int().positive(), reason: z.string(), token: z.string() })
     .strict();
-const taskRefusalSchema = z.union([
+const invalidCompositionRefusalSchema = z
+    .object({ kind: z.literal("invalid-composition"), diagnostics: z.array(compositionDiagnosticSchema).readonly() })
+    .strict();
+export const taskRefusalSchema = z.union([
     z.object({ kind: z.literal("task-missing"), taskId: taskMutationIdSchema }).strict(),
     z
         .object({
@@ -82,47 +71,101 @@ const taskRefusalSchema = z.union([
         declaringTask: taskMutationIdSchema,
     })
         .strict(),
-    z.object({ kind: z.literal("invalid-composition"), diagnostics: z.array(compositionDiagnosticSchema) }).strict(),
+    invalidCompositionRefusalSchema,
 ]);
+const taskRefusedResultSchema = z.object({ kind: z.literal("refused"), refusal: taskRefusalSchema }).strict();
 export const taskMutationResultSchema = z.union([
     z
         .object({ kind: z.literal("accepted"), value: taskViewSchema, cleanup: taskCleanupFailureSchema.optional() })
         .strict()
         .transform((value) => withoutUndefined(value, ["cleanup"])),
-    z.object({ kind: z.literal("refused"), refusal: taskRefusalSchema }).strict(),
+    taskRefusedResultSchema,
     taskRetrySchema,
 ]);
 export const taskUpdateResultSchema = z.union([
     z
         .object({
         kind: z.literal("accepted"),
-        value: z.object({ task: taskViewSchema, documentDiff: z.string() }).strict(),
+        value: z
+            .object({
+            task: taskViewSchema,
+            documentDiff: z.string(),
+            changedFields: z
+                .array(z
+                .object({ field: z.string(), action: z.enum(["added", "replaced", "cleared", "changed", "appended"]) })
+                .strict())
+                .readonly(),
+        })
+            .strict(),
         cleanup: taskCleanupFailureSchema.optional(),
     })
         .strict()
         .transform((value) => withoutUndefined(value, ["cleanup"])),
-    z.object({ kind: z.literal("refused"), refusal: taskRefusalSchema }).strict(),
+    taskRefusedResultSchema,
     taskRetrySchema,
 ]);
 export const taskBatchResultSchema = z
-    .object({ items: z.array(z.object({ id: taskMutationIdSchema, outcome: taskMutationResultSchema }).strict()) })
+    .object({
+    items: z.array(z.object({ id: taskMutationIdSchema, outcome: taskMutationResultSchema }).strict()).readonly(),
+})
     .strict();
-const aliasesSchema = z.array(z.object({ alias: nonblankTextSchema, taskId: taskMutationIdSchema }).strict());
-const documentChangesSchema = z.array(z.object({ taskId: taskMutationIdSchema, kind: z.enum(["created", "updated"]), documentDiff: z.string() }).strict());
-const compositionFactsSchema = { aliases: aliasesSchema, admissionOrder: taskIdsSchema };
+const aliasesSchema = z
+    .array(z.object({ alias: taskNonblankTextSchema, taskId: taskMutationIdSchema }).strict())
+    .readonly();
+const planAliasesSchema = z
+    .array(z.object({ alias: taskNonblankTextSchema, position: z.number().int().positive() }).strict())
+    .readonly();
+const planOrderSchema = z
+    .array(z
+    .object({
+    position: z.number().int().positive(),
+    alias: taskNonblankTextSchema.optional(),
+    taskId: taskMutationIdSchema.optional(),
+})
+    .strict())
+    .readonly();
+const admissionsSchema = z
+    .array(z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("new"),
+        position: z.number().int().positive(),
+        alias: taskNonblankTextSchema.optional(),
+        title: z.string(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("existing"),
+        position: z.number().int().positive(),
+        taskId: taskMutationIdSchema,
+        title: z.string(),
+    })
+        .strict(),
+]))
+    .readonly();
+const documentChangesSchema = z
+    .array(z.object({ taskId: taskMutationIdSchema, kind: z.enum(["created", "updated"]), documentDiff: z.string() }).strict())
+    .readonly();
+const compositionFactsSchema = { aliases: aliasesSchema, admissionOrder: taskIdsSchema, admissions: admissionsSchema };
 export const taskCompositionResultSchema = z.union([
     z
         .object({
         kind: z.literal("planned"),
-        ...compositionFactsSchema,
-        bodies: z.array(z
+        aliases: planAliasesSchema,
+        admissionOrder: planOrderSchema,
+        admissions: admissionsSchema,
+        bodies: z
+            .array(z
             .object({
-            taskId: taskMutationIdSchema,
+            position: z.number().int().positive(),
+            title: z.string(),
             bytes: z.number().int().nonnegative(),
             firstLine: z.string(),
             lastLine: z.string(),
         })
-            .strict()),
+            .strict())
+            .readonly(),
     })
         .strict(),
     z
@@ -134,14 +177,7 @@ export const taskCompositionResultSchema = z.union([
     })
         .strict()
         .transform((value) => withoutUndefined(value, ["cleanup"])),
-    z
-        .object({
-        kind: z.literal("refused"),
-        refusal: z
-            .object({ kind: z.literal("invalid-composition"), diagnostics: z.array(compositionDiagnosticSchema) })
-            .strict(),
-    })
-        .strict(),
+    z.object({ kind: z.literal("refused"), refusal: invalidCompositionRefusalSchema }).strict(),
     z
         .object({
         kind: z.literal("incomplete"),
@@ -160,6 +196,3 @@ export const taskMutationExecutionResultSchema = z.union([
     taskUpdateResultSchema,
     taskCompositionResultSchema,
 ]);
-export function isTaskMutationExecutionResult(value) {
-    return taskMutationExecutionResultSchema.safeParse(value).success;
-}