@objectstack/service-automation 9.0.0 → 9.1.0

package/dist/index.cjs

@@ -496,6 +496,8 @@ var AutomationEngine = class {
     }
     const runId = this.nextRunId();
     variables.set("$runId", runId);
+    variables.set("$flowName", flowName);
+    variables.set("$flowLabel", flow.label ?? flowName);
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const steps = [];
     try {
@@ -704,7 +706,11 @@ var AutomationEngine = class {
       const steps = run.steps;
       const context = run.context;
       try {
-        await this.traverseNext(node, flow, variables, context, steps, signal?.branchLabel);
+        if (typeof run.correlation === "string" && run.correlation.startsWith("map:")) {
+          await this.executeNode(node, flow, variables, context, steps);
+        } else {
+          await this.traverseNext(node, flow, variables, context, steps, signal?.branchLabel);
+        }
         const output = {};
         if (flow.variables) {
           for (const v of flow.variables) {
@@ -808,10 +814,12 @@ var AutomationEngine = class {
    * caller who resumed the child.
    */
   async bubbleToParent(run, output) {
-    const parentRunId = run.context?.$parentRunId;
+    const ctx = run.context;
+    const parentRunId = ctx?.$parentRunId;
     if (typeof parentRunId !== "string" || !parentRunId) return;
     try {
-      const sig = this.buildSubflowResumeSignal(run.context, output);
+      const mapNode = ctx?.$parentMapNode;
+      const sig = typeof mapNode === "string" && mapNode ? { variables: { [`${mapNode}.$mapItemOutput`]: output ?? null, [`${mapNode}.$mapItemDone`]: true } } : this.buildSubflowResumeSignal(run.context, output);
       const parentRes = await this.resumeInternal(parentRunId, sig, false);
       if (!parentRes.success) {
         this.logger.warn(
@@ -2802,6 +2810,96 @@ function registerSubflowNode(engine, ctx) {
   ctx.logger.info("[Subflow Node] 1 built-in node executor registered");
 }
 
+// src/builtin/map-node.ts
+var import_automation13 = require("@objectstack/spec/automation");
+var MAX_MAP_ITEMS = 1e4;
+function registerMapNode(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "map",
+    descriptor: (0, import_automation13.defineActionDescriptor)({
+      type: "map",
+      version: "1.0.0",
+      name: "Map",
+      description: "Run a per-item subflow for each element of a collection, one at a time (each item may pause).",
+      icon: "list-check",
+      category: "logic",
+      source: "builtin",
+      // Each item's subflow may pause, so the map suspends and resumes per item.
+      supportsPause: true,
+      isAsync: true
+    }),
+    async execute(node, variables, context) {
+      const cfg = node.config ?? {};
+      const flowName = typeof cfg.flowName === "string" ? cfg.flowName : typeof cfg.flow === "string" ? cfg.flow : void 0;
+      if (!flowName) {
+        return { success: false, error: `map '${node.id}': config.flowName (the per-item subflow) is required` };
+      }
+      const iteratorVariable = typeof cfg.iteratorVariable === "string" && cfg.iteratorVariable ? cfg.iteratorVariable : "item";
+      const indexVariable = typeof cfg.indexVariable === "string" && cfg.indexVariable ? cfg.indexVariable : void 0;
+      const outVar = typeof cfg.outputVariable === "string" && cfg.outputVariable ? cfg.outputVariable : void 0;
+      const rawCollection = cfg.collection;
+      let collection;
+      if (Array.isArray(rawCollection)) {
+        collection = rawCollection;
+      } else if (typeof rawCollection === "string") {
+        collection = interpolate(rawCollection, variables, context ?? {});
+        if (collection == null && variables.has(rawCollection)) collection = variables.get(rawCollection);
+      }
+      if (!Array.isArray(collection)) {
+        return { success: false, error: `map '${node.id}': collection '${String(rawCollection)}' did not resolve to an array` };
+      }
+      if (collection.length > MAX_MAP_ITEMS) {
+        return { success: false, error: `map '${node.id}': collection length ${collection.length} exceeds the ${MAX_MAP_ITEMS} cap` };
+      }
+      const stateKey = `${node.id}.$mapState`;
+      const state = variables.get(stateKey) ?? {
+        started: 0,
+        results: []
+      };
+      if (variables.get(`${node.id}.$mapItemDone`) === true) {
+        state.results.push(variables.get(`${node.id}.$mapItemOutput`) ?? null);
+        variables.delete(`${node.id}.$mapItemDone`);
+        variables.delete(`${node.id}.$mapItemOutput`);
+      }
+      const parentRunId = variables.get("$runId");
+      while (state.started < collection.length) {
+        const idx = state.started;
+        const item = collection[idx];
+        variables.set(iteratorVariable, item);
+        if (indexVariable) variables.set(indexVariable, idx);
+        const rawInput = cfg.input && typeof cfg.input === "object" ? cfg.input : {};
+        const params = interpolate(rawInput, variables, context ?? {});
+        const itemIsRecord = item != null && typeof item === "object" && typeof item.id === "string";
+        const itemObject = typeof cfg.itemObject === "string" ? cfg.itemObject : context?.object;
+        const childContext = {
+          ...context ?? {},
+          params,
+          ...itemIsRecord ? { record: item, object: itemObject } : {},
+          ...parentRunId != null ? { $parentRunId: String(parentRunId), $parentMapNode: node.id } : {}
+        };
+        const child = await engine.execute(flowName, childContext);
+        if (child.status === "paused") {
+          if (!child.runId) {
+            return { success: false, error: `map '${node.id}': item ${idx} paused without a run id \u2014 cannot link the runs` };
+          }
+          state.started = idx + 1;
+          variables.set(stateKey, state);
+          return { success: true, suspend: true, correlation: `map:${child.runId}` };
+        }
+        if (!child.success) {
+          return { success: false, error: `map '${node.id}': item ${idx} (subflow '${flowName}') failed: ${child.error ?? "unknown error"}` };
+        }
+        state.started = idx + 1;
+        state.results.push(child.output ?? null);
+      }
+      variables.set(stateKey, state);
+      if (outVar) variables.set(outVar, state.results);
+      return { success: true, output: { results: state.results, count: state.results.length } };
+    }
+  });
+  ctx.logger.info("[Map Node] 1 built-in node executor registered");
+}
+
 // src/builtin/index.ts
 function installBuiltinNodes(engine, ctx) {
   registerLogicNodes(engine, ctx);
@@ -2815,6 +2913,7 @@ function installBuiltinNodes(engine, ctx) {
   registerNotifyNode(engine, ctx);
   registerWaitNode(engine, ctx);
   registerSubflowNode(engine, ctx);
+  registerMapNode(engine, ctx);
   const types = engine.getRegisteredNodeTypes();
   ctx.logger.info(
     `[Automation] ${types.length} built-in node executors installed: ${types.join(", ")}`