@objectstack/service-automation 7.4.1 → 7.5.0

package/dist/index.cjs

@@ -1668,6 +1668,142 @@ function registerNotifyNode(engine, ctx) {
   ctx.logger.info("[Notify] 1 built-in node executor registered (notify)");
 }
 
+// src/builtin/wait-node.ts
+var import_automation8 = require("@objectstack/spec/automation");
+function registerWaitNode(engine, ctx) {
+  const getJobService = () => {
+    try {
+      return ctx.getService("job");
+    } catch {
+      return void 0;
+    }
+  };
+  engine.registerNodeExecutor({
+    type: "wait",
+    descriptor: (0, import_automation8.defineActionDescriptor)({
+      type: "wait",
+      version: "1.0.0",
+      name: "Wait",
+      description: "Pause the flow until a timer elapses or a named signal arrives.",
+      icon: "timer-reset",
+      category: "logic",
+      source: "builtin",
+      // Durable pause — the run suspends and resumes later (timer/signal).
+      supportsPause: true,
+      isAsync: true
+    }),
+    async execute(node, variables, _context) {
+      const loose = node.config ?? {};
+      const wec = node.waitEventConfig ?? {};
+      const eventType = String(wec.eventType ?? loose.eventType ?? "timer");
+      const runId = variables.get("$runId");
+      if (eventType === "timer") {
+        const durationMs = parseIsoDuration(wec.timerDuration ?? loose.timerDuration ?? loose.duration) ?? (typeof wec.timeoutMs === "number" ? wec.timeoutMs : void 0) ?? (typeof loose.timeoutMs === "number" ? loose.timeoutMs : void 0);
+        const job = getJobService();
+        if (job && runId != null && durationMs && durationMs > 0) {
+          const jobName = `flow-wait:${String(runId)}:${node.id}`;
+          const at = new Date(Date.now() + durationMs).toISOString();
+          try {
+            await job.schedule(jobName, { type: "once", at }, async () => {
+              try {
+                await engine.resume(String(runId));
+              } finally {
+                try {
+                  await job.cancel?.(jobName);
+                } catch {
+                }
+              }
+            });
+            return { success: true, suspend: true, correlation: jobName };
+          } catch (err) {
+            ctx.logger.warn(
+              `[wait] node '${node.id}': failed to schedule timer resume (${err?.message ?? err}); suspending without auto-resume (resume it via resume(runId))`
+            );
+          }
+        } else if (!job) {
+          ctx.logger.warn(
+            `[wait] node '${node.id}': no job service registered \u2014 suspending without an auto-resume timer (resume it via resume(runId), or install the job service for durable timers)`
+          );
+        }
+        return { success: true, suspend: true, correlation: `timer:${node.id}` };
+      }
+      const signal = String(wec.signalName ?? loose.signalName ?? loose.signal ?? `wait:${node.id}`);
+      return { success: true, suspend: true, correlation: signal };
+    }
+  });
+  ctx.logger.info("[Wait Node] 1 built-in node executor registered");
+}
+function parseIsoDuration(input) {
+  if (typeof input === "number" && Number.isFinite(input)) return input > 0 ? input : void 0;
+  if (typeof input !== "string") return void 0;
+  const s = input.trim();
+  if (!s) return void 0;
+  if (/^\d+(?:\.\d+)?$/.test(s)) {
+    const n = Number(s);
+    return n > 0 ? n : void 0;
+  }
+  const m = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(s);
+  if (!m) return void 0;
+  const [, w, d, h, min, sec] = m;
+  if (!w && !d && !h && !min && !sec) return void 0;
+  const totalSec = Number(w ?? 0) * 7 * 86400 + Number(d ?? 0) * 86400 + Number(h ?? 0) * 3600 + Number(min ?? 0) * 60 + Number(sec ?? 0);
+  const ms = totalSec * 1e3;
+  return ms > 0 ? ms : void 0;
+}
+
+// src/builtin/subflow-node.ts
+var import_automation9 = require("@objectstack/spec/automation");
+var MAX_SUBFLOW_DEPTH = 16;
+function registerSubflowNode(engine, ctx) {
+  engine.registerNodeExecutor({
+    type: "subflow",
+    descriptor: (0, import_automation9.defineActionDescriptor)({
+      type: "subflow",
+      version: "1.0.0",
+      name: "Subflow",
+      description: "Invoke another flow as a reusable step and capture its output.",
+      icon: "workflow",
+      category: "logic",
+      source: "builtin"
+    }),
+    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: `subflow '${node.id}': config.flowName is required` };
+      }
+      const depth = Number(context?.$subflowDepth ?? 0);
+      if (depth >= MAX_SUBFLOW_DEPTH) {
+        return {
+          success: false,
+          error: `subflow '${flowName}': max nesting depth (${MAX_SUBFLOW_DEPTH}) exceeded \u2014 recursive subflow?`
+        };
+      }
+      const rawInput = cfg.input && typeof cfg.input === "object" ? cfg.input : {};
+      const params = interpolate(rawInput, variables, context ?? {});
+      const childContext = {
+        ...context ?? {},
+        $subflowDepth: depth + 1,
+        params
+      };
+      const child = await engine.execute(flowName, childContext);
+      if (child.status === "paused") {
+        return {
+          success: false,
+          error: `subflow '${flowName}' suspended at a pausing node \u2014 a nested approval/screen/wait pause from a subflow is not yet supported`
+        };
+      }
+      if (!child.success) {
+        return { success: false, error: `subflow '${flowName}' failed: ${child.error ?? "unknown error"}` };
+      }
+      const outVar = typeof cfg.outputVariable === "string" && cfg.outputVariable ? cfg.outputVariable : void 0;
+      if (outVar) variables.set(outVar, child.output ?? null);
+      return { success: true, output: { output: child.output ?? null } };
+    }
+  });
+  ctx.logger.info("[Subflow Node] 1 built-in node executor registered");
+}
+
 // src/builtin/index.ts
 function installBuiltinNodes(engine, ctx) {
   registerLogicNodes(engine, ctx);
@@ -1676,6 +1812,8 @@ function installBuiltinNodes(engine, ctx) {
   registerHttpNodes(engine, ctx);
   registerConnectorNodes(engine, ctx);
   registerNotifyNode(engine, ctx);
+  registerWaitNode(engine, ctx);
+  registerSubflowNode(engine, ctx);
   const types = engine.getRegisteredNodeTypes();
   ctx.logger.info(
     `[Automation] ${types.length} built-in node executors installed: ${types.join(", ")}`