@nocobase/plugin-workflow 1.8.26 → 1.8.28

package/dist/client/nodes/condition.d.ts

@@ -98,9 +98,6 @@ export default class extends Instruction {
     branching: ({ rejectOnFalse }?: {
         rejectOnFalse?: boolean;
     }) => false | ({
-        label: string;
-        value: boolean;
-    } | {
         label: string;
         value: 1;
     } | {

package/dist/externalVersion.js

@@ -11,8 +11,8 @@ module.exports = {
   "react": "18.2.0",
   "@formily/core": "2.3.0",
   "@formily/react": "2.3.0",
-  "@nocobase/client": "1.8.26",
-  "@nocobase/utils": "1.8.26",
+  "@nocobase/client": "1.8.28",
+  "@nocobase/utils": "1.8.28",
   "antd": "5.24.2",
   "@ant-design/icons": "5.6.1",
   "react-router-dom": "6.28.1",
@@ -20,17 +20,17 @@ module.exports = {
   "lodash": "4.17.21",
   "@dnd-kit/core": "6.1.0",
   "@formily/shared": "2.3.2",
-  "@nocobase/plugin-mobile": "1.8.26",
+  "@nocobase/plugin-mobile": "1.8.28",
   "sequelize": "6.35.2",
-  "@nocobase/database": "1.8.26",
-  "@nocobase/server": "1.8.26",
-  "@nocobase/data-source-manager": "1.8.26",
-  "@nocobase/logger": "1.8.26",
-  "@nocobase/evaluators": "1.8.26",
+  "@nocobase/database": "1.8.28",
+  "@nocobase/server": "1.8.28",
+  "@nocobase/data-source-manager": "1.8.28",
+  "@nocobase/logger": "1.8.28",
+  "@nocobase/evaluators": "1.8.28",
   "@formily/antd-v5": "1.2.3",
   "@formily/reactive": "2.3.0",
-  "@nocobase/actions": "1.8.26",
+  "@nocobase/actions": "1.8.28",
   "dayjs": "1.11.13",
-  "@nocobase/plugin-workflow-test": "1.8.26",
-  "@nocobase/test": "1.8.26"
+  "@nocobase/plugin-workflow-test": "1.8.28",
+  "@nocobase/test": "1.8.28"
 };

package/dist/locale/zh-CN.json

@@ -179,16 +179,19 @@
   "Calculation result": "计算结果",
   "True": "真",
   "False": "假",
-  "concat": "连接",
+  "Concat": "连接",
   "Condition": "条件判断",
   "Based on boolean result of the calculation to determine whether to \"continue\" or \"exit\" the process, or continue on different branches of \"yes\" and \"no\".":
     "基于计算结果的真假来决定“继续”或“退出”流程，或者在“是”与“否”的分支上分别继续。",
   "Mode": "模式",
+  "Yes": "是",
+  "No": "否",
   "Continue when \"Yes\"": "“是”则继续",
   "Branch into \"Yes\" and \"No\"": "“是”和“否”分别继续",
   "Condition expression": "条件表达式",
-  "Inside of \"Yes\" branch": "“是”分支内",
-  "Inside of \"No\" branch": "“否”分支内",
+  "Inside of \"{{branchName}}\" branch": "“{{branchName}}”分支内",
+  "\"{{branchName}}\" branch": "“{{branchName}}”分支",
+  "Branch {{index}}": "分支 {{index}}",
   "Create record": "新增数据",
   "Add new record to a collection. You can use variables from upstream nodes to assign values to fields.":
     "向一个数据表中添加新的数据。可以使用上游节点里的变量为字段赋值。",
@@ -235,7 +238,10 @@
   "Succeeded": "成功",
   "Test run": "测试执行",
   "Test run will do the actual data manipulating or API calling, please use with caution.": "测试执行会进行实际的数据操作或 API 调用，请谨慎使用。",
+  "Replace variables": "替换变量",
   "No variable": "无变量",
+  "Result": "结果",
+  "Log": "日志",
 
   "Add node": "添加节点",
   "Move all downstream nodes to": "将所有下游节点移至",
@@ -246,6 +252,11 @@
   "New version enabled": "已启用新版本",
   "Workflow is not exists": "工作流不存在",
 
+  "Delete node": "删除节点",
+  "Branch to keep": "保留分支",
+  "Delete all": "删除全部",
+  "Keep": "保留",
+
   "Select users": "选择用户",
   "Query users": "查询用户",
   "Add": "添加",

package/dist/node_modules/cron-parser/package.json

@@ -1 +1 @@
-{"name":"cron-parser","version":"4.4.0","description":"Node.js library for parsing crontab instructions","main":"lib/parser.js","types":"index.d.ts","typesVersions":{"<4.1":{"*":["types/ts3/*"]}},"directories":{"test":"test"},"scripts":{"test:tsd":"tsd","test:unit":"TZ=UTC tap ./test/*.js","test:cover":"TZ=UTC tap --coverage-report=html ./test/*.js","lint":"eslint .","lint:fix":"eslint --fix .","test":"npm run lint && npm run test:unit && npm run test:tsd"},"repository":{"type":"git","url":"https://github.com/harrisiirak/cron-parser.git"},"keywords":["cron","crontab","parser"],"author":"Harri Siirak","contributors":["Nicholas Clawson","Daniel Prentis <daniel@salsitasoft.com>","Renault John Lecoultre","Richard Astbury <richard.astbury@gmail.com>","Meaglin Wasabi <Meaglin.wasabi@gmail.com>","Mike Kusold <hello@mikekusold.com>","Alex Kit <alex.kit@atmajs.com>","Santiago Gimeno <santiago.gimeno@gmail.com>","Daniel <darc.tec@gmail.com>","Christian Steininger <christian.steininger.cs@gmail.com>","Mykola Piskovyi <m.piskovyi@gmail.com>","Brian Vaughn <brian.david.vaughn@gmail.com>","Nicholas Clawson <nickclaw@gmail.com>","Yasuhiroki <yasuhiroki.duck@gmail.com>","Nicholas Clawson <nickclaw@gmail.com>","Brendan Warkentin <faazshift@gmail.com>","Charlie Fish <fishcharlie.code@gmail.com>","Ian Graves <ian+diskimage@iangrav.es>","Andy Thompson <me@andytson.com>","Regev Brody <regevbr@gmail.com>"],"license":"MIT","dependencies":{"luxon":"^1.28.0"},"devDependencies":{"eslint":"^8.2.0","sinon":"^10.0.0","tap":"^16.0.1","tsd":"^0.19.0"},"engines":{"node":">=0.8"},"browser":{"fs":false},"tap":{"check-coverage":false},"tsd":{"directory":"test","compilerOptions":{"lib":["es2017","dom"]}},"_lastModified":"2025-09-20T04:13:43.893Z"}
+{"name":"cron-parser","version":"4.4.0","description":"Node.js library for parsing crontab instructions","main":"lib/parser.js","types":"index.d.ts","typesVersions":{"<4.1":{"*":["types/ts3/*"]}},"directories":{"test":"test"},"scripts":{"test:tsd":"tsd","test:unit":"TZ=UTC tap ./test/*.js","test:cover":"TZ=UTC tap --coverage-report=html ./test/*.js","lint":"eslint .","lint:fix":"eslint --fix .","test":"npm run lint && npm run test:unit && npm run test:tsd"},"repository":{"type":"git","url":"https://github.com/harrisiirak/cron-parser.git"},"keywords":["cron","crontab","parser"],"author":"Harri Siirak","contributors":["Nicholas Clawson","Daniel Prentis <daniel@salsitasoft.com>","Renault John Lecoultre","Richard Astbury <richard.astbury@gmail.com>","Meaglin Wasabi <Meaglin.wasabi@gmail.com>","Mike Kusold <hello@mikekusold.com>","Alex Kit <alex.kit@atmajs.com>","Santiago Gimeno <santiago.gimeno@gmail.com>","Daniel <darc.tec@gmail.com>","Christian Steininger <christian.steininger.cs@gmail.com>","Mykola Piskovyi <m.piskovyi@gmail.com>","Brian Vaughn <brian.david.vaughn@gmail.com>","Nicholas Clawson <nickclaw@gmail.com>","Yasuhiroki <yasuhiroki.duck@gmail.com>","Nicholas Clawson <nickclaw@gmail.com>","Brendan Warkentin <faazshift@gmail.com>","Charlie Fish <fishcharlie.code@gmail.com>","Ian Graves <ian+diskimage@iangrav.es>","Andy Thompson <me@andytson.com>","Regev Brody <regevbr@gmail.com>"],"license":"MIT","dependencies":{"luxon":"^1.28.0"},"devDependencies":{"eslint":"^8.2.0","sinon":"^10.0.0","tap":"^16.0.1","tsd":"^0.19.0"},"engines":{"node":">=0.8"},"browser":{"fs":false},"tap":{"check-coverage":false},"tsd":{"directory":"test","compilerOptions":{"lib":["es2017","dom"]}},"_lastModified":"2025-10-14T05:56:38.482Z"}

package/dist/node_modules/lru-cache/package.json

@@ -1 +1 @@
-{"name":"lru-cache","description":"A cache object that deletes the least-recently-used items.","version":"8.0.5","author":"Isaac Z. Schlueter <i@izs.me>","keywords":["mru","lru","cache"],"sideEffects":false,"scripts":{"build":"npm run prepare","preprepare":"rm -rf dist","prepare":"tsc -p tsconfig.json && tsc -p tsconfig-esm.json","postprepare":"bash fixup.sh","pretest":"npm run prepare","presnap":"npm run prepare","test":"c8 tap","snap":"c8 tap","preversion":"npm test","postversion":"npm publish","prepublishOnly":"git push origin --follow-tags","format":"prettier --write .","typedoc":"typedoc --tsconfig tsconfig-esm.json ./src/*.ts","benchmark-results-typedoc":"bash scripts/benchmark-results-typedoc.sh","prebenchmark":"npm run prepare","benchmark":"make -C benchmark","preprofile":"npm run prepare","profile":"make -C benchmark profile"},"main":"./dist/cjs/index-cjs.js","module":"./dist/mjs/index.js","types":"./dist/mjs/index.d.ts","exports":{"./min":{"import":{"types":"./dist/mjs/index.d.ts","default":"./dist/mjs/index.min.js"},"require":{"types":"./dist/cjs/index.d.ts","default":"./dist/cjs/index.min.js"}},".":{"import":{"types":"./dist/mjs/index.d.ts","default":"./dist/mjs/index.js"},"require":{"types":"./dist/cjs/index.d.ts","default":"./dist/cjs/index-cjs.js"}}},"repository":"git://github.com/isaacs/node-lru-cache.git","devDependencies":{"@size-limit/preset-small-lib":"^7.0.8","@types/node":"^17.0.31","@types/tap":"^15.0.6","benchmark":"^2.1.4","c8":"^7.11.2","clock-mock":"^1.0.6","esbuild":"^0.17.11","eslint-config-prettier":"^8.5.0","marked":"^4.2.12","mkdirp":"^2.1.5","prettier":"^2.6.2","size-limit":"^7.0.8","tap":"^16.3.4","ts-node":"^10.7.0","tslib":"^2.4.0","typedoc":"^0.23.24","typescript":"^4.6.4"},"license":"ISC","files":["dist"],"engines":{"node":">=16.14"},"prettier":{"semi":false,"printWidth":70,"tabWidth":2,"useTabs":false,"singleQuote":true,"jsxSingleQuote":false,"bracketSameLine":true,"arrowParens":"avoid","endOfLine":"lf"},"tap":{"coverage":false,"node-arg":["--expose-gc","--no-warnings","--loader","ts-node/esm"],"ts":false},"size-limit":[{"path":"./dist/mjs/index.js"}],"_lastModified":"2025-09-20T04:13:43.546Z"}
+{"name":"lru-cache","description":"A cache object that deletes the least-recently-used items.","version":"8.0.5","author":"Isaac Z. Schlueter <i@izs.me>","keywords":["mru","lru","cache"],"sideEffects":false,"scripts":{"build":"npm run prepare","preprepare":"rm -rf dist","prepare":"tsc -p tsconfig.json && tsc -p tsconfig-esm.json","postprepare":"bash fixup.sh","pretest":"npm run prepare","presnap":"npm run prepare","test":"c8 tap","snap":"c8 tap","preversion":"npm test","postversion":"npm publish","prepublishOnly":"git push origin --follow-tags","format":"prettier --write .","typedoc":"typedoc --tsconfig tsconfig-esm.json ./src/*.ts","benchmark-results-typedoc":"bash scripts/benchmark-results-typedoc.sh","prebenchmark":"npm run prepare","benchmark":"make -C benchmark","preprofile":"npm run prepare","profile":"make -C benchmark profile"},"main":"./dist/cjs/index-cjs.js","module":"./dist/mjs/index.js","types":"./dist/mjs/index.d.ts","exports":{"./min":{"import":{"types":"./dist/mjs/index.d.ts","default":"./dist/mjs/index.min.js"},"require":{"types":"./dist/cjs/index.d.ts","default":"./dist/cjs/index.min.js"}},".":{"import":{"types":"./dist/mjs/index.d.ts","default":"./dist/mjs/index.js"},"require":{"types":"./dist/cjs/index.d.ts","default":"./dist/cjs/index-cjs.js"}}},"repository":"git://github.com/isaacs/node-lru-cache.git","devDependencies":{"@size-limit/preset-small-lib":"^7.0.8","@types/node":"^17.0.31","@types/tap":"^15.0.6","benchmark":"^2.1.4","c8":"^7.11.2","clock-mock":"^1.0.6","esbuild":"^0.17.11","eslint-config-prettier":"^8.5.0","marked":"^4.2.12","mkdirp":"^2.1.5","prettier":"^2.6.2","size-limit":"^7.0.8","tap":"^16.3.4","ts-node":"^10.7.0","tslib":"^2.4.0","typedoc":"^0.23.24","typescript":"^4.6.4"},"license":"ISC","files":["dist"],"engines":{"node":">=16.14"},"prettier":{"semi":false,"printWidth":70,"tabWidth":2,"useTabs":false,"singleQuote":true,"jsxSingleQuote":false,"bracketSameLine":true,"arrowParens":"avoid","endOfLine":"lf"},"tap":{"coverage":false,"node-arg":["--expose-gc","--no-warnings","--loader","ts-node/esm"],"ts":false},"size-limit":[{"path":"./dist/mjs/index.js"}],"_lastModified":"2025-10-14T05:56:38.198Z"}

package/dist/node_modules/nodejs-snowflake/package.json

@@ -1 +1 @@
-{"name":"nodejs-snowflake","collaborators":["Utkarsh Srivastava <utkarsh@sagacious.dev>"],"description":"Generate time sortable 64 bits unique ids for distributed systems (inspired from twitter snowflake)","version":"2.0.1","license":"Apache 2.0","repository":{"type":"git","url":"https://github.com/utkarsh-pro/nodejs-snowflake.git"},"files":["nodejs_snowflake_bg.wasm","nodejs_snowflake.js","nodejs_snowflake.d.ts"],"main":"nodejs_snowflake.js","types":"nodejs_snowflake.d.ts","_lastModified":"2025-09-20T04:13:43.346Z"}
+{"name":"nodejs-snowflake","collaborators":["Utkarsh Srivastava <utkarsh@sagacious.dev>"],"description":"Generate time sortable 64 bits unique ids for distributed systems (inspired from twitter snowflake)","version":"2.0.1","license":"Apache 2.0","repository":{"type":"git","url":"https://github.com/utkarsh-pro/nodejs-snowflake.git"},"files":["nodejs_snowflake_bg.wasm","nodejs_snowflake.js","nodejs_snowflake.d.ts"],"main":"nodejs_snowflake.js","types":"nodejs_snowflake.d.ts","_lastModified":"2025-10-14T05:56:37.939Z"}

package/dist/server/Dispatcher.d.ts

@@ -6,6 +6,52 @@
  * 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 { Transactionable } from 'sequelize';
+import type { QueueEventOptions } from '@nocobase/server';
+import Processor from './Processor';
+import type { ExecutionModel, JobModel, WorkflowModel } from './types';
+import type PluginWorkflowServer from './Plugin';
+type Pending = {
+    execution: ExecutionModel;
+    job?: JobModel;
+    force?: boolean;
+};
+export type EventOptions = {
+    eventKey?: string;
+    context?: any;
+    deferred?: boolean;
+    manually?: boolean;
+    force?: boolean;
+    stack?: Array<number | string>;
+    onTriggerFail?: Function;
+    [key: string]: any;
+} & Transactionable;
+export declare const WORKER_JOB_WORKFLOW_PROCESS = "workflow:process";
 export default class Dispatcher {
-    constructor();
+    private readonly plugin;
+    private ready;
+    private executing;
+    private pending;
+    private events;
+    private eventsCount;
+    get idle(): boolean;
+    constructor(plugin: PluginWorkflowServer);
+    readonly onQueueExecution: QueueEventOptions['process'];
+    setReady(ready: boolean): void;
+    isReady(): boolean;
+    getEventsCount(): number;
+    trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null>;
+    resume(job: any): Promise<void>;
+    start(execution: ExecutionModel): Promise<void>;
+    beforeStop(): Promise<void>;
+    dispatch(): Promise<void>;
+    run(pending: Pending): Promise<void>;
+    private triggerSync;
+    private validateEvent;
+    private createExecution;
+    private prepare;
+    private acquirePendingExecution;
+    private acquireQueueingExecution;
+    private process;
 }
+export {};

package/dist/server/Dispatcher.js

@@ -26,10 +26,381 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Dispatcher_exports = {};
 __export(Dispatcher_exports, {
+  WORKER_JOB_WORKFLOW_PROCESS: () => WORKER_JOB_WORKFLOW_PROCESS,
   default: () => Dispatcher
 });
 module.exports = __toCommonJS(Dispatcher_exports);
+var import_crypto = require("crypto");
+var import_sequelize = require("sequelize");
+var import_database = require("@nocobase/database");
+var import_constants = require("./constants");
+const WORKER_JOB_WORKFLOW_PROCESS = "workflow:process";
 class Dispatcher {
-  constructor() {
+  constructor(plugin) {
+    this.plugin = plugin;
+    this.prepare = this.prepare.bind(this);
+  }
+  ready = false;
+  executing = null;
+  pending = [];
+  events = [];
+  eventsCount = 0;
+  get idle() {
+    return !this.executing && !this.pending.length && !this.events.length;
+  }
+  onQueueExecution = async (event) => {
+    const ExecutionRepo = this.plugin.db.getRepository("executions");
+    const execution = await ExecutionRepo.findOne({
+      filterByTk: event.executionId
+    });
+    if (!execution || execution.status !== import_constants.EXECUTION_STATUS.QUEUEING) {
+      this.plugin.getLogger("dispatcher").info(`execution (${event.executionId}) from queue not found or not in queueing status, skip`);
+      return;
+    }
+    this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) received from queue, adding to pending list`);
+    this.run({ execution });
+  };
+  setReady(ready) {
+    this.ready = ready;
+  }
+  isReady() {
+    return this.ready;
+  }
+  getEventsCount() {
+    return this.eventsCount;
+  }
+  trigger(workflow, context, options = {}) {
+    const logger = this.plugin.getLogger(workflow.id);
+    if (!this.ready) {
+      logger.warn(`app is not ready, event of workflow ${workflow.id} will be ignored`);
+      logger.debug(`ignored event data:`, context);
+      return;
+    }
+    if (!options.force && !options.manually && !workflow.enabled) {
+      logger.warn(`workflow ${workflow.id} is not enabled, event will be ignored`);
+      return;
+    }
+    const duplicated = this.events.find(([w, c, { eventKey }]) => {
+      if (eventKey && options.eventKey) {
+        return eventKey === options.eventKey;
+      }
+    });
+    if (duplicated) {
+      logger.warn(`event of workflow ${workflow.id} is duplicated (${options.eventKey}), event will be ignored`);
+      return;
+    }
+    if (context == null) {
+      logger.warn(`workflow ${workflow.id} event data context is null, event will be ignored`);
+      return;
+    }
+    if (options.manually || this.plugin.isWorkflowSync(workflow)) {
+      return this.triggerSync(workflow, context, options);
+    }
+    const { transaction, ...rest } = options;
+    this.events.push([workflow, context, rest]);
+    this.eventsCount = this.events.length;
+    logger.info(`new event triggered, now events: ${this.events.length}`);
+    logger.debug(`event data:`, { context });
+    if (this.events.length > 1) {
+      logger.info(`new event is pending to be prepared after previous preparation is finished`);
+      return;
+    }
+    setImmediate(this.prepare);
+  }
+  async resume(job) {
+    let { execution } = job;
+    if (!execution) {
+      execution = await job.getExecution();
+    }
+    this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) resuming from job (${job.id}) added to pending list`);
+    this.run({ execution, job, force: true });
+  }
+  async start(execution) {
+    if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
+      return;
+    }
+    this.plugin.getLogger(execution.workflowId).info(`starting deferred execution (${execution.id})`);
+    this.run({ execution, force: true });
+  }
+  async beforeStop() {
+    this.ready = false;
+    if (this.events.length) {
+      await this.prepare();
+    }
+    if (this.executing) {
+      await this.executing;
+    }
+  }
+  dispatch() {
+    if (!this.ready) {
+      this.plugin.getLogger("dispatcher").warn(`app is not ready, new dispatching will be ignored`);
+      return;
+    }
+    if (!this.plugin.app.serving(WORKER_JOB_WORKFLOW_PROCESS)) {
+      this.plugin.getLogger("dispatcher").warn(`${WORKER_JOB_WORKFLOW_PROCESS} is not serving, new dispatching will be ignored`);
+      return;
+    }
+    if (this.executing) {
+      this.plugin.getLogger("dispatcher").warn(`workflow executing is not finished, new dispatching will be ignored`);
+      return;
+    }
+    if (this.events.length) {
+      return this.prepare();
+    }
+    this.executing = (async () => {
+      let next = null;
+      let execution = null;
+      if (this.pending.length) {
+        const pending = this.pending.shift();
+        execution = pending.force ? pending.execution : await this.acquirePendingExecution(pending.execution);
+        if (execution) {
+          next = [execution, pending.job];
+          this.plugin.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
+        }
+      } else {
+        execution = await this.acquireQueueingExecution();
+        if (execution) {
+          next = [execution];
+        }
+      }
+      if (next) {
+        await this.process(...next);
+      }
+      this.executing = null;
+      if (next || this.pending.length) {
+        this.plugin.getLogger("dispatcher").debug(`last process finished, will do another dispatch`);
+        this.dispatch();
+      }
+    })();
+  }
+  async run(pending) {
+    this.pending.push(pending);
+    this.dispatch();
+  }
+  async triggerSync(workflow, context, { deferred, ...options } = {}) {
+    let execution;
+    try {
+      execution = await this.createExecution(workflow, context, options);
+    } catch (err) {
+      this.plugin.getLogger(workflow.id).error(`creating execution failed: ${err.message}`, err);
+      return null;
+    }
+    try {
+      return this.process(execution, null, options);
+    } catch (err) {
+      this.plugin.getLogger(execution.workflowId).error(`execution (${execution.id}) error: ${err.message}`, err);
+    }
+    return null;
+  }
+  async validateEvent(workflow, context, options) {
+    const trigger = this.plugin.triggers.get(workflow.type);
+    const triggerValid = await trigger.validateEvent(workflow, context, options);
+    if (!triggerValid) {
+      return false;
+    }
+    const { stack } = options;
+    let valid = true;
+    if ((stack == null ? void 0 : stack.length) > 0) {
+      const existed = await workflow.countExecutions({
+        where: {
+          id: stack
+        },
+        transaction: options.transaction
+      });
+      const limitCount = workflow.options.stackLimit || 1;
+      if (existed >= limitCount) {
+        this.plugin.getLogger(workflow.id).warn(
+          `workflow ${workflow.id} has already been triggered in stacks executions (${stack}), and max call coont is ${limitCount}, newly triggering will be skipped.`
+        );
+        valid = false;
+      }
+    }
+    return valid;
+  }
+  async createExecution(workflow, context, options) {
+    var _a;
+    const { deferred } = options;
+    const transaction = await this.plugin.useDataSourceTransaction("main", options.transaction, true);
+    const sameTransaction = options.transaction === transaction;
+    const valid = await this.validateEvent(workflow, context, { ...options, transaction });
+    if (!valid) {
+      if (!sameTransaction) {
+        await transaction.commit();
+      }
+      (_a = options.onTriggerFail) == null ? void 0 : _a.call(options, workflow, context, options);
+      return Promise.reject(new Error("event is not valid"));
+    }
+    let execution;
+    try {
+      execution = await workflow.createExecution(
+        {
+          context,
+          key: workflow.key,
+          eventKey: options.eventKey ?? (0, import_crypto.randomUUID)(),
+          stack: options.stack,
+          status: deferred ? import_constants.EXECUTION_STATUS.STARTED : import_constants.EXECUTION_STATUS.QUEUEING
+        },
+        { transaction }
+      );
+    } catch (err) {
+      if (!sameTransaction) {
+        await transaction.rollback();
+      }
+      throw err;
+    }
+    this.plugin.getLogger(workflow.id).info(`execution of workflow ${workflow.id} created as ${execution.id}`);
+    if (!workflow.stats) {
+      workflow.stats = await workflow.getStats({ transaction });
+    }
+    await workflow.stats.increment("executed", { transaction });
+    if (this.plugin.db.options.dialect !== "postgres") {
+      await workflow.stats.reload({ transaction });
+    }
+    if (!workflow.versionStats) {
+      workflow.versionStats = await workflow.getVersionStats({ transaction });
+    }
+    await workflow.versionStats.increment("executed", { transaction });
+    if (this.plugin.db.options.dialect !== "postgres") {
+      await workflow.versionStats.reload({ transaction });
+    }
+    if (!sameTransaction) {
+      await transaction.commit();
+    }
+    execution.workflow = workflow;
+    return execution;
+  }
+  prepare = async () => {
+    if (this.executing && this.plugin.db.options.dialect === "sqlite") {
+      await this.executing;
+    }
+    const event = this.events.shift();
+    this.eventsCount = this.events.length;
+    if (!event) {
+      this.plugin.getLogger("dispatcher").info(`events queue is empty, no need to prepare`);
+      return;
+    }
+    const logger = this.plugin.getLogger(event[0].id);
+    logger.info(`preparing execution for event`);
+    try {
+      const execution = await this.createExecution(...event);
+      if ((execution == null ? void 0 : execution.status) === import_constants.EXECUTION_STATUS.QUEUEING) {
+        if (!this.executing && !this.pending.length) {
+          logger.info(`local pending list is empty, adding execution (${execution.id}) to pending list`);
+          this.pending.push({ execution });
+        } else {
+          logger.info(`local pending list is not empty, sending execution (${execution.id}) to queue`);
+          if (this.ready) {
+            this.plugin.app.backgroundJobManager.publish(`${this.plugin.name}.pendingExecution`, {
+              executionId: execution.id
+            });
+          }
+        }
+      }
+    } catch (error) {
+      logger.error(`failed to create execution:`, { error });
+    }
+    if (this.events.length) {
+      await this.prepare();
+    } else {
+      this.plugin.getLogger("dispatcher").info("no more events need to be prepared, dispatching...");
+      if (this.executing) {
+        await this.executing;
+      }
+      this.dispatch();
+    }
+  };
+  async acquirePendingExecution(execution) {
+    const logger = this.plugin.getLogger(execution.workflowId);
+    const isolationLevel = this.plugin.db.options.dialect === "sqlite" ? [][0] : import_sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ;
+    let fetched = execution;
+    try {
+      await this.plugin.db.sequelize.transaction({ isolationLevel }, async (transaction) => {
+        const ExecutionModelClass = this.plugin.db.getModel("executions");
+        const [affected] = await ExecutionModelClass.update(
+          { status: import_constants.EXECUTION_STATUS.STARTED },
+          {
+            where: {
+              id: execution.id,
+              status: {
+                [import_database.Op.is]: import_constants.EXECUTION_STATUS.QUEUEING
+              }
+            },
+            transaction
+          }
+        );
+        if (!affected) {
+          fetched = null;
+          return;
+        }
+        await execution.reload({ transaction });
+      });
+    } catch (error) {
+      logger.error(`acquiring pending execution failed: ${error.message}`, { error });
+    }
+    return fetched;
+  }
+  async acquireQueueingExecution() {
+    const isolationLevel = this.plugin.db.options.dialect === "sqlite" ? [][0] : import_sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ;
+    let fetched = null;
+    try {
+      await this.plugin.db.sequelize.transaction(
+        {
+          isolationLevel
+        },
+        async (transaction) => {
+          const execution = await this.plugin.db.getRepository("executions").findOne({
+            filter: {
+              status: {
+                [import_database.Op.is]: import_constants.EXECUTION_STATUS.QUEUEING
+              },
+              "workflow.enabled": true
+            },
+            sort: "id",
+            transaction
+          });
+          if (execution) {
+            this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
+            await execution.update(
+              {
+                status: import_constants.EXECUTION_STATUS.STARTED
+              },
+              { transaction }
+            );
+            execution.workflow = this.plugin.enabledCache.get(execution.workflowId);
+            fetched = execution;
+          } else {
+            this.plugin.getLogger("dispatcher").debug(`no execution in db queued to process`);
+          }
+        }
+      );
+    } catch (error) {
+      this.plugin.getLogger("dispatcher").error(`fetching execution from db failed: ${error.message}`, { error });
+    }
+    return fetched;
+  }
+  async process(execution, job, options = {}) {
+    var _a, _b;
+    const logger = this.plugin.getLogger(execution.workflowId);
+    if (execution.status === import_constants.EXECUTION_STATUS.QUEUEING) {
+      const transaction = await this.plugin.useDataSourceTransaction("main", options.transaction);
+      await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED }, { transaction });
+      logger.info(`execution (${execution.id}) from pending list updated to started`);
+    }
+    const processor = this.plugin.createProcessor(execution, options);
+    logger.info(`execution (${execution.id}) ${job ? "resuming" : "starting"}...`);
+    try {
+      await (job ? processor.resume(job) : processor.start());
+      logger.info(`execution (${execution.id}) finished with status: ${execution.status}`, { execution });
+      if (execution.status && ((_b = (_a = execution.workflow.options) == null ? void 0 : _a.deleteExecutionOnStatus) == null ? void 0 : _b.includes(execution.status))) {
+        await execution.destroy({ transaction: processor.mainTransaction });
+      }
+    } catch (err) {
+      logger.error(`execution (${execution.id}) error: ${err.message}`, err);
+    }
+    return processor;
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORKER_JOB_WORKFLOW_PROCESS
+});

package/dist/server/Plugin.d.ts

@@ -11,37 +11,23 @@ import { Transactionable } from 'sequelize';
 import { Plugin } from '@nocobase/server';
 import { Registry } from '@nocobase/utils';
 import { Logger } from '@nocobase/logger';
+import Dispatcher, { EventOptions } from './Dispatcher';
 import Processor from './Processor';
 import { CustomFunction } from './functions';
 import Trigger from './triggers';
 import { InstructionInterface } from './instructions';
-import type { ExecutionModel, JobModel, WorkflowModel } from './types';
+import type { ExecutionModel, WorkflowModel } from './types';
 type ID = number | string;
-export type EventOptions = {
-    eventKey?: string;
-    context?: any;
-    deferred?: boolean;
-    manually?: boolean;
-    force?: boolean;
-    stack?: Array<ID>;
-    onTriggerFail?: Function;
-    [key: string]: any;
-} & Transactionable;
 export default class PluginWorkflowServer extends Plugin {
     instructions: Registry<InstructionInterface>;
     triggers: Registry<Trigger>;
     functions: Registry<CustomFunction>;
     enabledCache: Map<number, WorkflowModel>;
     snowflake: Snowflake;
-    private ready;
-    private executing;
-    private pending;
-    private events;
-    private eventsCount;
+    private dispatcher;
     private loggerCache;
     private meter;
     private checker;
-    private onQueueExecution;
     private onBeforeSave;
     private onAfterCreate;
     private onAfterUpdate;
@@ -74,20 +60,14 @@ export default class PluginWorkflowServer extends Plugin {
     load(): Promise<void>;
     private toggle;
     trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null>;
-    private triggerSync;
-    run(execution: ExecutionModel, job?: JobModel): Promise<void>;
+    run(pending: Parameters<Dispatcher['run']>[0]): Promise<void>;
     resume(job: any): Promise<void>;
     /**
      * Start a deferred execution
      * @experimental
      */
     start(execution: ExecutionModel): Promise<void>;
-    private validateEvent;
-    private createExecution;
-    private prepare;
-    private dispatch;
     createProcessor(execution: ExecutionModel, options?: {}): Processor;
-    private process;
     execute(workflow: WorkflowModel, values: any, options?: EventOptions): Promise<void | Processor>;
     /**
      * @experimental