@sanity/workflow-engine 0.8.0 → 0.10.0

package/dist/define.cjs

@@ -29,16 +29,26 @@ function serializeGroqValue(value) {
   return serialized;
 }
 function desugarWorkflow(authoring) {
-  const ctx = { issues: [], claimStates: /* @__PURE__ */ new Map(), claimedStates: /* @__PURE__ */ new Set() }, workflowState = desugarStateEntries(authoring.state, ["state"], ctx), workflowLayer = layerOf(workflowState), stages = authoring.stages.map((stage, i) => {
-    const path = ["stages", i], stageState = desugarStateEntries(stage.state, [...path, "state"], ctx), stageEnv = {
+  const ctx = {
+    issues: [],
+    claimFields: /* @__PURE__ */ new Map(),
+    claimedFields: /* @__PURE__ */ new Set(),
+    roleAliases: authoring.roleAliases
+  }, workflowFields = desugarFieldEntries(authoring.fields, ["fields"], ctx), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
+    const path = ["stages", i], stageFields = desugarFieldEntries(stage.fields, [...path, "fields"], ctx), stageEnv = {
       layers: [
-        { scope: "stage", entries: layerOf(stageState) },
+        { scope: "stage", entries: layerOf(stageFields) },
         { scope: "workflow", entries: workflowLayer }
       ]
     }, tasks = (stage.tasks ?? []).map(
       (task, j) => desugarTask(task, [...path, "tasks", j], stageEnv, ctx)
     ), transitions = (stage.transitions ?? []).map(
       (transition, k) => desugarTransition(transition, [...path, "transitions", k], stageEnv, ctx)
+    ), editable = desugarStageEditable(
+      stage.editable,
+      editableSlotNames(workflowFields, stageFields, tasks),
+      [...path, "editable"],
+      ctx
     );
     return {
       ...stripUndefined({
@@ -47,12 +57,13 @@ function desugarWorkflow(authoring) {
         description: stage.description,
         guards: stage.guards
       }),
-      ...stageState ? { state: stageState } : {},
+      ...stageFields ? { fields: stageFields } : {},
       ...tasks.length > 0 ? { tasks } : {},
-      ...transitions.length > 0 ? { transitions } : {}
+      ...transitions.length > 0 ? { transitions } : {},
+      ...editable ? { editable } : {}
     };
   });
-  return checkUnclaimedClaimStates(ctx), { definition: {
+  return checkUnclaimedClaimFields(ctx), { definition: {
     ...stripUndefined({
       name: authoring.name,
       version: authoring.version,
@@ -60,29 +71,82 @@ function desugarWorkflow(authoring) {
       description: authoring.description,
       role: authoring.role,
       initialStage: authoring.initialStage,
-      predicates: authoring.predicates
+      predicates: authoring.predicates,
+      roleAliases: authoring.roleAliases
     }),
-    ...workflowState ? { state: workflowState } : {},
+    ...workflowFields ? { fields: workflowFields } : {},
     stages
   }, issues: ctx.issues };
 }
-function desugarStateEntries(entries, path, ctx) {
+function desugarFieldEntries(entries, path, ctx) {
   return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => {
-    if (entry.type !== "claim") return entry;
-    const desugared = {
-      ...stripUndefined({ name: entry.name, title: entry.title, description: entry.description }),
-      type: "value.actor",
-      source: { type: "write" }
+    if (entry.type === "claim") {
+      const desugared = {
+        ...stripUndefined({ name: entry.name, title: entry.title, description: entry.description }),
+        type: "value.actor",
+        source: { type: "write" }
+      };
+      return ctx.claimFields.set(desugared, { name: entry.name, path: [...path, i] }), desugared;
+    }
+    const editable = normalizeEditable(entry.editable, [...path, i, "editable"], ctx);
+    return {
+      ...stripUndefined({
+        type: entry.type,
+        name: entry.name,
+        title: entry.title,
+        description: entry.description,
+        required: entry.required,
+        editable
+      }),
+      source: entry.source
     };
-    return ctx.claimStates.set(desugared, { name: entry.name, path: [...path, i] }), desugared;
   });
 }
+function normalizeEditable(editable, path, ctx) {
+  if (editable === void 0 || editable === !0) return editable;
+  if (Array.isArray(editable)) {
+    const condition = rolesCondition(editable, ctx.roleAliases);
+    if (condition === void 0) {
+      ctx.issues.push({
+        path,
+        message: "editable: [] names no roles \u2014 use `true` to open the slot to anyone in its scope, or list at least one role"
+      });
+      return;
+    }
+    return condition;
+  }
+  return editable;
+}
+function editableSlotNames(workflowFields, stageFields, tasks) {
+  const names = /* @__PURE__ */ new Set(), collect = (entries) => {
+    for (const entry of entries ?? []) entry.editable !== void 0 && names.add(entry.name);
+  };
+  collect(workflowFields), collect(stageFields);
+  for (const task of tasks) collect(task.fields);
+  return names;
+}
+function desugarStageEditable(overrides, inScope, path, ctx) {
+  if (overrides === void 0) return;
+  const out = {};
+  for (const [name, value] of Object.entries(overrides)) {
+    if (!inScope.has(name)) {
+      ctx.issues.push({
+        path: [...path, name],
+        message: `stage editable override "${name}" does not narrow an editable slot in scope \u2014 name a workflow/stage/task slot of this stage that declares \`editable\``
+      });
+      continue;
+    }
+    const normalized = normalizeEditable(value, [...path, name], ctx);
+    normalized !== void 0 && (out[name] = normalized);
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function layerOf(entries) {
   return new Map((entries ?? []).map((entry) => [entry.name, entry]));
 }
 function desugarTask(task, path, stageEnv, ctx) {
-  const taskState = desugarStateEntries(task.state, [...path, "state"], ctx), env = {
-    layers: [{ scope: "task", entries: layerOf(taskState) }, ...stageEnv.layers]
+  const taskFields = desugarFieldEntries(task.fields, [...path, "fields"], ctx), env = {
+    layers: [{ scope: "task", entries: layerOf(taskFields) }, ...stageEnv.layers]
   }, ops = desugarOps(task.ops, [...path, "ops"], env, task.name, ctx), actions = (task.actions ?? []).map(
     (action, a) => desugarAction(action, [...path, "actions", a], env, task.name, ctx)
   );
@@ -99,7 +163,7 @@ function desugarTask(task, path, stageEnv, ctx) {
       subworkflows: task.subworkflows
     }),
     activation: task.activation ?? "manual",
-    ...taskState ? { state: taskState } : {},
+    ...taskFields ? { fields: taskFields } : {},
     ...ops ? { ops } : {},
     ...actions.length > 0 ? { actions } : {}
   };
@@ -107,7 +171,7 @@ function desugarTask(task, path, stageEnv, ctx) {
 function desugarAction(action, path, env, taskName, ctx) {
   if ("type" in action)
     return desugarClaimAction(action, path, env, ctx);
-  const filter = composeFilter([rolesCondition(action.roles), action.filter]), ops = desugarOps(action.ops, [...path, "ops"], env, taskName, ctx) ?? [];
+  const filter = schema.andConditions([rolesCondition(action.roles, ctx.roleAliases), action.filter]), ops = desugarOps(action.ops, [...path, "ops"], env, taskName, ctx) ?? [];
   return action.status !== void 0 && ops.push({ type: "status.set", task: taskName, status: action.status }), {
     ...stripUndefined({
       name: action.name,
@@ -121,15 +185,19 @@ function desugarAction(action, path, env, taskName, ctx) {
   };
 }
 function desugarClaimAction(action, path, env, ctx) {
-  const ref = typeof action.state == "string" ? { state: action.state } : action.state, resolved = resolveRef(ref, env, [...path, "state"], ctx);
+  const ref = typeof action.field == "string" ? { field: action.field } : action.field, resolved = resolveRef(ref, env, [...path, "field"], ctx);
   if (resolved) {
     const entry = entryAt(env, resolved);
     entry && entry.type !== "value.actor" && ctx.issues.push({
-      path: [...path, "state"],
-      message: `claim action "${action.name}" references "${resolved.state}" of kind "${entry.type}" \u2014 a claim pair needs an actor-valued entry (a "claim" or "value.actor" state declaration)`
-    }), checkShadowedClaimTarget(action.name, ref.state, resolved, env, [...path, "state"], ctx), entry && ctx.claimedStates.add(entry);
+      path: [...path, "field"],
+      message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" \u2014 a claim pair needs an actor-valued entry (a "claim" or "value.actor" field declaration)`
+    }), checkShadowedClaimTarget(action.name, ref.field, resolved, env, [...path, "field"], ctx), entry && ctx.claimedFields.add(entry);
   }
-  const noSteal = `!defined($state.${ref.state})`, filter = composeFilter([noSteal, rolesCondition(action.roles), action.filter]), ops = resolved ? [{ type: "state.set", target: resolved, value: { type: "actor" } }] : [];
+  const noSteal = `!defined($fields.${ref.field})`, filter = schema.andConditions([
+    noSteal,
+    rolesCondition(action.roles, ctx.roleAliases),
+    action.filter
+  ]), ops = resolved ? [{ type: "field.set", target: resolved, value: { type: "actor" } }] : [];
   return {
     ...stripUndefined({
       name: action.name,
@@ -142,18 +210,18 @@ function desugarClaimAction(action, path, env, ctx) {
     ...ops.length > 0 ? { ops } : {}
   };
 }
-function checkShadowedClaimTarget(actionName, state, resolved, env, path, ctx) {
-  const nearest = env.layers.find((l) => l.entries.has(state));
+function checkShadowedClaimTarget(actionName, field, resolved, env, path, ctx) {
+  const nearest = env.layers.find((l) => l.entries.has(field));
   nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
     path,
-    message: `claim action "${actionName}" targets "${state}" at scope "${resolved.scope}", but a nearer ${nearest.scope}-scope entry of the same name shadows it in $state \u2014 the no-steal filter would read the shadowing entry while the claim writes the "${resolved.scope}" one. Rename one of the entries or claim the nearer one`
+    message: `claim action "${actionName}" targets "${field}" at scope "${resolved.scope}", but a nearer ${nearest.scope}-scope entry of the same name shadows it in $fields \u2014 the no-steal filter would read the shadowing entry while the claim writes the "${resolved.scope}" one. Rename one of the entries or claim the nearer one`
   });
 }
-function checkUnclaimedClaimStates(ctx) {
-  for (const [entry, { name, path }] of ctx.claimStates)
-    ctx.claimedStates.has(entry) || ctx.issues.push({
+function checkUnclaimedClaimFields(ctx) {
+  for (const [entry, { name, path }] of ctx.claimFields)
+    ctx.claimedFields.has(entry) || ctx.issues.push({
       path,
-      message: `claim state "${name}" is never referenced by a claim action \u2014 you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", state: "${name}" }) or use a raw value.actor entry`
+      message: `claim field "${name}" is never referenced by a claim action \u2014 you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw value.actor entry`
     });
 }
 function desugarTransition(transition, path, stageEnv, ctx) {
@@ -193,7 +261,7 @@ function desugarAuditOp(op, path, env, ctx) {
     return ctx.issues.push({
       path: [...path, "value"],
       message: `audit value must be an object source carrying the domain fields (got "${op.value.type}")`
-    }), { type: "state.append", target, value: op.value };
+    }), { type: "field.append", target, value: op.value };
   const actorField = op.stampFields?.actor ?? "actor", atField = op.stampFields?.at ?? "at", fields = { ...op.value.fields };
   for (const [stamp, source] of [
     [actorField, AUDIT_STAMPS.actor],
@@ -208,32 +276,27 @@ function desugarAuditOp(op, path, env, ctx) {
     }
     fields[stamp] = source;
   }
-  return { type: "state.append", target, value: { type: "object", fields } };
+  return { type: "field.append", target, value: { type: "object", fields } };
 }
 function resolveRef(ref, env, path, ctx) {
   const layers = ref.scope === void 0 ? env.layers : env.layers.filter((l) => l.scope === ref.scope);
   for (const layer of layers)
-    if (layer.entries.has(ref.state)) return { scope: layer.scope, state: ref.state };
+    if (layer.entries.has(ref.field)) return { scope: layer.scope, field: ref.field };
   const reachable = env.layers.flatMap((l) => [...l.entries.keys()].map((n) => `${l.scope}:${n}`));
   ctx.issues.push({
     path,
-    message: `state reference "${ref.state}"${ref.scope ? ` (scope "${ref.scope}")` : ""} does not resolve to a declared entry. Reachable: ${reachable.join(", ") || "(none)"}`
+    message: `field reference "${ref.field}"${ref.scope ? ` (scope "${ref.scope}")` : ""} does not resolve to a declared entry. Reachable: ${reachable.join(", ") || "(none)"}`
   });
 }
 function entryAt(env, ref) {
-  return env.layers.find((l) => l.scope === ref.scope)?.entries.get(ref.state);
+  return env.layers.find((l) => l.scope === ref.scope)?.entries.get(ref.field);
 }
 function fallbackRef(ref) {
-  return { scope: ref.scope ?? "workflow", state: ref.state };
+  return { scope: ref.scope ?? "workflow", field: ref.field };
 }
-function rolesCondition(roles) {
+function rolesCondition(roles, aliases) {
   if (!(!roles || roles.length === 0))
-    return groq`count($actor.roles[@ in ${roles}]) > 0`;
-}
-function composeFilter(parts) {
-  const present = parts.filter((p) => p !== void 0);
-  if (present.length !== 0)
-    return present.length === 1 ? present[0] : present.map((p) => `(${p})`).join(" && ");
+    return groq`count($actor.roles[@ in ${schema.expandRequiredRoles(roles, aliases)}]) > 0`;
 }
 function stripUndefined(obj) {
   const out = {};
@@ -242,7 +305,7 @@ function stripUndefined(obj) {
   return out;
 }
 const RESERVED_CONDITION_VARS = [
-  "state",
+  "fields",
   "actor",
   "assigned",
   "can",
@@ -363,43 +426,43 @@ function checkGuardNames(def, issues) {
     issues
   );
 }
-function stateScopes(def) {
+function fieldScopes(def) {
   const scopes = [
-    { entries: def.state, scope: "workflow", path: ["state"], label: "workflow state" }
+    { entries: def.fields, scope: "workflow", path: ["fields"], label: "workflow fields" }
   ];
   for (const [i, stage] of def.stages.entries()) {
     scopes.push({
-      entries: stage.state,
+      entries: stage.fields,
       scope: "stage",
-      path: ["stages", i, "state"],
-      label: `stage "${stage.name}" state`
+      path: ["stages", i, "fields"],
+      label: `stage "${stage.name}" fields`
     });
     for (const [j, task] of (stage.tasks ?? []).entries())
       scopes.push({
-        entries: task.state,
+        entries: task.fields,
         scope: "task",
-        path: ["stages", i, "tasks", j, "state"],
-        label: `task "${task.name}" state`
+        path: ["stages", i, "tasks", j, "fields"],
+        label: `task "${task.name}" fields`
       });
   }
   return scopes;
 }
-function checkRequiredState(def, issues) {
-  for (const { entries, scope, path, label } of stateScopes(def))
+function checkRequiredField(def, issues) {
+  for (const { entries, scope, path, label } of fieldScopes(def))
     for (const [n, entry] of (entries ?? []).entries())
       entry.required === !0 && (scope !== "workflow" ? issues.push({
         path: [...path, n, "required"],
         message: `${label} entry "${entry.name}" is \`required\`, but \`required\` applies only to workflow-scope \`init\` entries \u2014 only those are caller-supplied at start/spawn`
       }) : entry.source.type !== "init" && issues.push({
         path: [...path, n, "required"],
-        message: `state entry "${entry.name}" is \`required\` but its source is "${entry.source.type}" \u2014 \`required\` applies only to \`init\`-sourced entries (the caller fills them at start/spawn)`
+        message: `field entry "${entry.name}" is \`required\` but its source is "${entry.source.type}" \u2014 \`required\` applies only to \`init\`-sourced entries (the caller fills them at start/spawn)`
       }));
 }
-function checkStateEntryNames(def, issues) {
-  for (const { entries, path, label } of stateScopes(def))
+function checkFieldEntryNames(def, issues) {
+  for (const { entries, path, label } of fieldScopes(def))
     checkDuplicates(
       (entries ?? []).map((entry, n) => ({ name: entry.name, path: [...path, n, "name"] })),
-      `state entry name in ${label}`,
+      `field entry name in ${label}`,
       issues
     );
 }
@@ -499,15 +562,15 @@ function collectBindingSites(effects, path, label, sites) {
       });
 }
 function checkAssigneesEntries(def, issues) {
-  for (const { entries, path } of stateScopes(def))
+  for (const { entries, path } of fieldScopes(def))
     (entries ?? []).filter((e) => e.type === "assignees").length <= 1 || issues.push({
       path,
-      message: "at most one assignees-kind state entry per scope \u2014 the inbox reads it by kind"
+      message: "at most one assignees-kind field entry per scope \u2014 the inbox reads it by kind"
     });
 }
 function checkWorkflowInvariants(def) {
   const issues = [], stageNames = checkStages(def, issues);
-  return checkInitialStage(def, stageNames, issues), checkTransitionTargets(def, stageNames, issues), checkEffectNames(def, issues), checkGuardNames(def, issues), checkStateEntryNames(def, issues), checkRequiredState(def, issues), checkPredicates(def, issues), checkCanOutsideActionFilters(def, issues), checkAssigneesEntries(def, issues), issues;
+  return checkInitialStage(def, stageNames, issues), checkTransitionTargets(def, stageNames, issues), checkEffectNames(def, issues), checkGuardNames(def, issues), checkFieldEntryNames(def, issues), checkRequiredField(def, issues), checkPredicates(def, issues), checkCanOutsideActionFilters(def, issues), checkAssigneesEntries(def, issues), issues;
 }
 function defineWorkflow(definition) {
   const label = labelFor("defineWorkflow", definition), parsed = parseOrThrow(schema.AuthoringWorkflowSchema, definition, label), { definition: stored, issues: desugarIssues } = desugarWorkflow(parsed), issues = [...desugarIssues, ...checkWorkflowInvariants(stored)];
@@ -526,8 +589,8 @@ function defineAction(action) {
 function defineTransition(transition) {
   return parseOrThrow(schema.AuthoringTransitionSchema, transition, transitionLabel(transition));
 }
-function defineState(entry) {
-  return parseOrThrow(schema.AuthoringStateEntrySchema, entry, labelFor("defineState", entry));
+function defineField(entry) {
+  return parseOrThrow(schema.AuthoringFieldEntrySchema, entry, labelFor("defineField", entry));
 }
 function defineOp(op) {
   return parseOrThrow(schema.AuthoringOpSchema, op, "defineOp");
@@ -562,10 +625,10 @@ function labelFor(fn, value) {
 exports.defineAction = defineAction;
 exports.defineEffect = defineEffect;
 exports.defineEffectDescriptor = defineEffectDescriptor;
+exports.defineField = defineField;
 exports.defineGuard = defineGuard;
 exports.defineOp = defineOp;
 exports.defineStage = defineStage;
-exports.defineState = defineState;
 exports.defineTask = defineTask;
 exports.defineTransition = defineTransition;
 exports.defineWorkflow = defineWorkflow;