@nocobase/plugin-workflow 2.0.0-alpha.9 → 2.1.0-alpha.1

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
@@ -293,18 +299,30 @@ class PluginWorkflowServer extends import_server.Plugin {
     this.initTriggers(options.triggers);
     this.initInstructions(options.instructions);
     (0, import_functions.default)(this, options.functions);
+    this.functions.register("instanceId", () => this.app.instanceId);
+    this.functions.register("epoch", () => 1605024e3);
+    this.functions.register("genSnowflakeId", () => this.app.snowflakeIdGenerator.generate());
     this.loggerCache = new import_lru_cache.default({
       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 +334,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 +352,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 +371,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 +484,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

@@ -102,11 +102,15 @@ class Processor {
     });
   }
   makeJobs(jobs) {
-    jobs.forEach((job) => {
+    for (const job of jobs) {
       const node = this.nodesMap.get(job.nodeId);
+      if (!node) {
+        this.logger.warn(`node (#${job.nodeId}) not found for job (#${job.id}), this will lead to unexpected error`);
+        continue;
+      }
       this.jobsMapByNodeKey[node.key] = job;
       this.jobResultsMapByNodeKey[node.key] = job.result;
-    });
+    }
   }
   async prepare() {
     const {
@@ -144,7 +148,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 +164,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 +176,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 +187,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 +207,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 +228,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 +238,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 +257,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 +278,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 +316,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 +349,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

@@ -41,6 +41,7 @@ __export(actions_exports, {
 module.exports = __toCommonJS(actions_exports);
 var workflows = __toESM(require("./workflows"));
 var nodes = __toESM(require("./nodes"));
+var jobs = __toESM(require("./jobs"));
 var executions = __toESM(require("./executions"));
 var userWorkflowTasks = __toESM(require("./userWorkflowTasks"));
 function make(name, mod) {
@@ -61,8 +62,10 @@ function actions_default({ app }) {
     ...make("flow_nodes", {
       update: nodes.update,
       destroy: nodes.destroy,
+      destroyBranch: nodes.destroyBranch,
       test: nodes.test
     }),
+    ...make("jobs", jobs),
     ...make("executions", executions),
     ...make("userWorkflowTasks", userWorkflowTasks)
   });

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

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function resume(context: any, next: any): Promise<any>;

package/dist/server/actions/jobs.js

@@ -0,0 +1,64 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jobs_exports = {};
+__export(jobs_exports, {
+  resume: () => resume
+});
+module.exports = __toCommonJS(jobs_exports);
+var import_actions = require("@nocobase/actions");
+var import_Plugin = __toESM(require("../Plugin"));
+async function resume(context, next) {
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const workflowPlugin = context.app.pm.get(import_Plugin.default);
+  const { filterByTk, values = {} } = context.action.params;
+  const job = await repository.findOne({
+    filterByTk
+  });
+  if (!job) {
+    return context.throw(404, "Job not found");
+  }
+  workflowPlugin.getLogger(job.workflowId).warn(`Resuming job #${job.id}...`);
+  await job.update(values);
+  context.body = job;
+  context.status = 202;
+  await next();
+  workflowPlugin.resume(job);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resume
+});

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
 });
@@ -158,7 +159,7 @@ async function destroy(context, next) {
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const { filterByTk, keepBranch } = context.action.params;
   const keepBranchIndex = keepBranch == null || keepBranch === "" ? null : Number.parseInt(keepBranch, 10);
-  const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
   const instance = await repository.findOne({
     filterByTk,
     fields: [...fields, "workflowId"],
@@ -260,6 +261,81 @@ async function destroy(context, next) {
   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
+      },
+      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 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 = deletedBranchHead;
+  await next();
+}
 async function update(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
@@ -308,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
+});

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

@@ -21,7 +21,9 @@ export type InstructionInterface = {
     run: Runner;
     resume?: Runner;
     getScope?: (node: FlowNodeModel, data: any, processor: Processor) => any;
-    duplicateConfig?: (node: FlowNodeModel, options: Transactionable) => object | Promise<object>;
+    duplicateConfig?: (node: FlowNodeModel, options: Transactionable & {
+        origin?: FlowNodeModel;
+    }) => object | Promise<object>;
     test?: (config: Record<string, any>) => IJob | Promise<IJob>;
 };
 export declare abstract class Instruction implements InstructionInterface {