@sanity/workflow-engine 0.15.0 → 0.17.0

package/dist/define.cjs

@@ -6,617 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 
 var invariants = require("./_chunks-cjs/invariants.cjs");
 
-function groq(strings, ...values) {
-    return strings.reduce((out, part, i) => i === 0 ? part : `${out}${serializeGroqValue(values[i - 1])}${part}`, "");
-}
-
-function serializeGroqValue(value) {
-    const serialized = JSON.stringify(value);
-    if (serialized === void 0) throw new Error(`groq tag cannot serialize ${typeof value} — interpolate JSON-representable values only`);
-    return serialized;
-}
-
-function desugarWorkflow(authoring) {
-    const issues = [];
-    checkReservedRoleAliasKeys(authoring.roleAliases, issues);
-    const roleAliases = invariants.normalizeRoleAliases(authoring.roleAliases), ctx = {
-        issues: issues,
-        claimFields: /* @__PURE__ */ new Map,
-        claimedFields: /* @__PURE__ */ new Set,
-        roleAliases: roleAliases
-    }, workflowFields = desugarFieldEntries({
-        entries: authoring.fields,
-        path: [ "fields" ],
-        ctx: ctx
-    }), workflowLayer = layerOf(workflowFields), stages = authoring.stages.map((stage, i) => {
-        const path = [ "stages", i ], stageFields = desugarFieldEntries({
-            entries: stage.fields,
-            path: [ ...path, "fields" ],
-            ctx: ctx
-        }), stageEnv = {
-            layers: [ {
-                scope: "stage",
-                entries: layerOf(stageFields)
-            }, {
-                scope: "workflow",
-                entries: workflowLayer
-            } ]
-        }, activities = (stage.activities ?? []).map((activity, j) => desugarActivity({
-            activity: activity,
-            path: [ ...path, "activities", j ],
-            stageEnv: stageEnv,
-            ctx: ctx
-        })), transitions = (stage.transitions ?? []).map((transition, k) => desugarTransition({
-            transition: transition,
-            path: [ ...path, "transitions", k ],
-            stageEnv: stageEnv,
-            ctx: ctx
-        })), editable = desugarStageEditable({
-            overrides: stage.editable,
-            inScope: editableFieldNames({
-                workflowFields: workflowFields,
-                stageFields: stageFields,
-                activities: activities
-            }),
-            path: [ ...path, "editable" ],
-            ctx: ctx
-        });
-        return {
-            ...stripUndefined({
-                name: stage.name,
-                title: stage.title,
-                description: stage.description,
-                groups: stage.groups,
-                guards: stage.guards?.map(desugarGuard)
-            }),
-            ...stageFields ? {
-                fields: stageFields
-            } : {},
-            ...activities.length > 0 ? {
-                activities: activities
-            } : {},
-            ...transitions.length > 0 ? {
-                transitions: transitions
-            } : {},
-            ...editable ? {
-                editable: editable
-            } : {}
-        };
-    });
-    return checkUnclaimedClaimFields(ctx), {
-        definition: {
-            ...stripUndefined({
-                name: authoring.name,
-                title: authoring.title,
-                description: authoring.description,
-                groups: authoring.groups,
-                lifecycle: authoring.lifecycle,
-                applicableWhen: authoring.applicableWhen,
-                initialStage: authoring.initialStage,
-                predicates: authoring.predicates,
-                roleAliases: roleAliases
-            }),
-            ...workflowFields ? {
-                fields: workflowFields
-            } : {},
-            stages: stages
-        },
-        issues: ctx.issues
-    };
-}
-
-function checkReservedRoleAliasKeys(aliases, issues) {
-    for (const key of Object.keys(aliases ?? {})) key.startsWith("$") && issues.push({
-        path: [ "roleAliases", key ],
-        message: `role alias key "${key}" uses the reserved "$" prefix — that namespace is the engine's stored spelling for the universal fulfiller. Use "*" to mean "fulfills any gate", or rename the role.`
-    });
-}
-
-const TODOLIST_OF = [ {
-    type: "string",
-    name: "label",
-    title: "Label"
-}, {
-    type: "string",
-    name: "status",
-    title: "Status"
-}, {
-    type: "assignee",
-    name: "assignee",
-    title: "Assignee"
-}, {
-    type: "date",
-    name: "dueDate",
-    title: "Due date"
-} ], NOTES_OF = [ {
-    type: "text",
-    name: "body",
-    title: "Body"
-}, {
-    type: "actor",
-    name: "actor",
-    title: "Actor"
-}, {
-    type: "datetime",
-    name: "at",
-    title: "At"
-} ];
-
-function desugarFieldEntries({entries: entries, path: path, ctx: ctx}) {
-    return !entries || entries.length === 0 ? entries === void 0 ? void 0 : [] : entries.map((entry, i) => desugarFieldEntry({
-        entry: entry,
-        path: [ ...path, i ],
-        ctx: ctx
-    }));
-}
-
-function desugarFieldEntry({entry: entry, path: path, ctx: ctx}) {
-    if (entry.type === "claim") return desugarClaimField({
-        entry: entry,
-        path: path,
-        ctx: ctx
-    });
-    if (entry.type === "todoList" || entry.type === "notes") return desugarListField({
-        entry: entry,
-        path: path,
-        ctx: ctx
-    });
-    const editable = normalizeEditable({
-        editable: entry.editable,
-        path: [ ...path, "editable" ],
-        ctx: ctx
-    });
-    return {
-        ...stripUndefined({
-            type: entry.type,
-            name: entry.name,
-            title: entry.title,
-            description: entry.description,
-            group: normalizeGroup(entry.group),
-            required: entry.required,
-            initialValue: entry.initialValue,
-            editable: editable,
-            types: entry.types,
-            fields: entry.fields,
-            of: entry.of
-        })
-    };
-}
-
-function desugarClaimField({entry: entry, path: path, ctx: ctx}) {
-    const desugared = {
-        ...stripUndefined({
-            name: entry.name,
-            title: entry.title,
-            description: entry.description,
-            group: normalizeGroup(entry.group)
-        }),
-        type: "actor"
-    };
-    return ctx.claimFields.set(desugared, {
-        name: entry.name,
-        path: path
-    }), desugared;
-}
-
-function desugarListField({entry: entry, path: path, ctx: ctx}) {
-    const editable = normalizeEditable({
-        editable: entry.editable,
-        path: [ ...path, "editable" ],
-        ctx: ctx
-    });
-    return {
-        ...stripUndefined({
-            name: entry.name,
-            title: entry.title,
-            description: entry.description,
-            group: normalizeGroup(entry.group),
-            required: entry.required,
-            initialValue: entry.initialValue,
-            editable: editable
-        }),
-        type: "array",
-        of: entry.type === "todoList" ? TODOLIST_OF : NOTES_OF
-    };
-}
-
-function normalizeEditable({editable: editable, path: path, ctx: 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: path,
-                message: "editable: [] names no roles — use `true` to open the field to anyone in its scope, or list at least one role"
-            });
-            return;
-        }
-        return condition;
-    }
-    return editable;
-}
-
-function editableFieldNames({workflowFields: workflowFields, stageFields: stageFields, activities: activities}) {
-    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 activity of activities) collect(activity.fields);
-    return names;
-}
-
-function desugarStageEditable({overrides: overrides, inScope: inScope, path: path, ctx: 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 field in scope — name a workflow/stage/activity field of this stage that declares \`editable\``
-            });
-            continue;
-        }
-        const normalized = normalizeEditable({
-            editable: value,
-            path: [ ...path, name ],
-            ctx: 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 normalizeGroup(group) {
-    return group === void 0 || Array.isArray(group) ? group : [ group ];
-}
-
-function desugarActivity({activity: activity, path: path, stageEnv: stageEnv, ctx: ctx}) {
-    const activityFields = desugarFieldEntries({
-        entries: activity.fields,
-        path: [ ...path, "fields" ],
-        ctx: ctx
-    }), env = {
-        layers: [ {
-            scope: "activity",
-            entries: layerOf(activityFields)
-        }, ...stageEnv.layers ]
-    }, ops = desugarOps({
-        ops: activity.ops,
-        path: [ ...path, "ops" ],
-        env: env,
-        firingActivity: activity.name,
-        ctx: ctx
-    }), actions = (activity.actions ?? []).map((action, a) => desugarAction({
-        action: action,
-        path: [ ...path, "actions", a ],
-        env: env,
-        activityName: activity.name,
-        ctx: ctx
-    })), target = desugarTarget({
-        target: activity.target,
-        env: env,
-        path: [ ...path, "target" ],
-        ctx: ctx
-    });
-    return {
-        ...stripUndefined({
-            name: activity.name,
-            title: activity.title,
-            description: activity.description,
-            groups: activity.groups,
-            group: normalizeGroup(activity.group),
-            kind: activity.kind,
-            filter: activity.filter,
-            requirements: activity.requirements,
-            completeWhen: activity.completeWhen,
-            failWhen: activity.failWhen,
-            effects: activity.effects,
-            subworkflows: activity.subworkflows
-        }),
-        activation: activity.activation ?? "manual",
-        ...target ? {
-            target: target
-        } : {},
-        ...activityFields ? {
-            fields: activityFields
-        } : {},
-        ...ops ? {
-            ops: ops
-        } : {},
-        ...actions.length > 0 ? {
-            actions: actions
-        } : {}
-    };
-}
-
-const TARGET_DOC_KINDS = [ "doc.ref", "doc.refs", "release.ref" ];
-
-function desugarTarget({target: target, env: env, path: path, ctx: ctx}) {
-    if (target === void 0 || target.type === "url") return target;
-    const ref = typeof target.field == "string" ? {
-        field: target.field
-    } : target.field, field = resolveRef({
-        ref: ref,
-        env: env,
-        path: [ ...path, "field" ],
-        ctx: ctx
-    }) ?? fallbackRef(ref), entry = entryAt(env, field);
-    return entry && !TARGET_DOC_KINDS.includes(entry.type) && ctx.issues.push({
-        path: [ ...path, "field" ],
-        message: `manual activity target references "${field.field}" of kind "${entry.type}" — a deep-link target needs a document-valued entry (${TARGET_DOC_KINDS.join(", ")})`
-    }), {
-        type: "field",
-        field: field
-    };
-}
-
-function desugarAction({action: action, path: path, env: env, activityName: activityName, ctx: ctx}) {
-    if ("type" in action) return desugarClaimAction({
-        action: action,
-        path: path,
-        env: env,
-        ctx: ctx
-    });
-    const filter = invariants.andConditions([ rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = desugarOps({
-        ops: action.ops,
-        path: [ ...path, "ops" ],
-        env: env,
-        firingActivity: activityName,
-        ctx: ctx
-    }) ?? [];
-    return action.status !== void 0 && ops.push({
-        type: "status.set",
-        activity: activityName,
-        status: action.status
-    }), {
-        ...stripUndefined({
-            name: action.name,
-            title: action.title,
-            description: action.description,
-            group: normalizeGroup(action.group),
-            params: action.params,
-            effects: action.effects
-        }),
-        ...filter ? {
-            filter: filter
-        } : {},
-        ...ops.length > 0 ? {
-            ops: ops
-        } : {}
-    };
-}
-
-function desugarClaimAction({action: action, path: path, env: env, ctx: ctx}) {
-    const ref = typeof action.field == "string" ? {
-        field: action.field
-    } : action.field, resolved = resolveRef({
-        ref: ref,
-        env: env,
-        path: [ ...path, "field" ],
-        ctx: ctx
-    });
-    if (resolved) {
-        const entry = entryAt(env, resolved);
-        entry && entry.type !== "actor" && ctx.issues.push({
-            path: [ ...path, "field" ],
-            message: `claim action "${action.name}" references "${resolved.field}" of kind "${entry.type}" — a claim pair needs an actor-valued entry (a "claim" or "actor" field declaration)`
-        }), checkShadowedClaimTarget({
-            actionName: action.name,
-            field: ref.field,
-            resolved: resolved,
-            env: env,
-            path: [ ...path, "field" ],
-            ctx: ctx
-        }), entry && ctx.claimedFields.add(entry);
-    }
-    const noSteal = `!defined($fields.${ref.field})`, filter = invariants.andConditions([ noSteal, rolesCondition(action.roles, ctx.roleAliases), action.filter ]), ops = resolved ? [ {
-        type: "field.set",
-        target: resolved,
-        value: {
-            type: "actor"
-        }
-    } ] : [];
-    return {
-        ...stripUndefined({
-            name: action.name,
-            title: action.title,
-            description: action.description,
-            group: normalizeGroup(action.group),
-            params: action.params,
-            effects: action.effects
-        }),
-        filter: filter,
-        ...ops.length > 0 ? {
-            ops: ops
-        } : {}
-    };
-}
-
-function checkShadowedClaimTarget({actionName: actionName, field: field, resolved: resolved, env: env, path: path, ctx: ctx}) {
-    const nearest = env.layers.find(l => l.entries.has(field));
-    nearest === void 0 || nearest.scope === resolved.scope || ctx.issues.push({
-        path: path,
-        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 — 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 checkUnclaimedClaimFields(ctx) {
-    for (const [entry, {name: name, path: path}] of ctx.claimFields) ctx.claimedFields.has(entry) || ctx.issues.push({
-        path: path,
-        message: `claim field "${name}" is never referenced by a claim action — you announced the pattern and wrote half of it. Declare a defineAction({ type: "claim", field: "${name}" }) or use a raw actor entry`
-    });
-}
-
-function desugarTransition({transition: transition, path: path, stageEnv: stageEnv, ctx: ctx}) {
-    const ops = desugarOps({
-        ops: transition.ops,
-        path: [ ...path, "ops" ],
-        env: stageEnv,
-        firingActivity: void 0,
-        ctx: ctx
-    });
-    return {
-        ...stripUndefined({
-            name: transition.name,
-            title: transition.title,
-            description: transition.description,
-            to: transition.to,
-            effects: transition.effects
-        }),
-        filter: transition.filter ?? "$allActivitiesDone",
-        ...ops ? {
-            ops: ops
-        } : {}
-    };
-}
-
-function desugarGuard(guard) {
-    const {match: match, metadata: metadata, ...rest} = guard, {idRefs: idRefs, ...matchRest} = match;
-    return {
-        ...rest,
-        match: {
-            ...matchRest,
-            ...idRefs !== void 0 ? {
-                idRefs: idRefs.map(invariants.printGuardRead)
-            } : {}
-        },
-        ...metadata !== void 0 ? {
-            metadata: Object.fromEntries(Object.entries(metadata).map(([key, read]) => [ key, invariants.printGuardRead(read) ]))
-        } : {}
-    };
-}
-
-function desugarOps({ops: ops, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
-    if (ops) return ops.map((op, i) => desugarOp({
-        op: op,
-        path: [ ...path, i ],
-        env: env,
-        firingActivity: firingActivity,
-        ctx: ctx
-    }));
-}
-
-function desugarOp({op: op, path: path, env: env, firingActivity: firingActivity, ctx: ctx}) {
-    if (op.type === "status.set") {
-        const activity = op.activity ?? firingActivity;
-        return activity === void 0 && ctx.issues.push({
-            path: [ ...path, "activity" ],
-            message: "status.set outside an action must name its target activity"
-        }), {
-            type: "status.set",
-            activity: activity ?? "",
-            status: op.status
-        };
-    }
-    if (op.type === "audit") return desugarAuditOp({
-        op: op,
-        path: path,
-        env: env,
-        ctx: ctx
-    });
-    const target = resolveRef({
-        ref: op.target,
-        env: env,
-        path: [ ...path, "target" ],
-        ctx: ctx
-    }) ?? fallbackRef(op.target);
-    return {
-        ...op,
-        target: target
-    };
-}
-
-const AUDIT_STAMPS = {
-    actor: {
-        type: "actor"
-    },
-    at: {
-        type: "now"
-    }
-};
-
-function desugarAuditOp({op: op, path: path, env: env, ctx: ctx}) {
-    const target = resolveRef({
-        ref: op.target,
-        env: env,
-        path: [ ...path, "target" ],
-        ctx: ctx
-    }) ?? fallbackRef(op.target);
-    if (op.value.type !== "object") return ctx.issues.push({
-        path: [ ...path, "value" ],
-        message: `audit value must be an object source carrying the domain fields (got "${op.value.type}")`
-    }), {
-        type: "field.append",
-        target: 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 ], [ atField, AUDIT_STAMPS.at ] ]) {
-        if (stamp in fields) {
-            ctx.issues.push({
-                path: [ ...path, "value", "fields", stamp ],
-                message: `audit stamp field "${stamp}" collides with an authored domain field — rename yours or remap the stamp via stampFields`
-            });
-            continue;
-        }
-        fields[stamp] = source;
-    }
-    return {
-        type: "field.append",
-        target: target,
-        value: {
-            type: "object",
-            fields: fields
-        }
-    };
-}
-
-function resolveRef({ref: ref, env: env, path: path, ctx: 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.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: path,
-        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.field);
-}
-
-function fallbackRef(ref) {
-    return {
-        scope: ref.scope ?? "workflow",
-        field: ref.field
-    };
-}
-
-function rolesCondition(roles, aliases) {
-    if (!(!roles || roles.length === 0)) return groq`count($actor.roles[@ in ${invariants.expandRequiredRoles(roles, aliases)}]) > 0`;
-}
-
-function stripUndefined(obj) {
-    const out = {};
-    for (const [k, value] of Object.entries(obj)) value !== void 0 && (out[k] = value);
-    return out;
-}
-
 function defineWorkflow(definition) {
     const label = invariants.labelFor("defineWorkflow", definition), parsed = invariants.parseOrThrow({
         schema: invariants.AuthoringWorkflowSchema,
         input: definition,
         label: label
-    }), {definition: stored, issues: desugarIssues} = desugarWorkflow(parsed), issues = [ ...desugarIssues, ...invariants.checkWorkflowInvariants(stored) ];
+    }), {definition: stored, issues: desugarIssues} = invariants.desugarWorkflow(parsed), issues = [ ...desugarIssues, ...invariants.checkWorkflowInvariants(stored) ];
     if (issues.length > 0) throw new Error(invariants.formatValidationError(label, issues));
     return stored;
 }
@@ -719,6 +114,8 @@ exports.GUARD_PREDICATE_VARS = invariants.GUARD_PREDICATE_VARS;
 
 exports.RESERVED_CONDITION_VARS = invariants.RESERVED_CONDITION_VARS;
 
+exports.groq = invariants.groq;
+
 exports.defineAction = defineAction;
 
 exports.defineActivity = defineActivity;
@@ -742,5 +139,3 @@ exports.defineTransition = defineTransition;
 exports.defineWorkflow = defineWorkflow;
 
 exports.defineWorkflowConfig = defineWorkflowConfig;
-
-exports.groq = groq;