@sanity/workflow-engine 0.29.0 → 0.30.0

package/dist/_chunks-cjs/invariants.cjs

@@ -55,79 +55,6 @@ function andConditions(parts) {
     if (present.length !== 0) return present.length === 1 ? present[0] : present.map(p => `(${p})`).join(" && ");
 }
 
-class WorkflowError extends Error {
-    kind;
-    constructor(kind, message, options) {
-        super(message, options), this.kind = kind;
-    }
-}
-
-class ContractViolationError extends WorkflowError {
-    constructor(message) {
-        super("contract-violation", message), this.name = "ContractViolationError";
-    }
-}
-
-class InstanceNotFoundError extends WorkflowError {
-    instanceId;
-    constructor(args) {
-        super("instance-not-found", `Workflow instance ${args.instanceId} not found${args.detail ? ` (${args.detail})` : ""}`), 
-        this.name = "InstanceNotFoundError", this.instanceId = args.instanceId;
-    }
-}
-
-class DefinitionNotFoundError extends WorkflowError {
-    definition;
-    version;
-    constructor(args) {
-        super("definition-not-found", args.version !== void 0 ? `Workflow definition ${args.definition} v${args.version} not deployed` : `Workflow definition ${args.definition} has no deployed versions`), 
-        this.name = "DefinitionNotFoundError", this.definition = args.definition, args.version !== void 0 && (this.version = args.version);
-    }
-}
-
-class SpawnContractsInvalidError extends WorkflowError {
-    issues;
-    constructor(args) {
-        super("spawn-contracts-invalid", args.message), this.name = "SpawnContractsInvalidError", 
-        this.issues = args.issues;
-    }
-}
-
-class DefinitionInUseError extends WorkflowError {
-    definition;
-    blockedBy;
-    constructor(args) {
-        super("definition-in-use", definitionInUseMessage(args.definition, args.blockedBy)), 
-        this.name = "DefinitionInUseError", this.definition = args.definition, this.blockedBy = args.blockedBy;
-    }
-}
-
-function definitionInUseMessage(definition, blockedBy) {
-    if (blockedBy.reason === "non-terminal-instances") {
-        const head = blockedBy.instanceIds.slice(0, 3).join(", "), preview = blockedBy.instanceIds.length > 3 ? `${head}, …` : head;
-        return `Cannot delete ${definition}: ${blockedBy.instanceIds.length} non-terminal instance(s) exist (${preview}). Pass cascade to abort them first — instances are aborted in place, never deleted.`;
-    }
-    const names = blockedBy.referrers.map(r => `${r.definition} v${r.version}`).join(", ");
-    return `Cannot delete ${definition}: still spawn-referenced by deployed definition(s) ${names}. Delete or redeploy the referrer(s) first.`;
-}
-
-class EffectNotFoundError extends WorkflowError {
-    instanceId;
-    effectKey;
-    settled;
-    constructor(args) {
-        super("effect-not-found", effectNotFoundMessage(args)), this.name = "EffectNotFoundError", 
-        this.instanceId = args.instanceId, this.effectKey = args.effectKey, args.settled !== void 0 && (this.settled = args.settled);
-    }
-}
-
-function effectNotFoundMessage(args) {
-    const base = `Pending effect "${args.effectKey}" not found on instance ${args.instanceId}`;
-    if (args.settled === void 0) return base;
-    const cause = args.settled.detail !== void 0 ? ` (${args.settled.detail})` : "";
-    return args.settled.status === "cancelled" ? `${base} — it was cancelled at ${args.settled.ranAt}${cause}` : `${base} — it already settled "${args.settled.status}" at ${args.settled.ranAt}${cause}`;
-}
-
 const KNOWN_SCHEMES = /* @__PURE__ */ new Set([ "dataset", "canvas", "media-library", "dashboard" ]), KNOWN_SCHEMES_TEXT = [ ...KNOWN_SCHEMES ].join(", ");
 
 class VersionSpecificDatasetGdrError extends Error {
@@ -343,6 +270,79 @@ function isGdr(value) {
     return typeof value == "object" && value !== null && typeof value.id == "string" && typeof value.type == "string";
 }
 
+class WorkflowError extends Error {
+    kind;
+    constructor(kind, message, options) {
+        super(message, options), this.kind = kind;
+    }
+}
+
+class ContractViolationError extends WorkflowError {
+    constructor(message) {
+        super("contract-violation", message), this.name = "ContractViolationError";
+    }
+}
+
+class InstanceNotFoundError extends WorkflowError {
+    instanceId;
+    constructor(args) {
+        super("instance-not-found", `Workflow instance ${args.instanceId} not found${args.detail ? ` (${args.detail})` : ""}`), 
+        this.name = "InstanceNotFoundError", this.instanceId = args.instanceId;
+    }
+}
+
+class DefinitionNotFoundError extends WorkflowError {
+    definition;
+    version;
+    constructor(args) {
+        super("definition-not-found", args.version !== void 0 ? `Workflow definition ${args.definition} v${args.version} not deployed` : `Workflow definition ${args.definition} has no deployed versions`), 
+        this.name = "DefinitionNotFoundError", this.definition = args.definition, args.version !== void 0 && (this.version = args.version);
+    }
+}
+
+class SpawnContractsInvalidError extends WorkflowError {
+    issues;
+    constructor(args) {
+        super("spawn-contracts-invalid", args.message), this.name = "SpawnContractsInvalidError", 
+        this.issues = args.issues;
+    }
+}
+
+class DefinitionInUseError extends WorkflowError {
+    definition;
+    blockedBy;
+    constructor(args) {
+        super("definition-in-use", definitionInUseMessage(args.definition, args.blockedBy)), 
+        this.name = "DefinitionInUseError", this.definition = args.definition, this.blockedBy = args.blockedBy;
+    }
+}
+
+function definitionInUseMessage(definition, blockedBy) {
+    if (blockedBy.reason === "non-terminal-instances") {
+        const head = blockedBy.instanceIds.slice(0, 3).join(", "), preview = blockedBy.instanceIds.length > 3 ? `${head}, …` : head;
+        return `Cannot delete ${definition}: ${blockedBy.instanceIds.length} non-terminal instance(s) exist (${preview}). Pass cascade to abort them first — instances are aborted in place, never deleted.`;
+    }
+    const names = blockedBy.referrers.map(r => `${r.definition} v${r.version}`).join(", ");
+    return `Cannot delete ${definition}: still spawn-referenced by deployed definition(s) ${names}. Delete or redeploy the referrer(s) first.`;
+}
+
+class EffectNotFoundError extends WorkflowError {
+    instanceId;
+    effectKey;
+    settled;
+    constructor(args) {
+        super("effect-not-found", effectNotFoundMessage(args)), this.name = "EffectNotFoundError", 
+        this.instanceId = args.instanceId, this.effectKey = args.effectKey, args.settled !== void 0 && (this.settled = args.settled);
+    }
+}
+
+function effectNotFoundMessage(args) {
+    const base = `Pending effect "${args.effectKey}" not found on instance ${args.instanceId}`;
+    if (args.settled === void 0) return base;
+    const cause = args.settled.detail !== void 0 ? ` (${args.settled.detail})` : "";
+    return args.settled.status === "cancelled" ? `${base} — it was cancelled at ${args.settled.ranAt}${cause}` : `${base} — it already settled "${args.settled.status}" at ${args.settled.ranAt}${cause}`;
+}
+
 const LAKE_ID_SEGMENT_RE = /^[a-z0-9][a-z0-9-]*$/, LAKE_ID_SEGMENT_GLOSS = "ASCII lowercase + digits + dashes, no leading dash, no dots";
 
 function validateTag(tag) {
@@ -668,6 +668,7 @@ function desugarFieldEntry({entry: entry, path: path, ctx: ctx}) {
             options: entry.options,
             validation: entry.validation,
             types: entry.types,
+            roles: entry.roles,
             fields: entry.fields,
             of: entry.of
         })
@@ -1289,10 +1290,18 @@ function refKindAcceptsTypes(kind) {
     return isSingleDocRefKind(kind) || kind === "doc.refs";
 }
 
+function assignmentKindAcceptsRoles(kind) {
+    return kind === "assignee" || kind === "assignees";
+}
+
 function isSingleDocRefEntry(entry) {
     return isSingleDocRefKind(entry._type);
 }
 
+function isAssignmentFieldEntry(entry) {
+    return assignmentKindAcceptsRoles(entry._type);
+}
+
 function isTodoListItem(row) {
     if (typeof row != "object" || row === null) return !1;
     const candidate = row, status = candidate.status;
@@ -1601,6 +1610,10 @@ function lakePrincipalId(args) {
     return args.localPrincipalId ?? args.actor.id;
 }
 
+function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+
 class FieldValueShapeError extends WorkflowError {
     entryType;
     entryName;
@@ -1697,9 +1710,16 @@ const fieldValueSchemas = {
     query: v__namespace.any()
 };
 
-function shapeValueSchema(shape, leaf) {
-    if (shape.type === "object") return objectSchema(shape.fields ?? [], leaf);
-    if (shape.type === "array") return v__namespace.array(objectSchema(shape.of ?? [], leaf));
+function shapeValueSchema(args) {
+    const {shape: shape, leaf: leaf} = args;
+    if (shape.type === "object") return objectSchema({
+        fields: shape.fields ?? [],
+        leaf: leaf
+    });
+    if (shape.type === "array") return v__namespace.array(objectSchema({
+        fields: shape.of ?? [],
+        leaf: leaf
+    }));
     const schema = leaf[shape.type] ?? v__namespace.any();
     return constrainedScalarSchema({
         schema: schema,
@@ -1750,19 +1770,31 @@ function constrainedScalarSchema(args) {
     }) ?? [] ].join("; ")));
 }
 
-function objectSchema(fields, leaf) {
-    const entries = /* @__PURE__ */ Object.create(null);
-    for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema(f, leaf));
+function objectSchema(args) {
+    const {fields: fields, leaf: leaf} = args, entries = /* @__PURE__ */ Object.create(null);
+    for (const f of fields) entries[f.name] = v__namespace.optional(shapeValueSchema({
+        shape: f,
+        leaf: leaf
+    }));
     return v__namespace.looseObject(entries);
 }
 
 function wholeValueSchema(args) {
     const {entryType: entryType, shape: shape, leaf: leaf} = args;
-    return entryType === "object" ? v__namespace.union([ v__namespace.null(), objectSchema(shape.fields ?? [], leaf) ]) : entryType === "array" ? v__namespace.array(objectSchema(shape.of ?? [], leaf)) : leaf[entryType];
+    return entryType === "object" ? v__namespace.union([ v__namespace.null(), objectSchema({
+        fields: shape.fields ?? [],
+        leaf: leaf
+    }) ]) : entryType === "array" ? v__namespace.array(objectSchema({
+        fields: shape.of ?? [],
+        leaf: leaf
+    })) : leaf[entryType];
 }
 
 function appendItemSchema(entryType, shape) {
-    if (entryType === "array") return objectSchema(shape.of ?? [], valueSchemas);
+    if (entryType === "array") return objectSchema({
+        fields: shape.of ?? [],
+        leaf: valueSchemas
+    });
     if (entryType === "doc.refs") return GdrShape;
     if (entryType === "assignees") return AssigneeWriteShape;
 }
@@ -1814,7 +1846,7 @@ function checkValueAgainst(args, leaf) {
         entryType: args.entryType,
         validation: args.validation,
         value: args.value
-    });
+    }) ?? assignmentValueIssues(args, result.output);
     return postIssues !== void 0 ? {
         issues: postIssues
     } : {
@@ -1822,6 +1854,142 @@ function checkValueAgainst(args, leaf) {
     };
 }
 
+function assignmentIdentity(assignee) {
+    return assignee.type === "user" ? `user:${assignee.id}` : `role:${assignee.role}`;
+}
+
+function assignmentCandidate(value) {
+    const parsed = v__namespace.safeParse(AssigneeShape, value);
+    return parsed.success ? parsed.output : void 0;
+}
+
+function assignmentValueIssues(args, value) {
+    const retained = previousAssignmentIdentities(args), issues = [];
+    return visitAssignmentEntries({
+        entryType: args.entryType,
+        value: value,
+        roles: args.roles,
+        fields: args.fields,
+        of: args.of,
+        path: "$"
+    }, ({assignee: assignee, roles: roles, path: path}) => {
+        consumeRetainedAssignment({
+            retained: retained,
+            path: path,
+            identity: assignmentIdentity(assignee)
+        }) || issues.push(...assignmentCandidateIssues({
+            roles: roles,
+            memberRoles: args.memberRoles,
+            roleAliases: args.roleAliases
+        }, assignee));
+    }), issues.length === 0 ? void 0 : issues;
+}
+
+function consumeRetainedAssignment(args) {
+    const identities = args.retained.get(args.path), remaining = identities?.get(args.identity) ?? 0;
+    return remaining === 0 || identities === void 0 ? !1 : (remaining === 1 ? identities.delete(args.identity) : identities.set(args.identity, remaining - 1), 
+    !0);
+}
+
+function previousAssignmentIdentities(args) {
+    const retained = /* @__PURE__ */ new Map;
+    if (args.previousValue === void 0 || args.entryType === "assignee") return retained;
+    const schema = wholeValueSchema({
+        entryType: args.entryType,
+        shape: args,
+        leaf: valueSchemas
+    });
+    if (schema === void 0) return retained;
+    const previous = v__namespace.safeParse(schema, args.previousValue);
+    return previous.success && visitAssignmentEntries({
+        entryType: args.entryType,
+        value: previous.output,
+        roles: args.roles,
+        fields: args.fields,
+        of: args.of,
+        path: "$"
+    }, ({assignee: assignee, path: path}) => {
+        const identities = retained.get(path) ?? /* @__PURE__ */ new Map, identity = assignmentIdentity(assignee);
+        identities.set(identity, (identities.get(identity) ?? 0) + 1), retained.set(path, identities);
+    }), retained;
+}
+
+function visitAssignmentEntries(args, visit) {
+    if (assignmentKindAcceptsRoles(args.entryType)) {
+        visitAssignmentCandidates(args, visit);
+        return;
+    }
+    if (args.entryType === "object") {
+        visitAssignmentFields({
+            fields: args.fields,
+            value: args.value,
+            path: args.path
+        }, visit);
+        return;
+    }
+    if (!(args.entryType !== "array" || !Array.isArray(args.value))) for (const row of args.value) visitAssignmentFields({
+        fields: args.of,
+        value: row,
+        path: `${args.path}[]`
+    }, visit);
+}
+
+function visitAssignmentCandidates(args, visit) {
+    if (args.roles === void 0) return;
+    const indexedValues = args.entryType === "assignees" && Array.isArray(args.value) ? args.value.map(value => ({
+        value: value,
+        path: args.path
+    })) : [ {
+        value: args.value,
+        path: args.path
+    } ];
+    for (const {value: value, path: path} of indexedValues) {
+        const assignee = assignmentCandidate(value);
+        assignee !== void 0 && visit({
+            assignee: assignee,
+            roles: args.roles,
+            path: path
+        });
+    }
+}
+
+function visitAssignmentFields(args, visit) {
+    if (!(args.fields === void 0 || !isRecord(args.value))) for (const field of args.fields) visitAssignmentShape({
+        shape: field,
+        value: args.value[field.name],
+        path: `${args.path}.${field.name}`
+    }, visit);
+}
+
+function visitAssignmentShape(args, visit) {
+    visitAssignmentEntries({
+        entryType: args.shape.type,
+        value: args.value,
+        roles: args.shape.roles,
+        fields: args.shape.fields,
+        of: args.shape.of,
+        path: args.path
+    }, visit);
+}
+
+function assignmentCandidateIssues(args, assignee) {
+    if (assignee.type === "role") return collectiveRoleIssues(args, assignee.role);
+    const held = args.memberRoles?.[assignee.id];
+    return held === void 0 ? args.memberRoles === void 0 ? [] : [ `user "${assignee.id}" has no available project membership for role eligibility` ] : args.roles.some(required => actorFulfillsRole({
+        actorRoles: held,
+        required: required,
+        aliases: args.roleAliases
+    })) ? [] : [ `user "${assignee.id}" does not fulfill any eligible role: ${formatEligibleRoles(args.roles)}` ];
+}
+
+function collectiveRoleIssues(args, role) {
+    return args.roles.includes(role) ? [] : [ `collective role "${role}" is not eligible — this entry accepts ${formatEligibleRoles(args.roles)}` ];
+}
+
+function formatEligibleRoles(roles) {
+    return roles.map(role => `"${role}"`).join(", ");
+}
+
 function issuesOf(check) {
     return "issues" in check ? check.issues : void 0;
 }
@@ -1881,6 +2049,20 @@ function validateFieldAppendItem(args) {
         issues: formatIssues(result.issues),
         mode: "item"
     });
+    const assignmentArgs = {
+        entryType: appendAssignmentEntryType(args.entryType),
+        value: result.output,
+        roles: args.roles,
+        fields: args.entryType === "array" ? args.of : void 0,
+        memberRoles: args.memberRoles,
+        roleAliases: args.roleAliases
+    }, assignmentIssues = assignmentValueIssues(assignmentArgs, result.output);
+    if (assignmentIssues !== void 0) throw new FieldValueShapeError({
+        entryType: args.entryType,
+        entryName: args.entryName,
+        issues: assignmentIssues,
+        mode: "item"
+    });
     const typeIssues = refTypeIssues({
         entryType: args.entryType,
         types: args.types,
@@ -1895,6 +2077,10 @@ function validateFieldAppendItem(args) {
     return result.output;
 }
 
+function appendAssignmentEntryType(entryType) {
+    return entryType === "assignees" ? "assignee" : entryType === "array" ? "object" : entryType;
+}
+
 function formatIssues(issues, formatMessage = issue => issue.message) {
     const formatOne = (issue, prefix) => {
         const keys = [ ...prefix, ...issue.path?.map(p => p.key) ?? [] ], sub = issue.issues?.filter(candidate => candidate.expected !== "null");
@@ -2087,16 +2273,17 @@ function compositeChecked(entries) {
     return v__namespace.pipe(v__namespace.strictObject(entries), v__namespace.check(input => compositeShapeOk(input), issue => compositeShapeMessage(issue.input)), v__namespace.check(input => duplicateSubfieldName(input) === void 0, issue => `duplicate sub-field name "${duplicateSubfieldName(issue.input)}" — sub-field names must be unique within \`fields\` / \`of\``));
 }
 
-const FieldShapeSchema = v__namespace.lazy(() => v__namespace.pipe(compositeChecked({
+const AssignmentRolesSchema = v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one eligible role, or omit `roles`")), FieldShapeSchema = v__namespace.lazy(() => v__namespace.pipe(compositeChecked({
     type: FieldValueKindSchema,
     name: FieldEntryName,
     title: v__namespace.optional(v__namespace.string()),
     description: v__namespace.optional(v__namespace.string()),
     options: v__namespace.optional(ChoiceOptionsSchema),
     validation: v__namespace.optional(ScalarValidationSchema),
+    roles: v__namespace.optional(AssignmentRolesSchema),
     fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
     of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
-}), choiceOptionsCheck(), scalarValidationCheck())), StoredEditableSchema = v__namespace.union([ v__namespace.literal(!0), NonEmpty ]), AuthoringEditableSchema = v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]);
+}), choiceOptionsCheck(), scalarValidationCheck(), assignmentRolesCheck())), StoredEditableSchema = v__namespace.union([ v__namespace.literal(!0), NonEmpty ]), AuthoringEditableSchema = v__namespace.union([ v__namespace.literal(!0), v__namespace.array(NonEmpty), NonEmpty ]);
 
 function fieldBase(editable, group) {
     return {
@@ -2117,6 +2304,7 @@ function fieldEntryFields({editable: editable, group: group, kind: kind = FieldK
         options: v__namespace.optional(ChoiceOptionsSchema),
         validation: v__namespace.optional(ScalarValidationSchema),
         types: v__namespace.optional(v__namespace.pipe(v__namespace.array(NonEmpty), v__namespace.minLength(1, "declare at least one accepted type, or omit `types` to accept any"))),
+        roles: v__namespace.optional(AssignmentRolesSchema),
         fields: v__namespace.optional(v__namespace.array(FieldShapeSchema)),
         of: v__namespace.optional(v__namespace.array(FieldShapeSchema))
     };
@@ -2130,7 +2318,8 @@ function literalSeedIssues(entry) {
         fields: entry.fields,
         of: entry.of,
         options: entry.options,
-        validation: entry.validation
+        validation: entry.validation,
+        roles: entry.roles
     });
 }
 
@@ -2142,6 +2331,10 @@ function refTypesCheck() {
     return v__namespace.check(entry => entry.types === void 0 || refKindAcceptsTypes(entry.type), issue => `\`types\` is only valid on \`doc.ref\` / \`doc.refs\` / \`subject\` entries, not "${issue.input.type}"`);
 }
 
+function assignmentRolesCheck() {
+    return v__namespace.check(entry => entry.roles === void 0 || assignmentKindAcceptsRoles(entry.type), issue => `\`roles\` is only valid on \`assignee\` / \`assignees\` entries, not "${issue.input.type}"`);
+}
+
 function choiceOptionsCheck() {
     return v__namespace.check(entry => checkChoiceList({
         entryType: entry.type,
@@ -2176,11 +2369,11 @@ function scalarValidationDeclarationIssues(entry) {
 const FieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
     editable: StoredEditableSchema,
     group: StoredGroupMembershipSchema
-})), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
+})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), RawAuthoringFieldEntrySchema = pinned()(v__namespace.pipe(compositeChecked(fieldEntryFields({
     editable: AuthoringEditableSchema,
     group: AuthoringGroupMembershipSchema,
     kind: AuthoringRawFieldKindSchema
-})), refTypesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
+})), refTypesCheck(), assignmentRolesCheck(), choiceOptionsCheck(), scalarValidationCheck(), literalSeedCheck())), ClaimFieldSchema = pinned()(v__namespace.strictObject({
     type: v__namespace.literal("claim"),
     name: FieldEntryName,
     title: v__namespace.optional(v__namespace.string()),
@@ -3948,6 +4141,8 @@ exports.actorFulfillsRole = actorFulfillsRole;
 
 exports.andConditions = andConditions;
 
+exports.assignmentKindAcceptsRoles = assignmentKindAcceptsRoles;
+
 exports.checkWorkflowInvariants = checkWorkflowInvariants;
 
 exports.choiceValueIssues = choiceValueIssues;
@@ -4012,6 +4207,8 @@ exports.groupMembershipNames = groupMembershipNames;
 
 exports.isAlwaysArrayFieldKind = isAlwaysArrayFieldKind;
 
+exports.isAssignmentFieldEntry = isAssignmentFieldEntry;
+
 exports.isBareSeedId = isBareSeedId;
 
 exports.isCascadeFired = isCascadeFired;
@@ -4028,6 +4225,8 @@ exports.isNotesEntry = isNotesEntry;
 
 exports.isParseableInstant = isParseableInstant;
 
+exports.isRecord = isRecord;
+
 exports.isSingleDocRefEntry = isSingleDocRefEntry;
 
 exports.isSingleDocRefKind = isSingleDocRefKind;