@objectstack/service-automation 3.0.7 → 3.0.9

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/service-automation@3.0.7 build /home/runner/work/spec/spec/packages/services/service-automation
+> @objectstack/service-automation@3.0.9 build /home/runner/work/spec/spec/packages/services/service-automation
 > tsup --config ../../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs     12.25 KB
-CJS dist/index.cjs.map 28.34 KB
-CJS ⚡️ Build success in 59ms
-ESM dist/index.js     11.02 KB
-ESM dist/index.js.map 27.68 KB
-ESM ⚡️ Build success in 60ms
+CJS dist/index.cjs     26.75 KB
+CJS dist/index.cjs.map 57.83 KB
+CJS ⚡️ Build success in 107ms
+ESM dist/index.js     25.53 KB
+ESM dist/index.js.map 57.16 KB
+ESM ⚡️ Build success in 114ms
 DTS Build start
-DTS ⚡️ Build success in 7223ms
-DTS dist/index.d.ts  4.96 KB
-DTS dist/index.d.cts 4.96 KB
+DTS ⚡️ Build success in 14047ms
+DTS dist/index.d.ts  8.00 KB
+DTS dist/index.d.cts 8.00 KB

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @objectstack/service-automation
+
+## 3.0.9
+
+### Patch Changes
+
+- Updated dependencies [15e0df6]
+  - @objectstack/spec@3.0.9
+  - @objectstack/core@3.0.9
+
+## 3.0.8
+
+### Patch Changes
+
+- Updated dependencies [5a968a2]
+  - @objectstack/spec@3.0.8
+  - @objectstack/core@3.0.8

package/dist/index.cjs

@@ -33,8 +33,13 @@ var import_automation = require("@objectstack/spec/automation");
 var AutomationEngine = class {
   constructor(logger) {
     this.flows = /* @__PURE__ */ new Map();
+    this.flowEnabled = /* @__PURE__ */ new Map();
+    this.flowVersionHistory = /* @__PURE__ */ new Map();
     this.nodeExecutors = /* @__PURE__ */ new Map();
     this.triggers = /* @__PURE__ */ new Map();
+    this.executionLogs = [];
+    this.maxLogSize = 1e3;
+    this.runCounter = 0;
     this.logger = logger;
   }
   // ── Plugin Extension API ──────────────────────────────
@@ -72,22 +77,73 @@ var AutomationEngine = class {
   // ── IAutomationService Contract Implementation ────────
   registerFlow(name, definition) {
     const parsed = import_automation.FlowSchema.parse(definition);
+    this.detectCycles(parsed);
+    const history = this.flowVersionHistory.get(name) ?? [];
+    history.push({
+      version: parsed.version,
+      definition: parsed,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.flowVersionHistory.set(name, history);
     this.flows.set(name, parsed);
-    this.logger.info(`Flow registered: ${name}`);
+    if (!this.flowEnabled.has(name)) {
+      this.flowEnabled.set(name, true);
+    }
+    this.logger.info(`Flow registered: ${name} (version ${parsed.version})`);
   }
   unregisterFlow(name) {
     this.flows.delete(name);
+    this.flowEnabled.delete(name);
+    this.flowVersionHistory.delete(name);
     this.logger.info(`Flow unregistered: ${name}`);
   }
   async listFlows() {
     return [...this.flows.keys()];
   }
+  async getFlow(name) {
+    return this.flows.get(name) ?? null;
+  }
+  async toggleFlow(name, enabled) {
+    if (!this.flows.has(name)) {
+      throw new Error(`Flow '${name}' not found`);
+    }
+    this.flowEnabled.set(name, enabled);
+    this.logger.info(`Flow '${name}' ${enabled ? "enabled" : "disabled"}`);
+  }
+  /** Get flow version history */
+  getFlowVersionHistory(name) {
+    return this.flowVersionHistory.get(name) ?? [];
+  }
+  /** Rollback flow to a specific version */
+  rollbackFlow(name, version) {
+    const history = this.flowVersionHistory.get(name);
+    if (!history) {
+      throw new Error(`Flow '${name}' has no version history`);
+    }
+    const entry = history.find((h) => h.version === version);
+    if (!entry) {
+      throw new Error(`Version ${version} not found for flow '${name}'`);
+    }
+    this.flows.set(name, entry.definition);
+    this.logger.info(`Flow '${name}' rolled back to version ${version}`);
+  }
+  async listRuns(flowName, options) {
+    const limit = options?.limit ?? 20;
+    const logs = this.executionLogs.filter((l) => l.flowName === flowName);
+    return logs.slice(-limit).reverse();
+  }
+  async getRun(runId) {
+    return this.executionLogs.find((l) => l.id === runId) ?? null;
+  }
   async execute(flowName, context) {
     const startTime = Date.now();
     const flow = this.flows.get(flowName);
     if (!flow) {
       return { success: false, error: `Flow '${flowName}' not found` };
     }
+    if (this.flowEnabled.get(flowName) === false) {
+      return { success: false, error: `Flow '${flowName}' is disabled` };
+    }
     const variables = /* @__PURE__ */ new Map();
     if (flow.variables) {
       for (const v of flow.variables) {
@@ -99,12 +155,16 @@ var AutomationEngine = class {
     if (context?.record) {
       variables.set("$record", context.record);
     }
+    const runId = `run_${++this.runCounter}`;
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const steps = [];
     try {
       const startNode = flow.nodes.find((n) => n.type === "start");
       if (!startNode) {
         return { success: false, error: "Flow has no start node" };
       }
-      await this.executeNode(startNode, flow, variables, context ?? {});
+      this.validateNodeInputSchemas(flow, variables);
+      await this.executeNode(startNode, flow, variables, context ?? {}, steps);
       const output = {};
       if (flow.variables) {
         for (const v of flow.variables) {
@@ -113,73 +173,461 @@ var AutomationEngine = class {
           }
         }
       }
+      const durationMs = Date.now() - startTime;
+      this.recordLog({
+        id: runId,
+        flowName,
+        flowVersion: flow.version,
+        status: "completed",
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context?.event ?? "manual",
+          userId: context?.userId,
+          object: context?.object
+        },
+        steps,
+        output
+      });
       return {
         success: true,
         output,
-        durationMs: Date.now() - startTime
+        durationMs
       };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
+      const durationMs = Date.now() - startTime;
+      this.recordLog({
+        id: runId,
+        flowName,
+        flowVersion: flow.version,
+        status: "failed",
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context?.event ?? "manual",
+          userId: context?.userId,
+          object: context?.object
+        },
+        steps,
+        error: errorMessage
+      });
       if (flow.errorHandling?.strategy === "retry") {
         return this.retryExecution(flowName, context, startTime, flow.errorHandling);
       }
       return {
         success: false,
         error: errorMessage,
-        durationMs: Date.now() - startTime
+        durationMs
       };
     }
   }
   // ── DAG Traversal Core ──────────────────────────────────
-  async executeNode(node, flow, variables, context) {
+  recordLog(entry) {
+    this.executionLogs.push(entry);
+    if (this.executionLogs.length > this.maxLogSize) {
+      this.executionLogs.splice(0, this.executionLogs.length - this.maxLogSize);
+    }
+  }
+  /**
+   * Detect cycles in the flow graph (DAG validation).
+   * Uses DFS with coloring (white/gray/black) to detect back edges.
+   * Throws an error with cycle details if a cycle is found.
+   */
+  detectCycles(flow) {
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    const adj = /* @__PURE__ */ new Map();
+    for (const node of flow.nodes) {
+      color.set(node.id, WHITE);
+      adj.set(node.id, []);
+    }
+    for (const edge of flow.edges) {
+      const targets = adj.get(edge.source);
+      if (targets) targets.push(edge.target);
+    }
+    const dfs = (nodeId) => {
+      color.set(nodeId, GRAY);
+      for (const neighbor of adj.get(nodeId) ?? []) {
+        if (color.get(neighbor) === GRAY) {
+          const cycle = [neighbor, nodeId];
+          let cur = nodeId;
+          while (cur !== neighbor) {
+            cur = parent.get(cur);
+            if (cur) cycle.push(cur);
+            else break;
+          }
+          return cycle.reverse();
+        }
+        if (color.get(neighbor) === WHITE) {
+          parent.set(neighbor, nodeId);
+          const result = dfs(neighbor);
+          if (result) return result;
+        }
+      }
+      color.set(nodeId, BLACK);
+      return null;
+    };
+    for (const node of flow.nodes) {
+      if (color.get(node.id) === WHITE) {
+        const cycle = dfs(node.id);
+        if (cycle) {
+          throw new Error(`Flow contains a cycle: ${cycle.join(" \u2192 ")}. Only DAG flows are allowed.`);
+        }
+      }
+    }
+  }
+  /**
+   * Get the runtime type name of a value for schema validation.
+   */
+  getValueType(value) {
+    if (Array.isArray(value)) return "array";
+    if (typeof value === "object" && value !== null) return "object";
+    return typeof value;
+  }
+  /**
+   * Validate node input schemas before execution.
+   * Checks that node config matches declared inputSchema if present.
+   */
+  validateNodeInputSchemas(flow, _variables) {
+    for (const node of flow.nodes) {
+      if (node.inputSchema && node.config) {
+        for (const [paramName, paramDef] of Object.entries(node.inputSchema)) {
+          if (paramDef.required && !(paramName in node.config)) {
+            throw new Error(
+              `Node '${node.id}' missing required input parameter '${paramName}'`
+            );
+          }
+          const value = node.config[paramName];
+          if (value !== void 0) {
+            const actualType = this.getValueType(value);
+            if (actualType !== paramDef.type) {
+              throw new Error(
+                `Node '${node.id}' parameter '${paramName}' expected type '${paramDef.type}' but got '${actualType}'`
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Execute a node with timeout support, fault edge handling, and step logging.
+   */
+  async executeNode(node, flow, variables, context, steps) {
     if (node.type === "end") return;
+    const stepStart = Date.now();
+    const stepStartedAt = (/* @__PURE__ */ new Date()).toISOString();
     const executor = this.nodeExecutors.get(node.type);
     if (!executor) {
       if (node.type !== "start") {
+        steps.push({
+          nodeId: node.id,
+          nodeType: node.type,
+          status: "failure",
+          startedAt: stepStartedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - stepStart,
+          error: { code: "NO_EXECUTOR", message: `No executor registered for node type '${node.type}'` }
+        });
         throw new Error(`No executor registered for node type '${node.type}'`);
       }
+      steps.push({
+        nodeId: node.id,
+        nodeType: node.type,
+        status: "success",
+        startedAt: stepStartedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - stepStart
+      });
     } else {
-      const result = await executor.execute(node, variables, context);
+      let result;
+      try {
+        if (node.timeoutMs && node.timeoutMs > 0) {
+          result = await this.executeWithTimeout(
+            executor.execute(node, variables, context),
+            node.timeoutMs,
+            node.id
+          );
+        } else {
+          result = await executor.execute(node, variables, context);
+        }
+      } catch (execErr) {
+        const errMsg = execErr instanceof Error ? execErr.message : String(execErr);
+        steps.push({
+          nodeId: node.id,
+          nodeType: node.type,
+          status: "failure",
+          startedAt: stepStartedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - stepStart,
+          error: { code: "EXECUTION_ERROR", message: errMsg }
+        });
+        const faultEdge = flow.edges.find((e) => e.source === node.id && e.type === "fault");
+        if (faultEdge) {
+          variables.set("$error", { nodeId: node.id, message: errMsg });
+          const faultTarget = flow.nodes.find((n) => n.id === faultEdge.target);
+          if (faultTarget) {
+            await this.executeNode(faultTarget, flow, variables, context, steps);
+            return;
+          }
+        }
+        throw execErr;
+      }
       if (!result.success) {
-        throw new Error(`Node '${node.id}' failed: ${result.error}`);
+        const errMsg = result.error ?? "Unknown error";
+        steps.push({
+          nodeId: node.id,
+          nodeType: node.type,
+          status: "failure",
+          startedAt: stepStartedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - stepStart,
+          error: { code: "NODE_FAILURE", message: errMsg }
+        });
+        variables.set("$error", { nodeId: node.id, message: errMsg, output: result.output });
+        const faultEdge = flow.edges.find((e) => e.source === node.id && e.type === "fault");
+        if (faultEdge) {
+          const faultTarget = flow.nodes.find((n) => n.id === faultEdge.target);
+          if (faultTarget) {
+            await this.executeNode(faultTarget, flow, variables, context, steps);
+            return;
+          }
+        }
+        throw new Error(`Node '${node.id}' failed: ${errMsg}`);
       }
+      steps.push({
+        nodeId: node.id,
+        nodeType: node.type,
+        status: "success",
+        startedAt: stepStartedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - stepStart
+      });
       if (result.output) {
         for (const [key, value] of Object.entries(result.output)) {
           variables.set(`${node.id}.${key}`, value);
         }
       }
     }
-    const outEdges = flow.edges.filter((e) => e.source === node.id);
+    const outEdges = flow.edges.filter(
+      (e) => e.source === node.id && e.type !== "fault"
+    );
+    const conditionalEdges = [];
+    const unconditionalEdges = [];
     for (const edge of outEdges) {
-      if (edge.condition && !this.evaluateCondition(edge.condition, variables)) {
-        continue;
+      if (edge.condition) {
+        conditionalEdges.push(edge);
+      } else {
+        unconditionalEdges.push(edge);
       }
-      const nextNode = flow.nodes.find((n) => n.id === edge.target);
-      if (nextNode) {
-        await this.executeNode(nextNode, flow, variables, context);
+    }
+    for (const edge of conditionalEdges) {
+      if (this.evaluateCondition(edge.condition, variables)) {
+        const nextNode = flow.nodes.find((n) => n.id === edge.target);
+        if (nextNode) {
+          await this.executeNode(nextNode, flow, variables, context, steps);
+        }
       }
     }
+    if (unconditionalEdges.length > 0) {
+      const parallelTasks = unconditionalEdges.map((edge) => flow.nodes.find((n) => n.id === edge.target)).filter((n) => n != null).map((nextNode) => this.executeNode(nextNode, flow, variables, context, steps));
+      await Promise.all(parallelTasks);
+    }
+  }
+  /**
+   * Execute a promise with timeout using Promise.race.
+   */
+  executeWithTimeout(promise, timeoutMs, nodeId) {
+    return Promise.race([
+      promise,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Node '${nodeId}' timed out after ${timeoutMs}ms`)), timeoutMs)
+      )
+    ]);
   }
+  /**
+   * Safe expression evaluator.
+   * Uses simple operator-based parsing without `new Function`.
+   * Supports: comparisons (>, <, >=, <=, ==, !=, ===, !==),
+   * boolean literals (true, false), and basic arithmetic.
+   */
   evaluateCondition(expression, variables) {
     let resolved = expression;
     for (const [key, value] of variables) {
       resolved = resolved.split(`{${key}}`).join(String(value));
     }
+    resolved = resolved.trim();
     try {
-      return new Function(`return (${resolved})`)();
+      if (resolved === "true") return true;
+      if (resolved === "false") return false;
+      const operators = ["===", "!==", ">=", "<=", "!=", "==", ">", "<"];
+      for (const op of operators) {
+        const idx = resolved.indexOf(op);
+        if (idx !== -1) {
+          const left = resolved.slice(0, idx).trim();
+          const right = resolved.slice(idx + op.length).trim();
+          return this.compareValues(left, op, right);
+        }
+      }
+      const numVal = Number(resolved);
+      if (!isNaN(numVal)) return numVal !== 0;
+      return false;
     } catch {
       return false;
     }
   }
+  /**
+   * Compare two string-represented values with an operator.
+   */
+  compareValues(left, op, right) {
+    const lNum = Number(left);
+    const rNum = Number(right);
+    const bothNumeric = !isNaN(lNum) && !isNaN(rNum) && left !== "" && right !== "";
+    if (bothNumeric) {
+      switch (op) {
+        case ">":
+          return lNum > rNum;
+        case "<":
+          return lNum < rNum;
+        case ">=":
+          return lNum >= rNum;
+        case "<=":
+          return lNum <= rNum;
+        case "==":
+        case "===":
+          return lNum === rNum;
+        case "!=":
+        case "!==":
+          return lNum !== rNum;
+        default:
+          return false;
+      }
+    }
+    switch (op) {
+      case "==":
+      case "===":
+        return left === right;
+      case "!=":
+      case "!==":
+        return left !== right;
+      case ">":
+        return left > right;
+      case "<":
+        return left < right;
+      case ">=":
+        return left >= right;
+      case "<=":
+        return left <= right;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Retry execution with exponential backoff, jitter, and recursive protection.
+   * Uses an iterative loop with an internal retry flag to prevent recursive call stacking.
+   */
   async retryExecution(flowName, context, startTime, errorHandling) {
     const maxRetries = errorHandling.maxRetries ?? 3;
-    const delay = errorHandling.retryDelayMs ?? 1e3;
+    const baseDelay = errorHandling.retryDelayMs ?? 1e3;
+    const multiplier = errorHandling.backoffMultiplier ?? 1;
+    const maxDelay = errorHandling.maxRetryDelayMs ?? 3e4;
+    const useJitter = errorHandling.jitter ?? false;
+    let lastError = "Max retries exceeded";
     for (let i = 0; i < maxRetries; i++) {
+      let delay = Math.min(baseDelay * Math.pow(multiplier, i), maxDelay);
+      if (useJitter) {
+        delay = delay * (0.5 + Math.random() * 0.5);
+      }
       await new Promise((r) => setTimeout(r, delay));
-      const result = await this.execute(flowName, context);
+      const result = await this.executeWithoutRetry(flowName, context);
       if (result.success) return result;
+      lastError = result.error ?? "Unknown error";
+    }
+    return { success: false, error: lastError, durationMs: Date.now() - startTime };
+  }
+  /**
+   * Execute a flow without triggering retry logic (used by retryExecution to prevent recursion).
+   */
+  async executeWithoutRetry(flowName, context) {
+    const startTime = Date.now();
+    const flow = this.flows.get(flowName);
+    if (!flow) {
+      return { success: false, error: `Flow '${flowName}' not found` };
+    }
+    if (this.flowEnabled.get(flowName) === false) {
+      return { success: false, error: `Flow '${flowName}' is disabled` };
+    }
+    const variables = /* @__PURE__ */ new Map();
+    if (flow.variables) {
+      for (const v of flow.variables) {
+        if (v.isInput && context?.params?.[v.name] !== void 0) {
+          variables.set(v.name, context.params[v.name]);
+        }
+      }
+    }
+    if (context?.record) {
+      variables.set("$record", context.record);
+    }
+    const runId = `run_${++this.runCounter}`;
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const steps = [];
+    try {
+      const startNode = flow.nodes.find((n) => n.type === "start");
+      if (!startNode) {
+        return { success: false, error: "Flow has no start node" };
+      }
+      await this.executeNode(startNode, flow, variables, context ?? {}, steps);
+      const output = {};
+      if (flow.variables) {
+        for (const v of flow.variables) {
+          if (v.isOutput) {
+            output[v.name] = variables.get(v.name);
+          }
+        }
+      }
+      const durationMs = Date.now() - startTime;
+      this.recordLog({
+        id: runId,
+        flowName,
+        flowVersion: flow.version,
+        status: "completed",
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context?.event ?? "manual",
+          userId: context?.userId,
+          object: context?.object
+        },
+        steps,
+        output
+      });
+      return { success: true, output, durationMs };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const durationMs = Date.now() - startTime;
+      this.recordLog({
+        id: runId,
+        flowName,
+        flowVersion: flow.version,
+        status: "failed",
+        startedAt,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        trigger: {
+          type: context?.event ?? "manual",
+          userId: context?.userId,
+          object: context?.object
+        },
+        steps,
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage, durationMs };
     }
-    return { success: false, error: "Max retries exceeded", durationMs: Date.now() - startTime };
   }
 };
 
@@ -277,15 +725,8 @@ var LogicNodesPlugin = class {
         const config = node.config;
         const conditions = config?.conditions ?? [];
         for (const cond of conditions) {
-          let expr = cond.expression;
-          for (const [k, v] of variables) {
-            expr = expr.split(`{${k}}`).join(String(v));
-          }
-          try {
-            if (new Function(`return (${expr})`)()) {
-              return { success: true, branchLabel: cond.label };
-            }
-          } catch {
+          if (engine.evaluateCondition(cond.expression, variables)) {
+            return { success: true, branchLabel: cond.label };
           }
         }
         return { success: true, branchLabel: "default" };