@objectstack/service-automation 7.8.0 → 8.0.0

package/dist/index.cjs

@@ -181,7 +181,7 @@ var AutomationEngine = class {
         description: `Deprecated alias of '${canonicalType}' (ADR-0018 M3). Author new flows with '${canonicalType}'.`,
         category: meta?.category ?? "io",
         source: "builtin",
-        paradigms: meta?.paradigms ?? ["flow", "workflow_rule", "approval"],
+        paradigms: meta?.paradigms ?? ["flow", "approval"],
         supportsRetry: true,
         needsOutbox: meta?.needsOutbox ?? false,
         deprecated: true,
@@ -1023,6 +1023,9 @@ ${failures.join("\n")}`
         completedAt: (/* @__PURE__ */ new Date()).toISOString(),
         durationMs: Date.now() - stepStart
       });
+      if (result.childSteps?.length) {
+        steps.push(...result.childSteps);
+      }
       if (result.output) {
         for (const [key, value] of Object.entries(result.output)) {
           variables.set(`${node.id}.${key}`, value);
@@ -1087,14 +1090,19 @@ ${failures.join("\n")}`
    * nodes/edges, so the main DAG traversal (`traverseNext`) is never aware of
    * scope markers — keeping the shared traversal untouched.
    *
-   * Body step logs are kept in a region-local array (not yet merged into the
-   * parent run log); surfacing per-iteration steps is a follow-up.
+   * #1479: the executed body steps are **returned** (tagged with `grouping`)
+   * so the calling container node can fold them into the parent run log via
+   * `NodeExecutionResult.childSteps`. Tagging only fills fields left undefined,
+   * so when regions nest, each step keeps its **innermost** container's
+   * `parentNodeId` / `iteration` / `regionKind`. On failure the region throws
+   * as before (preserving `try_catch` retry semantics); a failed attempt's
+   * partial steps are not surfaced.
    *
    * Durable pause (`suspend`) inside a region is not supported in this
    * iteration — it is converted into a clear error (mirrors the `subflow`
    * nested-pause guard).
    */
-  async runRegion(region, variables, context) {
+  async runRegion(region, variables, context, grouping) {
     const entryId = (0, import_automation.findRegionEntry)(region);
     const entry = region.nodes.find((n) => n.id === entryId);
     if (!entry) {
@@ -1112,6 +1120,16 @@ ${failures.join("\n")}`
       }
       throw err;
     }
+    if (grouping) {
+      for (const step of regionSteps) {
+        if (step.parentNodeId === void 0) {
+          step.parentNodeId = grouping.parentNodeId;
+          if (grouping.iteration !== void 0) step.iteration = grouping.iteration;
+          if (grouping.regionKind !== void 0) step.regionKind = grouping.regionKind;
+        }
+      }
+    }
+    return regionSteps;
   }
   /**
    * Execute a promise with timeout using Promise.race.
@@ -1796,13 +1814,19 @@ function registerLoopNode(engine, ctx) {
         };
       }
       let iterations = 0;
+      const childSteps = [];
       for (let i = 0; i < collection.length; i++) {
         variables.set(iteratorVariable, collection[i]);
         if (indexVariable) variables.set(indexVariable, i);
-        await engine.runRegion(body, variables, context ?? {});
+        const iterSteps = await engine.runRegion(body, variables, context ?? {}, {
+          parentNodeId: node.id,
+          iteration: i,
+          regionKind: "loop-body"
+        });
+        childSteps.push(...iterSteps);
         iterations++;
       }
-      return { success: true, output: { iterations } };
+      return { success: true, output: { iterations }, childSteps };
     }
   });
   ctx.logger.info("[Loop Node] 1 built-in node executor registered");
@@ -1850,15 +1874,22 @@ function registerParallelNode(engine, ctx) {
           error: `parallel '${node.id}': config.branches must declare at least 2 branch regions`
         };
       }
+      let branchSteps;
       try {
-        await Promise.all(
-          branches.map((branch) => engine.runRegion(branch, variables, context ?? {}))
+        branchSteps = await Promise.all(
+          branches.map(
+            (branch, i) => engine.runRegion(branch, variables, context ?? {}, {
+              parentNodeId: node.id,
+              iteration: i,
+              regionKind: "parallel-branch"
+            })
+          )
         );
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { success: false, error: `parallel '${node.id}': branch failed \u2014 ${message}` };
       }
-      return { success: true, output: { branches: branches.length } };
+      return { success: true, output: { branches: branches.length }, childSteps: branchSteps.flat() };
     }
   });
   ctx.logger.info("[Parallel Node] 1 built-in node executor registered");
@@ -1929,8 +1960,11 @@ function registerTryCatchNode(engine, ctx) {
           if (delay > 0) await new Promise((r) => setTimeout(r, delay));
         }
         try {
-          await engine.runRegion(tryRegion, variables, ctxOrEmpty);
-          return { success: true, output: { attempts: attempt + 1, caught: false } };
+          const trySteps = await engine.runRegion(tryRegion, variables, ctxOrEmpty, {
+            parentNodeId: node.id,
+            regionKind: "try"
+          });
+          return { success: true, output: { attempts: attempt + 1, caught: false }, childSteps: trySteps };
         } catch (err) {
           lastError = err instanceof Error ? err.message : String(err);
         }
@@ -1938,8 +1972,15 @@ function registerTryCatchNode(engine, ctx) {
       if (catchRegion != null) {
         variables.set(errorVariable, { nodeId: node.id, message: lastError });
         try {
-          await engine.runRegion(catchRegion, variables, ctxOrEmpty);
-          return { success: true, output: { attempts: maxRetries + 1, caught: true, error: lastError } };
+          const catchSteps = await engine.runRegion(catchRegion, variables, ctxOrEmpty, {
+            parentNodeId: node.id,
+            regionKind: "catch"
+          });
+          return {
+            success: true,
+            output: { attempts: maxRetries + 1, caught: true, error: lastError },
+            childSteps: catchSteps
+          };
         } catch (catchErr) {
           const catchMsg = catchErr instanceof Error ? catchErr.message : String(catchErr);
           return { success: false, error: `try_catch '${node.id}': catch region failed \u2014 ${catchMsg}` };
@@ -2197,7 +2238,7 @@ function registerHttpNodes(engine, ctx) {
       // and the messaging HTTP outbox is wired).
       needsOutbox: true,
       supportsRetry: true,
-      paradigms: ["flow", "workflow_rule", "approval"],
+      paradigms: ["flow", "approval"],
       configSchema: {
         type: "object",
         required: ["url"],
@@ -2307,8 +2348,9 @@ function registerConnectorNodes(engine, ctx) {
       category: "io",
       source: "builtin",
       supportsRetry: true,
-      // Present in all three authoring paradigms (ADR-0018 §registry table).
-      paradigms: ["flow", "workflow_rule", "approval"],
+      // Present in both authoring paradigms (ADR-0018 §registry table;
+      // workflow_rule retired per ADR-0019).
+      paradigms: ["flow", "approval"],
       // Config contract — drives the Studio property form and flow validation.
       configSchema: {
         type: "object",
@@ -2383,7 +2425,7 @@ function registerNotifyNode(engine, ctx) {
       // Delivery is outbox-backed inside the messaging service (ADR-0030
       // emit → sys_notification_delivery), so it inherits retry/dead-letter.
       needsOutbox: true,
-      paradigms: ["flow", "workflow_rule", "approval"]
+      paradigms: ["flow", "approval"]
     }),
     async execute(node, variables, context) {
       const cfg = node.config ?? {};