foliko 2.0.30 → 2.0.32

package/plugins/core/workflow/stages/choice.js

@@ -1,74 +1,74 @@
-/**
- * choice stage executor
- * Conditional branching (if/else/switch)
- */
-
-const { evaluateInSandbox } = require('../../../../src/utils/sandbox');
-
-class ChoiceStage {
-  constructor(config) {
-    this.name = config.name;
-    this.choice = config.choice || []; // Array of { when, do } or { case, do }
-    this.default = config.default; // Default stage name
-    this._log = require('../../../../src/common/logger').logger.child('ChoiceStage');
-  }
-
-  /**
-   * Execute the choice stage
-   * @param {FlowContext} context
-   * @returns {Promise<string|null>} next stage name
-   */
-  async execute(context) {
-    this._log.debug(`Evaluating choice: ${this.name}`);
-
-    // Try each when/case condition
-    for (const branch of this.choice) {
-      const condition = branch.when || branch.case;
-      if (!condition) continue;
-
-      try {
-        // Resolve condition with variable interpolation
-        const resolvedCondition = context.resolveValue(condition);
-
-        // Evaluate condition
-        let matched = false;
-        if (typeof resolvedCondition === 'boolean') {
-          matched = resolvedCondition;
-        } else if (typeof resolvedCondition === 'string') {
-          // Use sandbox to evaluate the condition expression
-          // Extract stage results to top level so they can be accessed directly
-          // e.g., "init.value > 100" can access init from stage results
-          // Also spread context.data so each-loop variables (e.g. "fruit") work
-          // in choice conditions.
-          const stageResults = Object.fromEntries(context._results);
-          const evalContext = {
-            ...stageResults,  // Spread stage results to top level
-            ...context.data,  // Spread data so loop variables are reachable
-            input: context.input,
-            data: context.data,
-            previousResult: context._sentData,
-          };
-          matched = evaluateInSandbox(resolvedCondition, evalContext, { timeout: 5000 });
-        }
-
-        if (matched) {
-          this._log.debug(`Choice matched: ${condition} -> ${branch.do}`);
-          return branch.do; // Return next stage name
-        }
-      } catch (err) {
-        this._log.warn(`Condition evaluation error for "${condition}": ${err.message}`);
-      }
-    }
-
-    // No condition matched, use default
-    if (this.default) {
-      this._log.debug(`No choice matched, using default: ${this.default}`);
-      return this.default;
-    }
-
-    this._log.debug(`No choice matched and no default for: ${this.name}`);
-    return null;
-  }
-}
-
-module.exports = { ChoiceStage };
+/**
+ * choice stage executor
+ * Conditional branching (if/else/switch)
+ */
+
+const { evaluateInSandbox } = require('../../../../src/utils/sandbox');
+
+class ChoiceStage {
+  constructor(config) {
+    this.name = config.name;
+    this.choice = config.choice || []; // Array of { when, do } or { case, do }
+    this.default = config.default; // Default stage name
+    this._log = require('../../../../src/common/logger').logger.child('ChoiceStage');
+  }
+
+  /**
+   * Execute the choice stage
+   * @param {FlowContext} context
+   * @returns {Promise<string|null>} next stage name
+   */
+  async execute(context) {
+    this._log.debug(`Evaluating choice: ${this.name}`);
+
+    // Try each when/case condition
+    for (const branch of this.choice) {
+      const condition = branch.when || branch.case;
+      if (!condition) continue;
+
+      try {
+        // Resolve condition with variable interpolation
+        const resolvedCondition = context.resolveValue(condition);
+
+        // Evaluate condition
+        let matched = false;
+        if (typeof resolvedCondition === 'boolean') {
+          matched = resolvedCondition;
+        } else if (typeof resolvedCondition === 'string') {
+          // Use sandbox to evaluate the condition expression
+          // Extract stage results to top level so they can be accessed directly
+          // e.g., "init.value > 100" can access init from stage results
+          // Also spread context.data so each-loop variables (e.g. "fruit") work
+          // in choice conditions.
+          const stageResults = Object.fromEntries(context._results);
+          const evalContext = {
+            ...stageResults,  // Spread stage results to top level
+            ...context.data,  // Spread data so loop variables are reachable
+            input: context.input,
+            data: context.data,
+            previousResult: context._sentData,
+          };
+          matched = evaluateInSandbox(resolvedCondition, evalContext, { timeout: 5000 });
+        }
+
+        if (matched) {
+          this._log.debug(`Choice matched: ${condition} -> ${branch.do}`);
+          return branch.do; // Return next stage name
+        }
+      } catch (err) {
+        this._log.warn(`Condition evaluation error for "${condition}": ${err.message}`);
+      }
+    }
+
+    // No condition matched, use default
+    if (this.default) {
+      this._log.debug(`No choice matched, using default: ${this.default}`);
+      return this.default;
+    }
+
+    this._log.debug(`No choice matched and no default for: ${this.name}`);
+    return null;
+  }
+}
+
+module.exports = { ChoiceStage };

package/plugins/core/workflow/stages/each.js

@@ -1,123 +1,123 @@
-/**
- * each stage executor
- * Loop over items
- */
-
-class EachStage {
-  constructor(config) {
-    this.name = config.name;
-    this.each = config.each; // Array to iterate over
-    this.as = config.as || 'item'; // Item variable name
-    this.index = config.index || 'index'; // Index variable name
-    this.stages = config.stages || []; // Child stages to execute for each item
-    this.maxIterations = config.maxIterations || 100;
-    this.until = config.until; // Early exit condition
-    this._log = require('../../../../src/common/logger').logger.child('EachStage');
-  }
-
-  /**
-   * Execute the each stage
-   * @param {FlowContext} context
-   * @returns {Promise<Array>} results for each iteration
-   */
-  async execute(context) {
-    this._log.debug(`Executing each loop: ${this.name}`);
-
-    // Resolve the array to iterate
-    let array;
-    if (typeof this.each === 'string') {
-      // Strip optional surrounding {{ }} so users can write either
-      //   "each": "items"          (bare identifier)
-      //   "each": "{{items}}"       (templated)
-      //   "each": "{{init.items}}"  (stage.field)
-      let path = this.each.trim();
-      const m = path.match(/^\{\{([^}]+)\}\}$/);
-      if (m) path = m[1].trim();
-
-      // Use the low-level _resolvePath so we get the actual array/object back
-      // (String.prototype.replace in resolveValue would coerce non-strings.)
-      let resolved = context._resolvePath(path);
-      if (resolved === undefined && path.startsWith('[')) {
-        // Support inline array literal: each: "['a','b']"
-        try { resolved = JSON.parse(path); } catch {}
-      }
-      if (Array.isArray(resolved)) {
-        array = resolved;
-      } else if (resolved && typeof resolved === 'object') {
-        // Convert object to entries (so {{k, v}} style iteration works)
-        array = Object.entries(resolved);
-      } else {
-        throw new Error(`each "${this.each}" resolved to non-iterable: ${typeof resolved}`);
-      }
-    } else if (Array.isArray(this.each)) {
-      array = this.each;
-    } else {
-      throw new Error(`each stage "${this.name}" requires an array to iterate`);
-    }
-
-    const results = [];
-    const maxIter = Math.min(this.maxIterations, array.length);
-
-    for (let i = 0; i < maxIter; i++) {
-      // Set loop variables
-      context.data[this.as] = array[i];
-      context.data[this.index] = i;
-      context.data.loopIndex = i; // Legacy alias
-
-      this._log.debug(`Each iteration ${i}: ${this.as}=`, array[i]);
-
-      // Execute child stages sequentially
-      let stageResults = [];
-      for (const stageConfig of this.stages) {
-        const stageExecutor = context._stageExecutor;
-        if (stageExecutor) {
-          const result = await stageExecutor.executeStage(stageConfig, context);
-          stageResults.push(result);
-
-          // Check for early exit
-          if (context._destroyed) {
-            this._log.debug('Flow destroyed, stopping each loop');
-            break;
-          }
-        }
-      }
-      results.push(stageResults);
-
-      // Check until condition
-      if (this.until) {
-        try {
-          const { evaluateInSandbox } = require('../../../../../src/utils/sandbox');
-          const evalContext = {
-            input: context.input,
-            data: context.data,
-            variables: Object.fromEntries(context._results),
-            previousResult: context._sentData,
-            item: array[i],
-            index: i,
-          };
-          const shouldStop = evaluateInSandbox(this.until, evalContext, { timeout: 5000 });
-          if (shouldStop) {
-            this._log.debug(`Each loop terminated at iteration ${i} by until condition`);
-            break;
-          }
-        } catch (err) {
-          this._log.warn(`until condition error: ${err.message}`);
-        }
-      }
-    }
-
-    // Cleanup loop variables
-    delete context.data[this.as];
-    delete context.data[this.index];
-    delete context.data.loopIndex;
-
-    // Store results by name if this stage has a name
-    if (this.name) {
-      context.setResult(this.name, results);
-    }
-
-    return results;
-  }
-}
-
-module.exports = { EachStage };
+/**
+ * each stage executor
+ * Loop over items
+ */
+
+class EachStage {
+  constructor(config) {
+    this.name = config.name;
+    this.each = config.each; // Array to iterate over
+    this.as = config.as || 'item'; // Item variable name
+    this.index = config.index || 'index'; // Index variable name
+    this.stages = config.stages || []; // Child stages to execute for each item
+    this.maxIterations = config.maxIterations || 100;
+    this.until = config.until; // Early exit condition
+    this._log = require('../../../../src/common/logger').logger.child('EachStage');
+  }
+
+  /**
+   * Execute the each stage
+   * @param {FlowContext} context
+   * @returns {Promise<Array>} results for each iteration
+   */
+  async execute(context) {
+    this._log.debug(`Executing each loop: ${this.name}`);
+
+    // Resolve the array to iterate
+    let array;
+    if (typeof this.each === 'string') {
+      // Strip optional surrounding {{ }} so users can write either
+      //   "each": "items"          (bare identifier)
+      //   "each": "{{items}}"       (templated)
+      //   "each": "{{init.items}}"  (stage.field)
+      let path = this.each.trim();
+      const m = path.match(/^\{\{([^}]+)\}\}$/);
+      if (m) path = m[1].trim();
+
+      // Use the low-level _resolvePath so we get the actual array/object back
+      // (String.prototype.replace in resolveValue would coerce non-strings.)
+      let resolved = context._resolvePath(path);
+      if (resolved === undefined && path.startsWith('[')) {
+        // Support inline array literal: each: "['a','b']"
+        try { resolved = JSON.parse(path); } catch {}
+      }
+      if (Array.isArray(resolved)) {
+        array = resolved;
+      } else if (resolved && typeof resolved === 'object') {
+        // Convert object to entries (so {{k, v}} style iteration works)
+        array = Object.entries(resolved);
+      } else {
+        throw new Error(`each "${this.each}" resolved to non-iterable: ${typeof resolved}`);
+      }
+    } else if (Array.isArray(this.each)) {
+      array = this.each;
+    } else {
+      throw new Error(`each stage "${this.name}" requires an array to iterate`);
+    }
+
+    const results = [];
+    const maxIter = Math.min(this.maxIterations, array.length);
+
+    for (let i = 0; i < maxIter; i++) {
+      // Set loop variables
+      context.data[this.as] = array[i];
+      context.data[this.index] = i;
+      context.data.loopIndex = i; // Legacy alias
+
+      this._log.debug(`Each iteration ${i}: ${this.as}=`, array[i]);
+
+      // Execute child stages sequentially
+      let stageResults = [];
+      for (const stageConfig of this.stages) {
+        const stageExecutor = context._stageExecutor;
+        if (stageExecutor) {
+          const result = await stageExecutor.executeStage(stageConfig, context);
+          stageResults.push(result);
+
+          // Check for early exit
+          if (context._destroyed) {
+            this._log.debug('Flow destroyed, stopping each loop');
+            break;
+          }
+        }
+      }
+      results.push(stageResults);
+
+      // Check until condition
+      if (this.until) {
+        try {
+          const { evaluateInSandbox } = require('../../../../../src/utils/sandbox');
+          const evalContext = {
+            input: context.input,
+            data: context.data,
+            variables: Object.fromEntries(context._results),
+            previousResult: context._sentData,
+            item: array[i],
+            index: i,
+          };
+          const shouldStop = evaluateInSandbox(this.until, evalContext, { timeout: 5000 });
+          if (shouldStop) {
+            this._log.debug(`Each loop terminated at iteration ${i} by until condition`);
+            break;
+          }
+        } catch (err) {
+          this._log.warn(`until condition error: ${err.message}`);
+        }
+      }
+    }
+
+    // Cleanup loop variables
+    delete context.data[this.as];
+    delete context.data[this.index];
+    delete context.data.loopIndex;
+
+    // Store results by name if this stage has a name
+    if (this.name) {
+      context.setResult(this.name, results);
+    }
+
+    return results;
+  }
+}
+
+module.exports = { EachStage };

package/plugins/core/workflow/stages/parallel.js

@@ -1,69 +1,69 @@
-/**
- * parallel stage executor
- * Run stages concurrently
- */
-
-class ParallelStage {
-  constructor(config) {
-    this.name = config.name;
-    this.parallel = config.parallel || []; // Array of stages to run in parallel
-    this._log = require('../../../../src/common/logger').logger.child('ParallelStage');
-  }
-
-  /**
-   * Execute the parallel stage
-   * @param {FlowContext} context
-   * @returns {Promise<Array>} results from all parallel stages
-   */
-  async execute(context) {
-    this._log.debug(`Executing parallel: ${this.name}`);
-
-    if (!this.parallel || this.parallel.length === 0) {
-      return [];
-    }
-
-    const stageExecutor = context._stageExecutor;
-    if (!stageExecutor) {
-      throw new Error('Stage executor not set in context');
-    }
-
-    // Execute all stages concurrently
-    const promises = this.parallel.map(async (stageConfig) => {
-      try {
-        return await stageExecutor.executeStage(stageConfig, context);
-      } catch (err) {
-        this._log.warn(`Parallel stage error: ${err.message}`);
-        return { error: err.message };
-      }
-    });
-
-    const results = await Promise.all(promises);
-
-    // Build result object keyed by stage name (not plain array)
-    const resultByName = {};
-    for (let i = 0; i < this.parallel.length; i++) {
-      const stageConfig = this.parallel[i];
-      const name = stageConfig.name || String(i);
-      resultByName[name] = results[i];
-    }
-
-    // Store named results in context
-    // If the parallel block itself has a name, store the keyed object
-    if (this.name) {
-      context.setResult(this.name, resultByName);
-    }
-
-    // Also store individual named results for access via {{stageName}}
-    for (let i = 0; i < this.parallel.length; i++) {
-      const stageConfig = this.parallel[i];
-      if (stageConfig.name) {
-        context.setResult(stageConfig.name, results[i]);
-      }
-    }
-
-    this._log.debug(`Parallel completed: ${results.length} stages`);
-    return resultByName;
-  }
-}
-
-module.exports = { ParallelStage };
+/**
+ * parallel stage executor
+ * Run stages concurrently
+ */
+
+class ParallelStage {
+  constructor(config) {
+    this.name = config.name;
+    this.parallel = config.parallel || []; // Array of stages to run in parallel
+    this._log = require('../../../../src/common/logger').logger.child('ParallelStage');
+  }
+
+  /**
+   * Execute the parallel stage
+   * @param {FlowContext} context
+   * @returns {Promise<Array>} results from all parallel stages
+   */
+  async execute(context) {
+    this._log.debug(`Executing parallel: ${this.name}`);
+
+    if (!this.parallel || this.parallel.length === 0) {
+      return [];
+    }
+
+    const stageExecutor = context._stageExecutor;
+    if (!stageExecutor) {
+      throw new Error('Stage executor not set in context');
+    }
+
+    // Execute all stages concurrently
+    const promises = this.parallel.map(async (stageConfig) => {
+      try {
+        return await stageExecutor.executeStage(stageConfig, context);
+      } catch (err) {
+        this._log.warn(`Parallel stage error: ${err.message}`);
+        return { error: err.message };
+      }
+    });
+
+    const results = await Promise.all(promises);
+
+    // Build result object keyed by stage name (not plain array)
+    const resultByName = {};
+    for (let i = 0; i < this.parallel.length; i++) {
+      const stageConfig = this.parallel[i];
+      const name = stageConfig.name || String(i);
+      resultByName[name] = results[i];
+    }
+
+    // Store named results in context
+    // If the parallel block itself has a name, store the keyed object
+    if (this.name) {
+      context.setResult(this.name, resultByName);
+    }
+
+    // Also store individual named results for access via {{stageName}}
+    for (let i = 0; i < this.parallel.length; i++) {
+      const stageConfig = this.parallel[i];
+      if (stageConfig.name) {
+        context.setResult(stageConfig.name, results[i]);
+      }
+    }
+
+    this._log.debug(`Parallel completed: ${results.length} stages`);
+    return resultByName;
+  }
+}
+
+module.exports = { ParallelStage };