@nocobase/plugin-workflow 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/server/Plugin.js

@@ -36,6 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Plugin_exports = {};
 __export(Plugin_exports, {
+  WORKER_JOB_WORKFLOW_PROCESS: () => WORKER_JOB_WORKFLOW_PROCESS,
   default: () => PluginWorkflowServer
 });
 module.exports = __toCommonJS(Plugin_exports);
@@ -58,7 +59,9 @@ var import_CreateInstruction = __toESM(require("./instructions/CreateInstruction
 var import_DestroyInstruction = __toESM(require("./instructions/DestroyInstruction"));
 var import_QueryInstruction = __toESM(require("./instructions/QueryInstruction"));
 var import_UpdateInstruction = __toESM(require("./instructions/UpdateInstruction"));
+var import_MultiConditionsInstruction = __toESM(require("./instructions/MultiConditionsInstruction"));
 var import_WorkflowRepository = __toESM(require("./repositories/WorkflowRepository"));
+const WORKER_JOB_WORKFLOW_PROCESS = "workflow:process";
 class PluginWorkflowServer extends import_server.Plugin {
   instructions = new import_utils.Registry();
   triggers = new import_utils.Registry();
@@ -66,6 +69,9 @@ class PluginWorkflowServer extends import_server.Plugin {
   enabledCache = /* @__PURE__ */ new Map();
   snowflake;
   dispatcher = new import_Dispatcher.default(this);
+  get channelPendingExecution() {
+    return `${this.name}.pendingExecution`;
+  }
   loggerCache;
   meter = null;
   checker = null;
@@ -138,7 +144,6 @@ class PluginWorkflowServer extends import_server.Plugin {
   //   * add all hooks for enabled workflows
   //   * add hooks for create/update[enabled]/delete workflow to add/remove specific hooks
   onAfterStart = async () => {
-    this.dispatcher.setReady(true);
     const collection = this.db.getCollection("workflows");
     const workflows = await collection.repository.find({
       appends: ["versionStats"]
@@ -165,19 +170,20 @@ class PluginWorkflowServer extends import_server.Plugin {
       this.app.logger.info("workflow:dispatch");
       this.dispatcher.dispatch();
     });
+    this.dispatcher.setReady(true);
     this.getLogger("dispatcher").info("(starting) check for queueing executions");
     this.dispatcher.dispatch();
-    this.dispatcher.setReady(true);
   };
   onBeforeStop = async () => {
+    if (this.checker) {
+      clearInterval(this.checker);
+    }
+    await this.dispatcher.beforeStop();
     this.app.logger.info(`stopping workflow plugin before app (${this.app.name}) shutdown...`);
     for (const workflow of this.enabledCache.values()) {
       this.toggle(workflow, false, { silent: true });
     }
-    await this.dispatcher.beforeStop();
-    if (this.checker) {
-      clearInterval(this.checker);
-    }
+    this.app.eventQueue.unsubscribe(this.channelPendingExecution);
     this.loggerCache.clear();
   };
   async handleSyncMessage(message) {
@@ -202,13 +208,16 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     }
   }
+  serving() {
+    return this.app.serving(WORKER_JOB_WORKFLOW_PROCESS);
+  }
   /**
    * @experimental
    */
   getLogger(workflowId = "dispatcher") {
     const now = /* @__PURE__ */ new Date();
     const date = `${now.getFullYear()}-${`0${now.getMonth() + 1}`.slice(-2)}-${`0${now.getDate()}`.slice(-2)}`;
-    const key = `${date}-${workflowId}}`;
+    const key = `${date}-${workflowId}`;
     if (this.loggerCache.has(key)) {
       return this.loggerCache.get(key);
     }
@@ -259,6 +268,7 @@ class PluginWorkflowServer extends import_server.Plugin {
   initInstructions(more = {}) {
     this.registerInstruction("calculation", import_CalculationInstruction.default);
     this.registerInstruction("condition", import_ConditionInstruction.default);
+    this.registerInstruction("multi-conditions", import_MultiConditionsInstruction.default);
     this.registerInstruction("end", import_EndInstruction.default);
     this.registerInstruction("create", import_CreateInstruction.default);
     this.registerInstruction("destroy", import_DestroyInstruction.default);
@@ -279,10 +289,6 @@ class PluginWorkflowServer extends import_server.Plugin {
     this.snowflake = new import_nodejs_snowflake.Snowflake({
       custom_epoch: pluginRecord == null ? void 0 : pluginRecord.createdAt.getTime()
     });
-    this.app.backgroundJobManager.subscribe(`${this.name}.pendingExecution`, {
-      idle: () => this.app.serving(import_Dispatcher.WORKER_JOB_WORKFLOW_PROCESS) && this.dispatcher.idle,
-      process: this.dispatcher.onQueueExecution
-    });
   }
   /**
    * @internal
@@ -297,14 +303,23 @@ class PluginWorkflowServer extends import_server.Plugin {
       max: 20,
       updateAgeOnGet: true,
       dispose(logger) {
-        logger.end();
+        const cachedLogger = logger;
+        if (!cachedLogger) {
+          return;
+        }
+        cachedLogger.silent = true;
+        if (typeof cachedLogger.close === "function") {
+          cachedLogger.close();
+        }
       }
     });
     this.meter = this.app.telemetry.metric.getMeter();
-    const counter = this.meter.createObservableGauge("workflow.events.counter");
-    counter.addCallback((result) => {
-      result.observe(this.dispatcher.getEventsCount());
-    });
+    if (this.meter) {
+      const counter = this.meter.createObservableGauge("workflow.events.counter");
+      counter.addCallback((result) => {
+        result.observe(this.dispatcher.getEventsCount());
+      });
+    }
     this.app.acl.registerSnippet({
       name: `pm.${this.name}.workflows`,
       actions: [
@@ -316,6 +331,7 @@ class PluginWorkflowServer extends import_server.Plugin {
         "executions:destroy",
         "flow_nodes:update",
         "flow_nodes:destroy",
+        "flow_nodes:destroyBranch",
         "flow_nodes:test",
         "jobs:get",
         "workflowCategories:*"
@@ -333,12 +349,18 @@ class PluginWorkflowServer extends import_server.Plugin {
     db.on("workflows.afterDestroy", this.onAfterDestroy);
     this.app.on("afterStart", this.onAfterStart);
     this.app.on("beforeStop", this.onBeforeStop);
+    this.app.eventQueue.subscribe(this.channelPendingExecution, {
+      idle: () => this.serving() && this.dispatcher.idle,
+      process: this.dispatcher.onQueueExecution
+    });
   }
   toggle(workflow, enable, { silent, transaction } = {}) {
     const type = workflow.get("type");
     const trigger = this.triggers.get(type);
     if (!trigger) {
-      this.getLogger(workflow.id).error(`trigger type ${workflow.type} of workflow ${workflow.id} is not implemented`);
+      this.getLogger(workflow.id).error(`trigger type ${workflow.type} of workflow ${workflow.id} is not implemented`, {
+        workflowId: workflow.id
+      });
       return;
     }
     const next = enable ?? workflow.get("enabled");
@@ -346,14 +368,20 @@ class PluginWorkflowServer extends import_server.Plugin {
       const prev = workflow.previous();
       if (prev.config) {
         trigger.off({ ...workflow.get(), ...prev });
-        this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id} based on configuration before updated`);
+        this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id} based on configuration before updated`, {
+          workflowId: workflow.id
+        });
       }
       trigger.on(workflow);
-      this.getLogger(workflow.id).info(`toggle ON workflow ${workflow.id}`);
+      this.getLogger(workflow.id).info(`toggle ON workflow ${workflow.id}`, {
+        workflowId: workflow.id
+      });
       this.enabledCache.set(workflow.id, workflow);
     } else {
       trigger.off(workflow);
-      this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id}`);
+      this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id}`, {
+        workflowId: workflow.id
+      });
       this.enabledCache.delete(workflow.id);
     }
     if (!silent) {
@@ -453,3 +481,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_JOB_WORKFLOW_PROCESS
+});

package/dist/server/Processor.js

@@ -144,7 +144,9 @@ class Processor {
   async start() {
     const { execution } = this;
     if (execution.status) {
-      this.logger.warn(`execution was ended with status ${execution.status} before, could not be started again`);
+      this.logger.warn(`execution was ended with status ${execution.status} before, could not be started again`, {
+        workflowId: execution.workflowId
+      });
       return;
     }
     await this.prepare();
@@ -158,7 +160,9 @@ class Processor {
   async resume(job) {
     const { execution } = this;
     if (execution.status) {
-      this.logger.warn(`execution was ended with status ${execution.status} before, could not be resumed`);
+      this.logger.warn(`execution was ended with status ${execution.status} before, could not be resumed`, {
+        workflowId: execution.workflowId
+      });
       return;
     }
     await this.prepare();
@@ -168,7 +172,7 @@ class Processor {
   async exec(instruction, node, prevJob) {
     let job;
     try {
-      this.logger.debug(`config of node`, { data: node.config });
+      this.logger.debug(`config of node`, { data: node.config, workflowId: node.workflowId });
       job = await instruction(node, prevJob, this);
       if (job === null) {
         return this.exit();
@@ -179,7 +183,7 @@ class Processor {
     } catch (err) {
       this.logger.error(
         `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
-        err
+        { error: err, workflowId: node.workflowId }
       );
       job = {
         result: err instanceof Error ? {
@@ -199,7 +203,10 @@ class Processor {
     }
     const savedJob = this.saveJob(job);
     this.logger.info(
-      `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) finished as status: ${savedJob.status}`
+      `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) finished as status: ${savedJob.status}`,
+      {
+        workflowId: node.workflowId
+      }
     );
     this.logger.debug(`result of node`, { data: savedJob.result });
     if (savedJob.status === import_constants.JOB_STATUS.RESOLVED && node.downstream) {
@@ -217,7 +224,9 @@ class Processor {
     if (typeof instruction.run !== "function") {
       return Promise.reject(new Error("`run` should be implemented for customized execution of the node"));
     }
-    this.logger.info(`execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id})`);
+    this.logger.info(`execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id})`, {
+      workflowId: node.workflowId
+    });
     return this.exec(instruction.run.bind(instruction), node, input);
   }
   // parent node should take over the control
@@ -225,7 +234,9 @@ class Processor {
     this.logger.debug(`branch ended at node (${node.id})`);
     const parentNode = this.findBranchParentNode(node);
     if (parentNode) {
-      this.logger.debug(`not on main, recall to parent entry node (${node.id})})`);
+      this.logger.debug(`not on main, recall to parent entry node (${node.id})})`, {
+        workflowId: node.workflowId
+      });
       await this.recall(parentNode, job);
       return null;
     }
@@ -242,7 +253,9 @@ class Processor {
         new Error(`"resume" method should be implemented for [${node.type}] instruction of node (#${node.id})`)
       );
     }
-    this.logger.info(`execution (${this.execution.id}) resume instruction [${node.type}] for node (${node.id})`);
+    this.logger.info(`execution (${this.execution.id}) resume instruction [${node.type}] for node (${node.id})`, {
+      workflowId: node.workflowId
+    });
     return this.exec(instruction.resume.bind(instruction), node, job);
   }
   async exit(s) {
@@ -261,6 +274,10 @@ class Processor {
             changes.push([`status`, job.status]);
             job.changed("status", false);
           }
+          if (job.changed("meta")) {
+            changes.push([`meta`, JSON.stringify(job.meta ?? null)]);
+            job.changed("meta", false);
+          }
           if (job.changed("result")) {
             changes.push([`result`, JSON.stringify(job.result ?? null)]);
             job.changed("result", false);
@@ -295,7 +312,9 @@ class Processor {
     if (this.mainTransaction && this.mainTransaction !== this.transaction) {
       await this.mainTransaction.commit();
     }
-    this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`);
+    this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`, {
+      workflowId: this.execution.workflowId
+    });
     return null;
   }
   /**
@@ -326,7 +345,9 @@ class Processor {
     this.lastSavedJob = job;
     this.jobsMapByNodeKey[job.nodeKey] = job;
     this.jobResultsMapByNodeKey[job.nodeKey] = job.result;
-    this.logger.debug(`job added to save list: ${JSON.stringify(job)}`);
+    this.logger.debug(`job added to save list: ${JSON.stringify(job)}`, {
+      workflowId: this.execution.workflowId
+    });
     return job;
   }
   /**

package/dist/server/actions/index.js

@@ -61,6 +61,7 @@ function actions_default({ app }) {
     ...make("flow_nodes", {
       update: nodes.update,
       destroy: nodes.destroy,
+      destroyBranch: nodes.destroyBranch,
       test: nodes.test
     }),
     ...make("executions", executions),

package/dist/server/actions/nodes.d.ts

@@ -9,5 +9,6 @@
 import { Context } from '@nocobase/actions';
 export declare function create(context: Context, next: any): Promise<void>;
 export declare function destroy(context: Context, next: any): Promise<void>;
+export declare function destroyBranch(context: Context, next: any): Promise<void>;
 export declare function update(context: Context, next: any): Promise<void>;
 export declare function test(context: Context, next: any): Promise<void>;

package/dist/server/actions/nodes.js

@@ -38,6 +38,7 @@ var nodes_exports = {};
 __export(nodes_exports, {
   create: () => create,
   destroy: () => destroy,
+  destroyBranch: () => destroyBranch,
   test: () => test,
   update: () => update
 });
@@ -146,38 +147,146 @@ function searchBranchDownstreams(nodes, from) {
   }
   return result;
 }
+function findBranchTail(branchHead) {
+  let tail = branchHead;
+  while (tail.downstream) {
+    tail = tail.downstream;
+  }
+  return tail;
+}
 async function destroy(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
-  const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
+  const { filterByTk, keepBranch } = context.action.params;
+  const keepBranchIndex = keepBranch == null || keepBranch === "" ? null : Number.parseInt(keepBranch, 10);
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
   const instance = await repository.findOne({
     filterByTk,
     fields: [...fields, "workflowId"],
     appends: ["upstream", "downstream", "workflow.versionStats.executed"]
   });
+  if (!instance) {
+    context.throw(404, "Node not found");
+  }
   if (instance.workflow.versionStats.executed > 0) {
     context.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
-    if (upstream && upstream.downstreamId === instance.id) {
-      await upstream.update(
-        {
-          downstreamId: instance.downstreamId
-        },
-        { transaction }
-      );
+    const nodes = await repository.find({
+      filter: {
+        workflowId: instance.workflowId
+      },
+      fields,
+      transaction
+    });
+    const nodesMap = /* @__PURE__ */ new Map();
+    nodes.forEach((item) => {
+      nodesMap.set(item.id, item);
+    });
+    nodes.forEach((item) => {
+      if (item.upstreamId) {
+        item.upstream = nodesMap.get(item.upstreamId);
+      }
+      if (item.downstreamId) {
+        item.downstream = nodesMap.get(item.downstreamId);
+      }
+    });
+    const keepBranchHead = keepBranchIndex != null ? nodes.find((item) => item.upstreamId === instance.id && item.branchIndex == keepBranchIndex) : null;
+    if (keepBranchIndex != null && !keepBranchHead) {
+      context.throw(400, `Branch ${keepBranchIndex} not found`);
     }
-    if (downstream) {
-      await downstream.update(
+    const keepBranchNodes = keepBranchHead ? searchBranchDownstreams(nodes, keepBranchHead) : [];
+    const keepBranchNodeIds = new Set(keepBranchNodes.map((item) => item.id));
+    const branchNodes = instance ? searchBranchNodes(nodes, instance) : [];
+    const branchNodesToDelete = keepBranchHead ? branchNodes.filter((item) => !keepBranchNodeIds.has(item.id)) : branchNodes;
+    if (keepBranchHead) {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: keepBranchHead.id
+          },
+          { transaction }
+        );
+      }
+      await keepBranchHead.update(
         {
           upstreamId: instance.upstreamId,
           branchIndex: instance.branchIndex
         },
         { transaction }
       );
+      if (downstream) {
+        const branchTail = findBranchTail(keepBranchHead);
+        await branchTail.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+        branchTail.downstreamId = instance.downstreamId;
+        branchTail.downstream = downstream;
+        await downstream.update(
+          {
+            upstreamId: branchTail.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+      }
+    } else {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+      }
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.upstreamId,
+            branchIndex: instance.branchIndex
+          },
+          { transaction }
+        );
+      }
     }
+    await repository.destroy({
+      filterByTk: [instance.id, ...branchNodesToDelete.map((item) => item.id)],
+      transaction
+    });
+  });
+  context.body = instance;
+  await next();
+}
+async function destroyBranch(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, branchIndex: branchIndexParam, shift: shiftParam } = context.action.params;
+  if (branchIndexParam == null || branchIndexParam === "") {
+    context.throw(400, "branchIndex is required");
+  }
+  const branchIndex = Number.parseInt(branchIndexParam, 10);
+  if (Number.isNaN(branchIndex)) {
+    context.throw(400, "branchIndex must be a number");
+  }
+  const shift = !(shiftParam == null || shiftParam === "") && Number.parseInt(String(shiftParam), 10) === 1;
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
+  const instance = await repository.findOne({
+    filterByTk,
+    fields: [...fields, "workflowId"],
+    appends: ["workflow.versionStats.executed"]
+  });
+  if (!instance) {
+    context.throw(404, "Node not found");
+  }
+  if (instance.workflow.versionStats.executed > 0) {
+    context.throw(400, "Branches in executed workflow could not be deleted");
+  }
+  let deletedBranchHead = null;
+  await db.sequelize.transaction(async (transaction) => {
     const nodes = await repository.find({
       filter: {
         workflowId: instance.workflowId
@@ -197,13 +306,34 @@ async function destroy(context, next) {
         item.downstream = nodesMap.get(item.downstreamId);
       }
     });
-    const branchNodes = searchBranchNodes(nodes, nodesMap.get(instance.id));
-    await repository.destroy({
-      filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
-      transaction
-    });
+    const branchHeads = nodes.filter((item) => item.upstreamId === instance.id && item.branchIndex != null).sort((a, b) => a.branchIndex - b.branchIndex);
+    const branchHead = branchHeads.find((item) => item.branchIndex === branchIndex);
+    deletedBranchHead = branchHead || null;
+    if (branchHead) {
+      const nodesToDelete = searchBranchDownstreams(nodes, branchHead);
+      const idsToDelete = nodesToDelete.map((item) => item.id);
+      if (idsToDelete.length) {
+        await repository.destroy({
+          filterByTk: idsToDelete,
+          transaction
+        });
+      }
+    }
+    if (shift) {
+      const headsToShift = branchHeads.filter((item) => item.branchIndex > branchIndex);
+      await Promise.all(
+        headsToShift.map(
+          (item) => item.update(
+            {
+              branchIndex: item.branchIndex - 1
+            },
+            { transaction }
+          )
+        )
+      );
+    }
   });
-  context.body = instance;
+  context.body = deletedBranchHead;
   await next();
 }
 async function update(context, next) {
@@ -254,6 +384,7 @@ async function test(context, next) {
 0 && (module.exports = {
   create,
   destroy,
+  destroyBranch,
   test,
   update
 });

package/dist/server/instructions/MultiConditionsInstruction.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel, JobModel } from '../types';
+export declare class MultiConditionsInstruction extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<JobModel>;
+    resume(node: FlowNodeModel, branchJob: JobModel, processor: Processor): Promise<any>;
+    private evaluateCondition;
+    private getBranchNode;
+}
+export default MultiConditionsInstruction;

package/dist/server/instructions/MultiConditionsInstruction.js

@@ -0,0 +1,118 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MultiConditionsInstruction_exports = {};
+__export(MultiConditionsInstruction_exports, {
+  MultiConditionsInstruction: () => MultiConditionsInstruction,
+  default: () => MultiConditionsInstruction_default
+});
+module.exports = __toCommonJS(MultiConditionsInstruction_exports);
+var import_evaluators = require("@nocobase/evaluators");
+var import__ = require(".");
+var import_constants = require("../constants");
+var import_logicCalculate = require("../logicCalculate");
+class MultiConditionsInstruction extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const { conditions = [], continueOnNoMatch = false } = node.config || {};
+    const meta = { conditions: [] };
+    const job = processor.saveJob({
+      status: import_constants.JOB_STATUS.PENDING,
+      result: null,
+      meta,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    for (let cursor = 0; cursor < conditions.length; cursor++) {
+      const branchIndex = cursor + 1;
+      const condition = conditions[cursor];
+      let conditionResult;
+      try {
+        conditionResult = this.evaluateCondition(condition, node, processor);
+      } catch (error) {
+        conditionResult = error instanceof Error ? error.message : String(error);
+        processor.logger.error(`[multi-conditions] evaluate condition[${cursor}] error:`, { error });
+      } finally {
+        meta.conditions.push(conditionResult);
+        job.set("result", conditionResult);
+      }
+      if (typeof conditionResult === "string") {
+        job.set("status", import_constants.JOB_STATUS.ERROR);
+        return job;
+      }
+      if (conditionResult === true) {
+        const branchNode = this.getBranchNode(node, processor, branchIndex);
+        job.set("status", import_constants.JOB_STATUS.RESOLVED);
+        if (branchNode) {
+          await processor.run(branchNode, job);
+          return;
+        }
+        return job;
+      }
+    }
+    job.set("status", continueOnNoMatch ? import_constants.JOB_STATUS.RESOLVED : import_constants.JOB_STATUS.FAILED);
+    const defaultBranch = this.getBranchNode(node, processor, 0);
+    if (defaultBranch) {
+      await processor.run(defaultBranch, job);
+      return;
+    }
+    return job;
+  }
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    if (!job) {
+      throw new Error("Parent job not found");
+    }
+    const { continueOnNoMatch = false } = node.config || {};
+    const jobNode = processor.nodesMap.get(branchJob.nodeId);
+    const branchStartNode = processor.findBranchStartNode(jobNode, node);
+    const branchIndex = branchStartNode.branchIndex;
+    if (branchJob.status === import_constants.JOB_STATUS.RESOLVED) {
+      if (branchIndex > 0) {
+        job.set({
+          status: import_constants.JOB_STATUS.RESOLVED
+        });
+        return job;
+      }
+      job.set({ status: continueOnNoMatch ? import_constants.JOB_STATUS.RESOLVED : import_constants.JOB_STATUS.FAILED });
+      return job;
+    }
+    return processor.exit(branchJob.status);
+  }
+  evaluateCondition(condition, node, processor) {
+    const { engine = "basic", calculation, expression } = condition ?? {};
+    const evaluator = import_evaluators.evaluators.get(engine);
+    return evaluator ? evaluator(expression, processor.getScope(node.id)) : (0, import_logicCalculate.logicCalculate)(processor.getParsedValue(calculation, node.id));
+  }
+  getBranchNode(node, processor, branchIndex) {
+    return processor.getBranches(node).find((item) => Number(item.branchIndex) === Number(branchIndex));
+  }
+}
+var MultiConditionsInstruction_default = MultiConditionsInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiConditionsInstruction
+});