@workglow/task-graph 0.2.12 → 0.2.14

package/dist/browser.js

@@ -636,7 +636,8 @@ function computeGraphInputSchema(graph, options) {
     for (const [inputName, inputProp] of Object.entries(taskProperties)) {
       if (!properties[inputName]) {
         properties[inputName] = inputProp;
-        if (taskInputSchema.required && taskInputSchema.required.includes(inputName)) {
+        const isRequired = taskInputSchema.required?.includes(inputName) === true && !(task.defaults && task.defaults[inputName] !== undefined);
+        if (isRequired) {
           required.push(inputName);
         }
         if (trackOrigins) {
@@ -949,6 +950,7 @@ import { DirectedAcyclicGraph } from "@workglow/util/graph";
 
 // src/task/GraphAsTask.ts
 import { getLogger as getLogger4 } from "@workglow/util";
+import { CycleError } from "@workglow/util/graph";
 import { compileSchema as compileSchema2 } from "@workglow/util/schema";
 
 // src/task-graph/TaskGraphRunner.ts
@@ -2473,6 +2475,11 @@ function evaluatePolicy(policy, required) {
   }
   return results;
 }
+function can(policy, id, resources) {
+  const required = resources !== undefined ? { id, resources } : { id };
+  const [result] = evaluatePolicy(policy, { entitlements: [required] });
+  return result;
+}
 
 // src/task/EntitlementResolver.ts
 import { createServiceToken as createServiceToken2 } from "@workglow/util";
@@ -2489,6 +2496,16 @@ var DENY_ALL_RESOLVER = {
 var ENTITLEMENT_RESOLVER = createServiceToken2("workglow.entitlementResolver");
 
 // src/task/EntitlementEnforcer.ts
+function formatEntitlementDenial(denial) {
+  switch (denial.reason) {
+    case "policy-deny":
+      return `${denial.entitlement.id} (denied by rule ${denial.matchedRule.id})`;
+    case "user-deny":
+      return `${denial.entitlement.id} (denied by user)`;
+    case "default-deny":
+      return `${denial.entitlement.id} (no matching grant)`;
+  }
+}
 var PERMISSIVE_ENFORCER = {
   checkAll: async () => [],
   checkTask: async () => []
@@ -2499,24 +2516,27 @@ function createPolicyEnforcer(policy, resolver = PERMISSIVE_RESOLVER) {
     const denied = [];
     for (const result of results) {
       if (result.verdict === "denied") {
-        denied.push(result.entitlement);
+        if (result.matchedRule) {
+          denied.push({ entitlement: result.entitlement, reason: "policy-deny", matchedRule: result.matchedRule });
+        } else {
+          denied.push({ entitlement: result.entitlement, reason: "default-deny" });
+        }
       } else if (result.verdict === "ask") {
         const request = {
           entitlement: result.entitlement,
           taskType: taskType ?? "unknown",
           taskId: taskId ?? "unknown"
         };
-        const saved = resolver.lookup(request);
-        if (saved !== undefined) {
-          if (saved === "deny") {
-            denied.push(result.entitlement);
-          }
-          continue;
+        let answer = resolver.lookup(request);
+        if (answer === undefined) {
+          answer = await resolver.prompt(request);
+          resolver.save(request, answer);
         }
-        const answer = await resolver.prompt(request);
-        resolver.save(request, answer);
         if (answer === "deny") {
-          denied.push(result.entitlement);
+          if (!result.matchedRule) {
+            throw new Error(`Invariant violation: ask verdict for "${result.entitlement.id}" is missing matchedRule`);
+          }
+          denied.push({ entitlement: result.entitlement, reason: "user-deny", matchedRule: result.matchedRule });
         }
       }
     }
@@ -2736,7 +2756,7 @@ class TaskGraphRunner {
         const runAsync = async () => {
           let errorRouted = false;
           try {
-            const taskInput = isRootTask ? input : this.filterInputForTask(task, input);
+            const taskInput = isRootTask ? input : config?.matchAllEmptyInputs ? this.filterInputForTask(task, input) : {};
             const taskPromise = this.runTask(task, taskInput);
             this.inProgressTasks.set(task.id, taskPromise);
             const taskResult = await taskPromise;
@@ -3024,7 +3044,7 @@ class TaskGraphRunner {
     if (this.activeEnforcer && task.constructor.hasDynamicEntitlements) {
       const denied = await this.activeEnforcer.checkTask(task);
       if (denied.length > 0) {
-        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map((e) => e.id).join(", ")}`);
+        throw new TaskEntitlementError(`Task ${task.constructor.type} denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
       }
     }
     if (isStreamable) {
@@ -3247,7 +3267,7 @@ class TaskGraphRunner {
         const enforcer = this.registry.get(ENTITLEMENT_ENFORCER);
         const denied = await enforcer.checkAll(computeGraphEntitlements(this.graph));
         if (denied.length > 0) {
-          throw new TaskEntitlementError(`Denied entitlements: ${denied.map((e) => e.id).join(", ")}`);
+          throw new TaskEntitlementError(`Denied entitlements: ${denied.map(formatEntitlementDenial).join(", ")}`);
         }
         this.activeEnforcer = enforcer;
       } else {
@@ -3591,6 +3611,18 @@ class GraphAsTask extends Task {
       yield { type: "finish", data: input };
     }
   }
+  validateAcyclic() {
+    if (!this.hasChildren())
+      return;
+    if (!this.subGraph.isAcyclic()) {
+      throw new CycleError(`${this.type} (${this.id}): subgraph contains a cycle — loop tasks must wrap an acyclic subgraph.`);
+    }
+    for (const child of this.subGraph.getTasks()) {
+      if (child instanceof GraphAsTask) {
+        child.validateAcyclic();
+      }
+    }
+  }
   regenerateGraph() {
     this._inputSchemaNode = undefined;
     this.events.emit("regenerate");
@@ -3741,7 +3773,7 @@ function convertPipeFunctionToTask(fn, config) {
         properties: {
           [DATAFLOW_ALL_PORTS]: {}
         },
-        additionalProperties: false
+        additionalProperties: true
       };
     };
     static outputSchema = () => {
@@ -3750,7 +3782,7 @@ function convertPipeFunctionToTask(fn, config) {
         properties: {
           [DATAFLOW_ALL_PORTS]: {}
         },
-        additionalProperties: false
+        additionalProperties: true
       };
     };
     static cacheable = false;
@@ -3859,6 +3891,9 @@ class TaskGraph {
   topologicallySortedNodes() {
     return this._dag.topologicallySortedNodes();
   }
+  isAcyclic() {
+    return this._dag.isAcyclic();
+  }
   addTask(task, config) {
     return this._dag.addNode(ensureTask(task, config));
   }
@@ -4132,7 +4167,75 @@ function serialGraph(tasks, inputHandle, outputHandle) {
   return graph;
 }
 // src/task-graph/Workflow.ts
-import { EventEmitter as EventEmitter5, getLogger as getLogger5, uuid4 as uuid45 } from "@workglow/util";
+import { EventEmitter as EventEmitter5, getLogger as getLogger5, uuid4 as uuid46 } from "@workglow/util";
+
+// src/task-graph/ConditionalBuilder.ts
+import { uuid4 as uuid45 } from "@workglow/util";
+class ConditionalBuilder {
+  workflow;
+  condition;
+  thenSpec;
+  elseSpec;
+  constructor(workflow, condition) {
+    this.workflow = workflow;
+    this.condition = condition;
+  }
+  then(taskClass, input, config) {
+    this.thenSpec = { taskClass, input, config };
+    return this;
+  }
+  else(taskClass, input, config) {
+    this.elseSpec = { taskClass, input, config };
+    return this;
+  }
+  endIf() {
+    if (!this.thenSpec) {
+      throw new WorkflowError(".endIf() called without a prior .then(...) call");
+    }
+    const thenPort = "then";
+    const elsePort = "else";
+    const branches = [
+      {
+        id: thenPort,
+        condition: this.condition,
+        outputPort: thenPort
+      }
+    ];
+    if (this.elseSpec) {
+      branches.push({
+        id: elsePort,
+        condition: (input) => !this.condition(input),
+        outputPort: elsePort
+      });
+    }
+    const conditionalTask = new ConditionalTask({
+      id: uuid45(),
+      branches,
+      exclusive: true,
+      defaultBranch: this.elseSpec ? elsePort : undefined
+    });
+    this.workflow.graph.addTask(conditionalTask);
+    const thenTask = instantiate(this.thenSpec);
+    this.workflow.graph.addTask(thenTask);
+    this.workflow.graph.addDataflow(new Dataflow(conditionalTask.id, thenPort, thenTask.id, "*"));
+    if (this.elseSpec) {
+      const elseTask = instantiate(this.elseSpec);
+      this.workflow.graph.addTask(elseTask);
+      this.workflow.graph.addDataflow(new Dataflow(conditionalTask.id, elsePort, elseTask.id, "*"));
+    }
+    return this.workflow;
+  }
+}
+function instantiate(spec) {
+  const config = {
+    id: uuid45(),
+    ...spec.config,
+    defaults: spec.input
+  };
+  return new spec.taskClass(config);
+}
+
+// src/task-graph/Workflow.ts
 function getLastTask(workflow) {
   const tasks = workflow.graph.getTasks();
   return tasks.length > 0 ? tasks[tasks.length - 1] : undefined;
@@ -4275,7 +4378,7 @@ class Workflow {
       this._error = "";
       const parent = getLastTask(this);
       const task = this.addTaskToGraph(taskClass, {
-        id: uuid45(),
+        id: uuid46(),
         ...config,
         defaults: input
       });
@@ -4556,7 +4659,7 @@ class Workflow {
   addLoopTask(taskClass, config = {}) {
     this._error = "";
     const parent = getLastTask(this);
-    const task = this.addTaskToGraph(taskClass, { id: uuid45(), ...config });
+    const task = this.addTaskToGraph(taskClass, { id: uuid46(), ...config });
     if (this._dataFlows.length > 0) {
       this._dataFlows.forEach((dataflow) => {
         const taskSchema = task.inputSchema();
@@ -4576,6 +4679,9 @@ class Workflow {
     }
     return loopBuilder;
   }
+  if(condition) {
+    return new ConditionalBuilder(this, condition);
+  }
   autoConnectLoopTask(pending) {
     if (!pending)
       return;
@@ -4933,6 +5039,7 @@ class Workflow {
       return;
     }
     this._iteratorTask.subGraph = this.graph;
+    this._iteratorTask.validateAcyclic();
   }
   finalizeAndReturn() {
     if (!this._parentWorkflow) {
@@ -4967,6 +5074,7 @@ function getMethodNameMap() {
 }
 var LOOP_TASK_TYPES = {
   MapTask: { method: "map", endMethod: "endMap" },
+  ForEachTask: { method: "forEach", endMethod: "endForEach" },
   ReduceTask: { method: "reduce", endMethod: "endReduce" },
   WhileTask: { method: "while", endMethod: "endWhile" },
   GraphAsTask: { method: "group", endMethod: "endGroup" }
@@ -5149,7 +5257,8 @@ function extractLoopConfig(task) {
       }
       break;
     }
-    case "MapTask": {
+    case "MapTask":
+    case "ForEachTask": {
       if (rawConfig.preserveOrder !== undefined && rawConfig.preserveOrder !== true) {
         config.preserveOrder = rawConfig.preserveOrder;
       }
@@ -5162,16 +5271,22 @@ function extractLoopConfig(task) {
       if (rawConfig.batchSize !== undefined) {
         config.batchSize = rawConfig.batchSize;
       }
+      if (rawConfig.maxIterations !== undefined) {
+        config.maxIterations = rawConfig.maxIterations;
+      }
       break;
     }
     case "ReduceTask": {
       if (rawConfig.initialValue !== undefined) {
         config.initialValue = rawConfig.initialValue;
       }
+      if (rawConfig.maxIterations !== undefined) {
+        config.maxIterations = rawConfig.maxIterations;
+      }
       break;
     }
     case "WhileTask": {
-      if (rawConfig.maxIterations !== undefined && rawConfig.maxIterations !== 100) {
+      if (rawConfig.maxIterations !== undefined) {
         config.maxIterations = rawConfig.maxIterations;
       }
       if (rawConfig.chainIterations !== undefined && rawConfig.chainIterations !== true) {
@@ -5609,15 +5724,15 @@ async function compactSchemaInputs(input, schema, config, visited = new Set) {
   return compacted;
 }
 // src/task/IteratorTaskRunner.ts
-import { uuid4 as uuid46 } from "@workglow/util";
+import { uuid4 as uuid47 } from "@workglow/util";
 class IteratorTaskRunner extends GraphAsTaskRunner {
   aggregatingParentMapProgress = false;
   mapPartialProgress = [];
   mapPartialIterationCount = 0;
   async executeTask(input) {
     let analysis = this.task.analyzeIterationInput(input);
-    const maxIterations = this.task.config.maxIterations;
-    if (maxIterations !== undefined && maxIterations > 0 && analysis.iterationCount > maxIterations) {
+    const maxIterations = resolveIterationBound(this.task.config.maxIterations);
+    if (analysis.iterationCount > maxIterations) {
       analysis = { ...analysis, iterationCount: maxIterations };
     }
     if (analysis.iterationCount === 0) {
@@ -5723,7 +5838,7 @@ class IteratorTaskRunner extends GraphAsTaskRunner {
     const idMap = new Map;
     for (const task of graph.getTasks()) {
       const ctor = task.constructor;
-      const newId = uuid46();
+      const newId = uuid47();
       idMap.set(task.config.id, newId);
       const clonedConfig = { ...task.config, id: newId };
       const newTask = new ctor({ ...clonedConfig, defaults: task.defaults }, task.runConfig);
@@ -5793,15 +5908,21 @@ var ITERATOR_CONTEXT_SCHEMA = {
     }
   }
 };
+function resolveIterationBound(bound) {
+  return bound === "unbounded" ? Number.POSITIVE_INFINITY : bound;
+}
 var iteratorTaskConfigSchema = {
   type: "object",
   properties: {
     ...graphAsTaskConfigSchema["properties"],
     concurrencyLimit: { type: "integer", minimum: 1 },
     batchSize: { type: "integer", minimum: 1 },
-    maxIterations: { type: "integer", minimum: 1 },
+    maxIterations: {
+      oneOf: [{ type: "integer", minimum: 1 }, { type: "string", const: "unbounded" }]
+    },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
+  required: ["maxIterations"],
   additionalProperties: false
 };
 function isArrayVariant(schema) {
@@ -5916,6 +6037,12 @@ class IteratorTask extends GraphAsTask {
   static configSchema() {
     return iteratorTaskConfigSchema;
   }
+  constructor(config = {}, runConfig = {}) {
+    if (config.maxIterations === undefined) {
+      throw new TaskConfigurationError(`${new.target.type ?? "IteratorTask"}: maxIterations is required. ` + `Pass a positive integer to cap iteration, or "unbounded" to opt out explicitly.`);
+    }
+    super(config, runConfig);
+  }
   static getIterationContextSchema() {
     return ITERATOR_CONTEXT_SCHEMA;
   }
@@ -6305,13 +6432,16 @@ var whileTaskConfigSchema = {
   properties: {
     ...graphAsTaskConfigSchema["properties"],
     condition: {},
-    maxIterations: { type: "integer", minimum: 1 },
+    maxIterations: {
+      oneOf: [{ type: "integer", minimum: 1 }, { type: "string", const: "unbounded" }]
+    },
     chainIterations: { type: "boolean" },
     conditionField: { type: "string" },
     conditionOperator: { type: "string" },
     conditionValue: { type: "string" },
     iterationInputConfig: { type: "object", additionalProperties: true }
   },
+  required: ["maxIterations"],
   additionalProperties: false
 };
 
@@ -6324,6 +6454,12 @@ class WhileTask extends GraphAsTask {
   static configSchema() {
     return whileTaskConfigSchema;
   }
+  constructor(config = {}, runConfig = {}) {
+    if (config.maxIterations === undefined) {
+      throw new TaskConfigurationError(`${new.target.type ?? "WhileTask"}: maxIterations is required. ` + `Pass a positive integer to cap iteration, or "unbounded" to opt out explicitly.`);
+    }
+    super(config, runConfig);
+  }
   static getIterationContextSchema() {
     return WHILE_CONTEXT_SCHEMA;
   }
@@ -6341,7 +6477,7 @@ class WhileTask extends GraphAsTask {
     return this.config.condition;
   }
   get maxIterations() {
-    return this.config.maxIterations ?? 100;
+    return resolveIterationBound(this.config.maxIterations);
   }
   get chainIterations() {
     return this.config.chainIterations ?? true;
@@ -6948,8 +7084,10 @@ var mapTaskConfigSchema = {
   properties: {
     ...iteratorTaskConfigSchema["properties"],
     preserveOrder: { type: "boolean" },
-    flatten: { type: "boolean" }
+    flatten: { type: "boolean" },
+    discardResults: { type: "boolean" }
   },
+  required: iteratorTaskConfigSchema.required,
   additionalProperties: false
 };
 
@@ -6982,6 +7120,9 @@ class MapTask extends IteratorTask {
   get flatten() {
     return this.config.flatten ?? false;
   }
+  get discardResults() {
+    return this.config.discardResults ?? false;
+  }
   preserveIterationOrder() {
     return this.preserveOrder;
   }
@@ -7003,6 +7144,9 @@ class MapTask extends IteratorTask {
     return this.getWrappedOutputSchema();
   }
   collectResults(results) {
+    if (this.discardResults) {
+      return this.getEmptyResult();
+    }
     const collected = super.collectResults(results);
     if (!this.flatten || typeof collected !== "object" || collected === null) {
       return collected;
@@ -7018,8 +7162,19 @@ class MapTask extends IteratorTask {
     return flattened;
   }
 }
+
+class ForEachTask extends MapTask {
+  static type = "ForEachTask";
+  static title = "For Each";
+  static description = "Runs a workflow per array item for side effects; discards collected results";
+  constructor(config = {}, runConfig = {}) {
+    super({ discardResults: true, ...config }, runConfig);
+  }
+}
 Workflow.prototype.map = CreateLoopWorkflow(MapTask);
 Workflow.prototype.endMap = CreateEndLoopWorkflow("endMap");
+Workflow.prototype.forEach = CreateLoopWorkflow(ForEachTask);
+Workflow.prototype.endForEach = CreateEndLoopWorkflow("endForEach");
 // src/task/ReduceTask.ts
 var reduceTaskConfigSchema = {
   type: "object",
@@ -7038,13 +7193,13 @@ class ReduceTask extends IteratorTask {
   static configSchema() {
     return reduceTaskConfigSchema;
   }
-  constructor(config = {}) {
+  constructor(config = {}, runConfig = {}) {
     const reduceConfig = {
       ...config,
       concurrencyLimit: 1,
       batchSize: 1
     };
-    super(reduceConfig);
+    super(reduceConfig, runConfig);
   }
   get initialValue() {
     return this.config.initialValue ?? {};
@@ -8123,6 +8278,7 @@ export {
   scanGraphForCredentials,
   resourcePatternMatches,
   resolveSchemaInputs,
+  resolveIterationBound,
   resetMethodNameCache,
   removeIterationProperties,
   registerJobQueueFactory,
@@ -8167,6 +8323,7 @@ export {
   getFormatPrefix,
   getAppendPortId,
   formatValue,
+  formatEntitlementDenial,
   findArrayPorts,
   filterIterationProperties,
   fallbackTaskConfigSchema,
@@ -8195,6 +8352,7 @@ export {
   computeGraphInputSchema,
   computeGraphEntitlements,
   compactSchemaInputs,
+  can,
   calculateNodeDepths,
   buildIterationInputSchema,
   addIterationContextToSchema,
@@ -8247,6 +8405,7 @@ export {
   GraphAsTaskRunner,
   GraphAsTask,
   GRAPH_RESULT_ARRAY,
+  ForEachTask,
   FallbackTaskRunner,
   FallbackTask,
   EventTaskGraphToDagMapping,
@@ -8270,4 +8429,4 @@ export {
   BROWSER_GRANTS
 };
 
-//# debugId=E3C5AA591E51471C64756E2164756E21
+//# debugId=8CB4AA21F9A0895064756E2164756E21