@sanity/workflow-engine 0.9.0 → 0.11.0

package/dist/_chunks-cjs/schema.cjs

@@ -40,13 +40,13 @@ const TASK_STATUSES = ["pending", "active", "done", "skipped", "failed"], TERMIN
 function isTerminalTaskStatus(status) {
   return TERMINAL_TASK_STATUSES.includes(status);
 }
-const STATE_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
+const FIELD_SCOPES = ["workflow", "stage", "task"], DOCUMENT_VALUE_PERMISSIONS = ["create", "read", "update"], MUTATION_GUARD_ACTIONS = [
   "create",
   "update",
   "delete",
   "publish",
   "unpublish"
-], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+], TASK_KINDS = ["user", "service", "script", "manual", "receive"], DRIVER_KINDS = ["person", "agent", "service", "engine"], NonEmpty = v__namespace.pipe(v__namespace.string(), v__namespace.minLength(1, "must be a non-empty string")), PositiveInt = v__namespace.pipe(v__namespace.number(), v__namespace.integer(), v__namespace.minValue(1)), GROQ_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function groqIdentifier(referencedAs) {
   return v__namespace.pipe(
     v__namespace.string(),
@@ -64,7 +64,7 @@ function picklist(options) {
 }
 const SourceSchema = v__namespace.lazy(
   () => v__namespace.union([
-    // State-entry origins: who fills the entry, and when.
+    // Field-entry origins: who fills the entry, and when.
     v__namespace.strictObject({ type: v__namespace.literal("init") }),
     v__namespace.strictObject({ type: v__namespace.literal("write") }),
     v__namespace.strictObject({
@@ -79,9 +79,9 @@ const SourceSchema = v__namespace.lazy(
     v__namespace.strictObject({ type: v__namespace.literal("self") }),
     v__namespace.strictObject({ type: v__namespace.literal("stage") }),
     v__namespace.strictObject({
-      type: v__namespace.literal("stateRead"),
+      type: v__namespace.literal("fieldRead"),
       scope: v__namespace.optional(v__namespace.union([v__namespace.literal("workflow"), v__namespace.literal("stage")])),
-      state: NonEmpty,
+      field: NonEmpty,
       path: v__namespace.optional(v__namespace.string())
     }),
     v__namespace.strictObject({
@@ -89,13 +89,32 @@ const SourceSchema = v__namespace.lazy(
       fields: v__namespace.record(NonEmpty, SourceSchema)
     })
   ])
-), StoredStateRefSchema = v__namespace.strictObject({
-  scope: picklist(STATE_SCOPES),
-  state: NonEmpty
-}), AuthoringStateRefSchema = v__namespace.strictObject({
-  scope: v__namespace.optional(picklist(STATE_SCOPES)),
-  state: NonEmpty
-}), OpPredicateSchema = v__namespace.lazy(
+), StoredFieldRefSchema = v__namespace.strictObject({
+  scope: picklist(FIELD_SCOPES),
+  field: NonEmpty
+}), AuthoringFieldRefSchema = v__namespace.strictObject({
+  scope: v__namespace.optional(picklist(FIELD_SCOPES)),
+  field: NonEmpty
+}), HREF_SCHEMES = ["http:", "https:"];
+function isHttpUrl(value) {
+  try {
+    return HREF_SCHEMES.includes(new URL(value).protocol);
+  } catch {
+    return !1;
+  }
+}
+const UrlString = v__namespace.pipe(
+  v__namespace.string(),
+  v__namespace.url("must be a valid URL"),
+  v__namespace.check(isHttpUrl, "must be an http(s) URL")
+);
+function manualTargetSchema(ref) {
+  return v__namespace.variant("type", [
+    v__namespace.strictObject({ type: v__namespace.literal("url"), url: UrlString }),
+    v__namespace.strictObject({ type: v__namespace.literal("field"), field: ref })
+  ]);
+}
+const StoredManualTargetSchema = manualTargetSchema(StoredFieldRefSchema), AuthoringManualTargetSchema = manualTargetSchema(v__namespace.union([NonEmpty, AuthoringFieldRefSchema])), OpPredicateSchema = v__namespace.lazy(
   () => v__namespace.union([
     v__namespace.strictObject({
       type: v__namespace.literal("field"),
@@ -109,42 +128,42 @@ const SourceSchema = v__namespace.lazy(
 function opSchemas(targetSchema) {
   return [
     v__namespace.strictObject({
-      type: v__namespace.literal("state.set"),
+      type: v__namespace.literal("field.set"),
       target: targetSchema,
       value: SourceSchema
     }),
     v__namespace.strictObject({
-      type: v__namespace.literal("state.unset"),
+      type: v__namespace.literal("field.unset"),
       target: targetSchema
     }),
     v__namespace.strictObject({
-      type: v__namespace.literal("state.append"),
+      type: v__namespace.literal("field.append"),
       target: targetSchema,
       value: SourceSchema
     }),
     v__namespace.strictObject({
-      type: v__namespace.literal("state.updateWhere"),
+      type: v__namespace.literal("field.updateWhere"),
       target: targetSchema,
       where: OpPredicateSchema,
       value: SourceSchema
     }),
     v__namespace.strictObject({
-      type: v__namespace.literal("state.removeWhere"),
+      type: v__namespace.literal("field.removeWhere"),
       target: targetSchema,
       where: OpPredicateSchema
     })
   ];
 }
 const StoredOpSchema = v__namespace.variant("type", [
-  ...opSchemas(StoredStateRefSchema),
+  ...opSchemas(StoredFieldRefSchema),
   v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
     task: NonEmpty,
     status: picklist(TASK_STATUSES)
   })
-]), StoredTransitionOpSchema = v__namespace.variant("type", [...opSchemas(StoredStateRefSchema)]), AuditOpSchema = v__namespace.strictObject({
+]), StoredTransitionOpSchema = v__namespace.variant("type", [...opSchemas(StoredFieldRefSchema)]), AuditOpSchema = v__namespace.strictObject({
   type: v__namespace.literal("audit"),
-  target: AuthoringStateRefSchema,
+  target: AuthoringFieldRefSchema,
   value: SourceSchema,
   stampFields: v__namespace.optional(
     v__namespace.strictObject({
@@ -153,14 +172,14 @@ const StoredOpSchema = v__namespace.variant("type", [
     })
   )
 }), AuthoringOpSchema = v__namespace.variant("type", [
-  ...opSchemas(AuthoringStateRefSchema),
+  ...opSchemas(AuthoringFieldRefSchema),
   v__namespace.strictObject({
     type: v__namespace.literal("status.set"),
     task: v__namespace.optional(NonEmpty),
     status: picklist(TASK_STATUSES)
   }),
   AuditOpSchema
-]), StateKindSchema = picklist([
+]), FieldKindSchema = picklist([
   "doc.ref",
   "doc.refs",
   // Release reference. A workflow declares this entry to say "I target a
@@ -179,16 +198,16 @@ const StoredOpSchema = v__namespace.variant("type", [
   // The WHO-FOR entry: the inbox reverse-query reads it by kind, and the
   // rendered `$assigned` gate matches the caller against it.
   "assignees"
-]), StateEntryName = groqIdentifier("`$state.<name>`"), StoredEditableSchema = v__namespace.union([v__namespace.literal(!0), NonEmpty]), AuthoringEditableSchema = v__namespace.union([v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty]);
-function stateEntryFields(editable) {
+]), FieldEntryName = groqIdentifier("`$fields.<name>`"), StoredEditableSchema = v__namespace.union([v__namespace.literal(!0), NonEmpty]), AuthoringEditableSchema = v__namespace.union([v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty]);
+function fieldEntryFields(editable) {
   return {
-    type: StateKindSchema,
-    name: StateEntryName,
+    type: FieldKindSchema,
+    name: FieldEntryName,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
     /**
      * When true, the caller MUST supply this entry at start (via
-     * `initialState`) or spawn (via the parent's `subworkflows.with`). A
+     * `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).
@@ -199,12 +218,12 @@ function stateEntryFields(editable) {
     editable: v__namespace.optional(editable)
   };
 }
-const StateEntrySchema = v__namespace.strictObject(stateEntryFields(StoredEditableSchema)), RawAuthoringStateEntrySchema = v__namespace.strictObject(stateEntryFields(AuthoringEditableSchema)), ClaimStateSchema = v__namespace.strictObject({
+const FieldEntrySchema = v__namespace.strictObject(fieldEntryFields(StoredEditableSchema)), RawAuthoringFieldEntrySchema = v__namespace.strictObject(fieldEntryFields(AuthoringEditableSchema)), ClaimFieldSchema = v__namespace.strictObject({
   type: v__namespace.literal("claim"),
-  name: StateEntryName,
+  name: FieldEntryName,
   title: v__namespace.optional(v__namespace.string()),
   description: v__namespace.optional(v__namespace.string())
-}), AuthoringStateEntrySchema = v__namespace.union([RawAuthoringStateEntrySchema, ClaimStateSchema]), ConditionSchema = NonEmpty, EffectSchema = v__namespace.strictObject({
+}), AuthoringFieldEntrySchema = v__namespace.union([RawAuthoringFieldEntrySchema, ClaimFieldSchema]), ConditionSchema = NonEmpty, EffectSchema = v__namespace.strictObject({
   name: NonEmpty,
   title: v__namespace.optional(v__namespace.string()),
   description: v__namespace.optional(v__namespace.string()),
@@ -254,7 +273,7 @@ const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema
   name: NonEmpty,
   title: v__namespace.optional(v__namespace.string()),
   description: v__namespace.optional(v__namespace.string()),
-  state: v__namespace.union([NonEmpty, AuthoringStateRefSchema]),
+  field: v__namespace.union([NonEmpty, AuthoringFieldRefSchema]),
   roles: v__namespace.optional(v__namespace.array(NonEmpty)),
   filter: v__namespace.optional(ConditionSchema),
   params: v__namespace.optional(v__namespace.array(ActionParamSchema)),
@@ -266,7 +285,7 @@ const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema
   /** GROQ producing one row per subworkflow; each row binds as `$row`. */
   forEach: NonEmpty,
   definition: DefinitionRefSchema,
-  /** Initial state for each subworkflow — entry name → GROQ over `$row` + the parent scope. */
+  /** Initial fields for each subworkflow — entry name → GROQ over `$row` + the parent scope. */
   with: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema)),
   /**
    * Extra values evaluated in the parent's rendered scope at spawn time and
@@ -275,11 +294,21 @@ const StoredActionSchema = v__namespace.strictObject(actionFields(StoredOpSchema
    */
   context: v__namespace.optional(v__namespace.record(NonEmpty, ConditionSchema))
 });
-function taskFields(state, action, op) {
+function taskFields(field, action, op, target) {
   return {
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
+    /**
+     * Advisory BPMN-aligned classification of this task by its executor (see
+     * {@link TASK_KINDS}). Optional and derived from the task'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__namespace.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). */
+    target: v__namespace.optional(target),
     activation: v__namespace.optional(picklist(["auto", "manual"])),
     filter: v__namespace.optional(ConditionSchema),
     /**
@@ -308,14 +337,19 @@ function taskFields(state, action, op) {
     effects: v__namespace.optional(v__namespace.array(EffectSchema)),
     actions: v__namespace.optional(v__namespace.array(action)),
     subworkflows: v__namespace.optional(SubworkflowsSchema),
-    /** Task-scoped state entries. Resolved at task activation time. */
-    state: v__namespace.optional(v__namespace.array(state))
+    /** Task-scoped field entries. Resolved at task activation time. */
+    fields: v__namespace.optional(v__namespace.array(field))
   };
 }
 const StoredTaskSchema = v__namespace.strictObject(
-  taskFields(StateEntrySchema, StoredActionSchema, StoredOpSchema)
+  taskFields(FieldEntrySchema, StoredActionSchema, StoredOpSchema, StoredManualTargetSchema)
 ), AuthoringTaskSchema = v__namespace.strictObject(
-  taskFields(AuthoringStateEntrySchema, AuthoringActionSchema, AuthoringOpSchema)
+  taskFields(
+    AuthoringFieldEntrySchema,
+    AuthoringActionSchema,
+    AuthoringOpSchema,
+    AuthoringManualTargetSchema
+  )
 );
 function transitionFields(op, filter) {
   return {
@@ -324,7 +358,7 @@ function transitionFields(op, filter) {
     description: v__namespace.optional(v__namespace.string()),
     to: NonEmpty,
     filter,
-    /** The `state.*` subset — state-write-on-move, the stage's EXIT/ARRIVAL payload. */
+    /** The `field.*` subset — field-write-on-move, the stage's EXIT/ARRIVAL payload. */
     ops: v__namespace.optional(v__namespace.array(op)),
     effects: v__namespace.optional(v__namespace.array(EffectSchema))
   };
@@ -332,14 +366,14 @@ function transitionFields(op, filter) {
 const StoredTransitionSchema = v__namespace.strictObject(
   transitionFields(StoredTransitionOpSchema, ConditionSchema)
 ), AuthoringTransitionOpSchema = v__namespace.variant("type", [
-  ...opSchemas(AuthoringStateRefSchema),
+  ...opSchemas(AuthoringFieldRefSchema),
   AuditOpSchema
 ]), AuthoringTransitionSchema = v__namespace.strictObject(
   transitionFields(AuthoringTransitionOpSchema, v__namespace.optional(ConditionSchema))
 ), GuardActionSchema = picklist(MUTATION_GUARD_ACTIONS), GuardMatchSchema = v__namespace.strictObject({
   /** Subject `_type`(s); empty matches any type. */
   types: v__namespace.optional(v__namespace.array(NonEmpty)),
-  /** Target docs as `$state` reads (or `"$self"`), resolved at deploy to bare ids + the resource. */
+  /** Target docs as `$fields` reads (or `"$self"`), resolved at deploy to bare ids + the resource. */
   idRefs: v__namespace.optional(v__namespace.array(NonEmpty)),
   /** Glob id patterns (bare, resource-local). */
   idPatterns: v__namespace.optional(v__namespace.array(NonEmpty)),
@@ -360,16 +394,16 @@ const StoredTransitionSchema = v__namespace.strictObject(
    */
   predicate: v__namespace.optional(v__namespace.string()),
   /**
-   * Projected workflow state the predicate reads as `guard.metadata.*` —
-   * the only bridge from the lake eval context (which cannot see `$state`)
-   * to workflow state. Values are NOT GROQ: each is a deploy-time read in
+   * Projected workflow fields the predicate reads as `guard.metadata.*` —
+   * the only bridge from the lake eval context (which cannot see `$fields`)
+   * to workflow fields. Values are NOT GROQ: each is a deploy-time read in
    * the guard mini-language — `"$self"`, `"$now"`, or
-   * `"$state.<name>[.path]"` — resolved into a bare value at deploy and
-   * re-synced by the post-state-op guard refresh.
+   * `"$fields.<name>[.path]"` — resolved into a bare value at deploy and
+   * re-synced by the post-field-op guard refresh.
    */
   metadata: v__namespace.optional(v__namespace.record(NonEmpty, NonEmpty))
 });
-function stageFields(state, task, transition, editable) {
+function stageFields(field, task, transition, editable) {
   return {
     name: NonEmpty,
     title: v__namespace.optional(v__namespace.string()),
@@ -381,8 +415,8 @@ function stageFields(state, task, transition, editable) {
      * `temp.system.guard` doc deployed on stage entry and retracted on exit.
      */
     guards: v__namespace.optional(v__namespace.array(GuardSchema)),
-    /** Stage-scoped state entries. Resolved at stage entry. */
-    state: v__namespace.optional(v__namespace.array(state)),
+    /** Stage-scoped field entries. Resolved at stage entry. */
+    fields: v__namespace.optional(v__namespace.array(field)),
     /**
      * Tighten-only editability overrides for the time this stage holds, keyed
      * by an in-scope slot name. The slot's own `editable` is the ceiling; a
@@ -390,14 +424,14 @@ function stageFields(state, task, transition, editable) {
      * (never open a slot the baseline left closed). An unlisted slot inherits
      * its baseline.
      */
-    editable: v__namespace.optional(v__namespace.record(StateEntryName, editable))
+    editable: v__namespace.optional(v__namespace.record(FieldEntryName, editable))
   };
 }
 const StoredStageSchema = v__namespace.strictObject(
-  stageFields(StateEntrySchema, StoredTaskSchema, StoredTransitionSchema, StoredEditableSchema)
+  stageFields(FieldEntrySchema, StoredTaskSchema, StoredTransitionSchema, StoredEditableSchema)
 ), AuthoringStageSchema = v__namespace.strictObject(
   stageFields(
-    AuthoringStateEntrySchema,
+    AuthoringFieldEntrySchema,
     AuthoringTaskSchema,
     AuthoringTransitionSchema,
     AuthoringEditableSchema
@@ -406,7 +440,7 @@ const StoredStageSchema = v__namespace.strictObject(
   NonEmpty,
   v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "a role alias must list at least one fulfilling role"))
 ), WORKFLOW_ROLES = ["workflow", "child"];
-function workflowFields(state, stage) {
+function workflowFields(field, stage) {
   return {
     name: NonEmpty,
     version: PositiveInt,
@@ -418,14 +452,14 @@ function workflowFields(state, stage) {
      * 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
-     * `startInstance` on a `'child'` def — load-bearing `required` state is the
+     * `startInstance` on a `'child'` def — load-bearing `required` field is the
      * runtime backstop.
      */
     role: v__namespace.optional(picklist(WORKFLOW_ROLES)),
     /** Reference field: named for the target, holds the stage's `name`. */
     initialStage: NonEmpty,
-    /** Workflow-scope state entries. Persist for the instance lifetime. */
-    state: v__namespace.optional(v__namespace.array(state)),
+    /** Workflow-scope field entries. Persist for the instance lifetime. */
+    fields: v__namespace.optional(v__namespace.array(field)),
     stages: v__namespace.pipe(v__namespace.array(stage), v__namespace.minLength(1, "must declare at least one stage")),
     /**
      * Nullary named conditions — each `name: groq` entry is pre-evaluated
@@ -437,9 +471,9 @@ function workflowFields(state, stage) {
     roleAliases: v__namespace.optional(RoleAliasesSchema)
   };
 }
-v__namespace.strictObject(workflowFields(StateEntrySchema, StoredStageSchema));
+v__namespace.strictObject(workflowFields(FieldEntrySchema, StoredStageSchema));
 const AuthoringWorkflowSchema = v__namespace.strictObject(
-  workflowFields(AuthoringStateEntrySchema, AuthoringStageSchema)
+  workflowFields(AuthoringFieldEntrySchema, AuthoringStageSchema)
 ), WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
 function isStartableDefinition(definition) {
   return definition.role !== "child";
@@ -463,16 +497,18 @@ function formatPath(path) {
   return out;
 }
 exports.AuthoringActionSchema = AuthoringActionSchema;
+exports.AuthoringFieldEntrySchema = AuthoringFieldEntrySchema;
 exports.AuthoringOpSchema = AuthoringOpSchema;
 exports.AuthoringStageSchema = AuthoringStageSchema;
-exports.AuthoringStateEntrySchema = AuthoringStateEntrySchema;
 exports.AuthoringTaskSchema = AuthoringTaskSchema;
 exports.AuthoringTransitionSchema = AuthoringTransitionSchema;
 exports.AuthoringWorkflowSchema = AuthoringWorkflowSchema;
 exports.DOCUMENT_VALUE_PERMISSIONS = DOCUMENT_VALUE_PERMISSIONS;
+exports.DRIVER_KINDS = DRIVER_KINDS;
 exports.EffectSchema = EffectSchema;
 exports.GROQ_IDENTIFIER = GROQ_IDENTIFIER;
 exports.GuardSchema = GuardSchema;
+exports.TASK_KINDS = TASK_KINDS;
 exports.WORKFLOW_DEFINITION_TYPE = WORKFLOW_DEFINITION_TYPE;
 exports.actorFulfillsRole = actorFulfillsRole;
 exports.andConditions = andConditions;