@sanity/workflow-engine 0.11.0 → 0.12.0

package/dist/_chunks-es/schema.js

@@ -4,6 +4,12 @@ function andConditions(parts) {
   if (present.length !== 0)
     return present.length === 1 ? present[0] : present.map((p) => `(${p})`).join(" && ");
 }
+const UNIVERSAL_ROLE_ALIAS_KEY = "$all";
+function normalizeRoleAliases(aliases) {
+  if (aliases === void 0 || !("*" in aliases)) return aliases;
+  const { ["*"]: universal, ...perRole } = aliases;
+  return { ...perRole, [UNIVERSAL_ROLE_ALIAS_KEY]: universal };
+}
 function expandRequiredRoles(required, aliases) {
   if (aliases === void 0) return [...required];
   const out = /* @__PURE__ */ new Set();
@@ -11,7 +17,7 @@ function expandRequiredRoles(required, aliases) {
     out.add(role);
     for (const fulfiller of aliases[role] ?? []) out.add(fulfiller);
   }
-  for (const fulfiller of aliases["*"] ?? []) out.add(fulfiller);
+  for (const fulfiller of aliases[UNIVERSAL_ROLE_ALIAS_KEY] ?? []) out.add(fulfiller);
   return [...out];
 }
 function actorFulfillsRole(actorRoles, required, aliases) {
@@ -19,17 +25,17 @@ function actorFulfillsRole(actorRoles, required, aliases) {
   const accepted = new Set(expandRequiredRoles([required], aliases));
   return actorRoles.some((role) => accepted.has(role));
 }
-const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMINAL_TASK_STATUSES = ["done", "skipped", "failed"];
-function isTerminalTaskStatus(status) {
-  return TERMINAL_TASK_STATUSES.includes(status);
+const ACTIVITY_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMINAL_ACTIVITY_STATUSES = ["done", "skipped", "failed"];
+function isTerminalActivityStatus(status) {
+  return TERMINAL_ACTIVITY_STATUSES.includes(status);
 }
-const FIELD_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
+const FIELD_SCOPES = ["workflow", "stage", "activity"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
   "create",
   "update",
   "delete",
   "publish",
   "unpublish"
-], TASK_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+], ACTIVITY_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v.pipe(v.string(), v.minLength(1, "must be a non-empty string")), PositiveInt = v.pipe(v.number(), v.integer(), v.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function groqIdentifier(referencedAs) {
   return v.pipe(
     v.string(),
@@ -45,32 +51,28 @@ function picklist(options) {
     `Invalid option: expected one of ${options.map((o) => `"${o}"`).join("|")}`
   );
 }
-const SourceSchema = v.lazy(
+const LiteralSchema = v.strictObject({ type: v.literal("literal"), value: v.unknown() }), FieldReadSchema = v.strictObject({
+  type: v.literal("fieldRead"),
+  scope: v.optional(v.union([v.literal("workflow"), v.literal("stage")])),
+  field: NonEmpty,
+  path: v.optional(v.string())
+}), FieldSourceSchema = v.union([
+  // The caller supplies it at start/spawn (`initialFields` / `subworkflows.with`).
+  v.strictObject({ type: v.literal("input") }),
+  // Computed once by running GROQ against the lake at materialisation.
+  v.strictObject({ type: v.literal("query"), query: NonEmpty }),
+  LiteralSchema,
+  FieldReadSchema
+]), ValueExprSchema = v.lazy(
   () => v.union([
-    // Field-entry origins: who fills the entry, and when.
-    v.strictObject({ type: v.literal("init") }),
-    v.strictObject({ type: v.literal("write") }),
-    v.strictObject({
-      type: v.literal("query"),
-      query: NonEmpty
-    }),
-    // Value sources: resolved to concrete JSON when an op or seed applies.
-    v.strictObject({ type: v.literal("literal"), value: v.unknown() }),
+    LiteralSchema,
+    FieldReadSchema,
     v.strictObject({ type: v.literal("param"), param: NonEmpty }),
     v.strictObject({ type: v.literal("actor") }),
     v.strictObject({ type: v.literal("now") }),
     v.strictObject({ type: v.literal("self") }),
     v.strictObject({ type: v.literal("stage") }),
-    v.strictObject({
-      type: v.literal("fieldRead"),
-      scope: v.optional(v.union([v.literal("workflow"), v.literal("stage")])),
-      field: NonEmpty,
-      path: v.optional(v.string())
-    }),
-    v.strictObject({
-      type: v.literal("object"),
-      fields: v.record(NonEmpty, SourceSchema)
-    })
+    v.strictObject({ type: v.literal("object"), fields: v.record(NonEmpty, ValueExprSchema) })
   ])
 ), StoredFieldRefSchema = v.strictObject({
   scope: picklist(FIELD_SCOPES),
@@ -102,7 +104,7 @@ const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), Autho
     v.strictObject({
       type: v.literal("field"),
       field: NonEmpty,
-      equals: SourceSchema
+      equals: ValueExprSchema
     }),
     v.strictObject({ type: v.literal("all"), of: v.array(OpPredicateSchema) }),
     v.strictObject({ type: v.literal("any"), of: v.array(OpPredicateSchema) })
@@ -113,7 +115,7 @@ function opSchemas(targetSchema) {
     v.strictObject({
       type: v.literal("field.set"),
       target: targetSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v.strictObject({
       type: v.literal("field.unset"),
@@ -122,13 +124,13 @@ function opSchemas(targetSchema) {
     v.strictObject({
       type: v.literal("field.append"),
       target: targetSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v.strictObject({
       type: v.literal("field.updateWhere"),
       target: targetSchema,
       where: OpPredicateSchema,
-      value: SourceSchema
+      value: ValueExprSchema
     }),
     v.strictObject({
       type: v.literal("field.removeWhere"),
@@ -141,13 +143,13 @@ const StoredOpSchema = v.variant("type", [
   ...opSchemas(StoredFieldRefSchema),
   v.strictObject({
     type: v.literal("status.set"),
-    task: NonEmpty,
-    status: picklist(TASK_STATUSES)
+    activity: NonEmpty,
+    status: picklist(ACTIVITY_STATUSES)
   })
 ]), StoredTransitionOpSchema = v.variant("type", [...opSchemas(StoredFieldRefSchema)]), AuditOpSchema = v.strictObject({
   type: v.literal("audit"),
   target: AuthoringFieldRefSchema,
-  value: SourceSchema,
+  value: ValueExprSchema,
   stampFields: v.optional(
     v.strictObject({
       actor: v.optional(NonEmpty),
@@ -158,33 +160,83 @@ const StoredOpSchema = v.variant("type", [
   ...opSchemas(AuthoringFieldRefSchema),
   v.strictObject({
     type: v.literal("status.set"),
-    task: v.optional(NonEmpty),
-    status: picklist(TASK_STATUSES)
+    activity: v.optional(NonEmpty),
+    status: picklist(ACTIVITY_STATUSES)
   }),
   AuditOpSchema
-]), FieldKindSchema = picklist([
+]), FIELD_VALUE_KINDS = [
   "doc.ref",
   "doc.refs",
   // Release reference. A workflow declares this entry to say "I target a
   // Content Release"; the runtime fills it at start time and auto-derives
   // the instance's read perspective from it.
   "release.ref",
-  "query",
-  "value.string",
-  "value.url",
-  "value.number",
-  "value.boolean",
-  "value.dateTime",
-  "value.actor",
-  "checklist",
-  "notes",
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "url",
+  "actor",
+  // A single {@link Assignee} — the singular of `assignees`.
+  "assignee",
   // The WHO-FOR entry: the inbox reverse-query reads it by kind, and the
   // rendered `$assigned` gate matches the caller against it.
-  "assignees"
-]), FieldEntryName = groqIdentifier("`$fields.<name>`"), StoredEditableSchema = v.union([v.literal(!0), NonEmpty]), AuthoringEditableSchema = v.union([v.literal(!0), v.array(NonEmpty), NonEmpty]);
-function fieldEntryFields(editable) {
+  "assignees",
+  // Compositional kinds — mirror Sanity's `object.fields` / `array.of`.
+  "object",
+  "array"
+], FieldValueKindSchema = picklist(FIELD_VALUE_KINDS), FieldKindSchema = picklist(FIELD_VALUE_KINDS), FieldEntryName = groqIdentifier("`$fields.<name>`");
+function asShape(input) {
+  return typeof input == "object" && input !== null ? input : {};
+}
+function compositeShapeOk(input) {
+  const shape = asShape(input);
+  return shape.type === "object" ? Array.isArray(shape.fields) && shape.fields.length > 0 && shape.of === void 0 : shape.type === "array" ? Array.isArray(shape.of) && shape.of.length > 0 && shape.fields === void 0 : shape.fields === void 0 && shape.of === void 0;
+}
+function compositeShapeMessage(input) {
+  const shape = asShape(input);
+  return shape.type === "object" ? shape.of !== void 0 ? "an `object` kind declares its sub-fields with `fields`, not `of`" : "an `object` kind needs a non-empty `fields` list of sub-field shapes" : shape.type === "array" ? shape.fields !== void 0 ? "an `array` kind declares its item shape with `of`, not `fields`" : "an `array` kind needs a non-empty `of` list of sub-field shapes" : `\`fields\` / \`of\` are only valid on the \`object\` / \`array\` kinds, not "${String(shape.type)}"`;
+}
+function duplicateSubfieldName(input) {
+  const shape = asShape(input);
+  let list = [];
+  Array.isArray(shape.fields) ? list = shape.fields : Array.isArray(shape.of) && (list = shape.of);
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    const name = asShape(item).name;
+    if (typeof name == "string") {
+      if (seen.has(name)) return name;
+      seen.add(name);
+    }
+  }
+}
+function compositeChecked(entries) {
+  return v.pipe(
+    v.strictObject(entries),
+    v.check(
+      (input) => compositeShapeOk(input),
+      (issue) => compositeShapeMessage(issue.input)
+    ),
+    v.check(
+      (input) => duplicateSubfieldName(input) === void 0,
+      (issue) => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" \u2014 sub-field names must be unique within \`fields\` / \`of\``
+    )
+  );
+}
+const FieldShapeSchema = v.lazy(
+  () => compositeChecked({
+    type: FieldValueKindSchema,
+    name: FieldEntryName,
+    title: v.optional(v.string()),
+    description: v.optional(v.string()),
+    fields: v.optional(v.array(FieldShapeSchema)),
+    of: v.optional(v.array(FieldShapeSchema))
+  })
+), StoredEditableSchema = v.union([v.literal(!0), NonEmpty]), AuthoringEditableSchema = v.union([v.literal(!0), v.array(NonEmpty), NonEmpty]);
+function slotFields(editable) {
   return {
-    type: FieldKindSchema,
     name: FieldEntryName,
     title: v.optional(v.string()),
     description: v.optional(v.string()),
@@ -193,20 +245,47 @@ function fieldEntryFields(editable) {
      * `initialFields`) or spawn (via the parent's `subworkflows.with`). A
      * missing required entry throws rather than silently defaulting to
      * `null`/`[]` — the same fail-fast an action's `required` param gets.
-     * Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
+     * Valid only on a workflow-scope `input`-sourced entry (deploy invariant).
      */
     required: v.optional(v.boolean()),
-    source: SourceSchema,
+    /**
+     * How this field SEEDS its value at materialisation — see
+     * {@link FieldSourceSchema}. Optional: an absent `initialValue` is working
+     * memory (the slot starts empty and an op fills it later), the common case.
+     */
+    initialValue: v.optional(FieldSourceSchema),
     /** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
     editable: v.optional(editable)
   };
 }
-const FieldEntrySchema = v.strictObject(fieldEntryFields(StoredEditableSchema)), RawAuthoringFieldEntrySchema = v.strictObject(fieldEntryFields(AuthoringEditableSchema)), ClaimFieldSchema = v.strictObject({
+function fieldEntryFields(editable) {
+  return {
+    type: FieldKindSchema,
+    ...slotFields(editable),
+    /** Sub-field shapes for an `object` kind (see {@link compositeShapeOk}). */
+    fields: v.optional(v.array(FieldShapeSchema)),
+    /** Item sub-field shapes for an `array` kind (see {@link compositeShapeOk}). */
+    of: v.optional(v.array(FieldShapeSchema))
+  };
+}
+const FieldEntrySchema = compositeChecked(fieldEntryFields(StoredEditableSchema)), RawAuthoringFieldEntrySchema = compositeChecked(fieldEntryFields(AuthoringEditableSchema)), ClaimFieldSchema = v.strictObject({
   type: v.literal("claim"),
   name: FieldEntryName,
   title: v.optional(v.string()),
   description: v.optional(v.string())
-}), AuthoringFieldEntrySchema = v.union([RawAuthoringFieldEntrySchema, ClaimFieldSchema]), ConditionSchema = NonEmpty, EffectSchema = v.strictObject({
+});
+function listSugarFields(type) {
+  return {
+    type: v.literal(type),
+    ...slotFields(AuthoringEditableSchema)
+  };
+}
+const TodoListFieldSchema = v.strictObject(listSugarFields("todoList")), NotesFieldSchema = v.strictObject(listSugarFields("notes")), AuthoringFieldEntrySchema = v.union([
+  RawAuthoringFieldEntrySchema,
+  ClaimFieldSchema,
+  TodoListFieldSchema,
+  NotesFieldSchema
+]), ConditionSchema = NonEmpty, EffectSchema = v.strictObject({
   name: NonEmpty,
   title: v.optional(v.string()),
   description: v.optional(v.string()),
@@ -247,10 +326,10 @@ function actionFields(op) {
     effects: v.optional(v.array(EffectSchema))
   };
 }
-const StoredActionSchema = v.strictObject(actionFields(StoredOpSchema)), TerminalTaskStatus = picklist(TERMINAL_TASK_STATUSES), RawAuthoringActionSchema = v.strictObject({
+const StoredActionSchema = v.strictObject(actionFields(StoredOpSchema)), TerminalActivityStatus = picklist(TERMINAL_ACTIVITY_STATUSES), RawAuthoringActionSchema = v.strictObject({
   ...actionFields(AuthoringOpSchema),
   roles: v.optional(v.array(NonEmpty)),
-  status: v.optional(TerminalTaskStatus)
+  status: v.optional(TerminalActivityStatus)
 }), ClaimActionSchema = v.strictObject({
   type: v.literal("claim"),
   name: NonEmpty,
@@ -277,27 +356,27 @@ const StoredActionSchema = v.strictObject(actionFields(StoredOpSchema)), Termina
    */
   context: v.optional(v.record(NonEmpty, ConditionSchema))
 });
-function taskFields(field, action, op, target) {
+function activityFields(field, action, op, target) {
   return {
     name: NonEmpty,
     title: v.optional(v.string()),
     description: v.optional(v.string()),
     /**
-     * Advisory BPMN-aligned classification of this task by its executor (see
-     * {@link TASK_KINDS}). Optional and derived from the task's shape when
+     * Advisory BPMN-aligned classification of this activity by its executor (see
+     * {@link ACTIVITY_KINDS}). Optional and derived from the activity's shape when
      * omitted; declaring it lets deploy check the shape matches the lane.
      * Changes no gating or resolution — a label for tooling, like `assignees`.
      */
-    kind: v.optional(picklist(TASK_KINDS)),
-    /** Deep-link target for a `kind: "manual"` task (off-system work). Render-only
-     *  metadata; only valid on a manual task (deploy-checked). */
+    kind: v.optional(picklist(ACTIVITY_KINDS)),
+    /** Deep-link target for a `kind: "manual"` activity (off-system work). Render-only
+     *  metadata; only valid on a manual activity (deploy-checked). */
     target: v.optional(target),
     activation: v.optional(picklist(["auto", "manual"])),
     filter: v.optional(ConditionSchema),
     /**
      * Readiness gates, by name — conditions over the rendered scope that must
-     * hold for the task to be *executable*, orthogonal to `filter`
-     * (visibility). An unmet requirement keeps the task visible but disables
+     * hold for the activity to be *executable*, orthogonal to `filter`
+     * (visibility). An unmet requirement keeps the activity visible but disables
      * its actions with a `requirements-unmet` verdict naming the unmet keys;
      * all must hold (any-of lives inside one condition). Advisory like every
      * engine gate — the lake still enforces. Distinct from ACL (authorization)
@@ -306,8 +385,8 @@ function taskFields(field, action, op, target) {
     requirements: v.optional(v.record(NonEmpty, ConditionSchema)),
     /**
      * Auto-completion condition — evaluated at activation and on every
-     * cascade; truthy flips the task to `done` with a system actor. On a
-     * spawning task it typically reads `$subworkflows`.
+     * cascade; truthy flips the activity to `done` with a system actor. On a
+     * spawning activity it typically reads `$subworkflows`.
      */
     completeWhen: v.optional(ConditionSchema),
     /**
@@ -320,14 +399,14 @@ function taskFields(field, action, op, target) {
     effects: v.optional(v.array(EffectSchema)),
     actions: v.optional(v.array(action)),
     subworkflows: v.optional(SubworkflowsSchema),
-    /** Task-scoped field entries. Resolved at task activation time. */
+    /** Activity-scoped field entries. Resolved at activity activation time. */
     fields: v.optional(v.array(field))
   };
 }
-const StoredTaskSchema = v.strictObject(
-  taskFields(FieldEntrySchema, StoredActionSchema, StoredOpSchema, StoredManualTargetSchema)
-), AuthoringTaskSchema = v.strictObject(
-  taskFields(
+const StoredActivitySchema = v.strictObject(
+  activityFields(FieldEntrySchema, StoredActionSchema, StoredOpSchema, StoredManualTargetSchema)
+), AuthoringActivitySchema = v.strictObject(
+  activityFields(
     AuthoringFieldEntrySchema,
     AuthoringActionSchema,
     AuthoringOpSchema,
@@ -386,12 +465,12 @@ const StoredTransitionSchema = v.strictObject(
    */
   metadata: v.optional(v.record(NonEmpty, NonEmpty))
 });
-function stageFields(field, task, transition, editable) {
+function stageFields(field, activity, transition, editable) {
   return {
     name: NonEmpty,
     title: v.optional(v.string()),
     description: v.optional(v.string()),
-    tasks: v.optional(v.array(task)),
+    activities: v.optional(v.array(activity)),
     transitions: v.optional(v.array(transition)),
     /**
      * Lake mutation guards active while this stage holds. Each compiles to a
@@ -411,11 +490,11 @@ function stageFields(field, task, transition, editable) {
   };
 }
 const StoredStageSchema = v.strictObject(
-  stageFields(FieldEntrySchema, StoredTaskSchema, StoredTransitionSchema, StoredEditableSchema)
+  stageFields(FieldEntrySchema, StoredActivitySchema, StoredTransitionSchema, StoredEditableSchema)
 ), AuthoringStageSchema = v.strictObject(
   stageFields(
     AuthoringFieldEntrySchema,
-    AuthoringTaskSchema,
+    AuthoringActivitySchema,
     AuthoringTransitionSchema,
     AuthoringEditableSchema
   )
@@ -426,12 +505,11 @@ const StoredStageSchema = v.strictObject(
 function workflowFields(field, stage) {
   return {
     name: NonEmpty,
-    version: PositiveInt,
     title: NonEmpty,
     description: v.optional(v.string()),
     /**
      * Whether a human may start this workflow standalone. `'child'` marks a
-     * spawn-only definition — instantiated by a parent via `task.subworkflows`,
+     * spawn-only definition — instantiated by a parent via `activity.subworkflows`,
      * never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
      * Advisory: consumers filter their start pickers on it (see
      * {@link isStartableDefinition}); the engine does NOT refuse a
@@ -480,11 +558,12 @@ function formatPath(path) {
   return out;
 }
 export {
+  ACTIVITY_KINDS,
   AuthoringActionSchema,
+  AuthoringActivitySchema,
   AuthoringFieldEntrySchema,
   AuthoringOpSchema,
   AuthoringStageSchema,
-  AuthoringTaskSchema,
   AuthoringTransitionSchema,
   AuthoringWorkflowSchema,
   DOCUMENT_VALUE_PERMISSIONS,
@@ -492,14 +571,14 @@ export {
   EffectSchema,
   GROQ_IDENTIFIER,
   GuardSchema,
-  TASK_KINDS,
   WORKFLOW_DEFINITION_TYPE,
   actorFulfillsRole,
   andConditions,
   expandRequiredRoles,
   formatValidationError,
   isStartableDefinition,
-  isTerminalTaskStatus,
-  issuesFromValibot
+  isTerminalActivityStatus,
+  issuesFromValibot,
+  normalizeRoleAliases
 };
 //# sourceMappingURL=schema.js.map