@nocobase/plugin-workflow 2.1.30 → 2.1.31

package/dist/externalVersion.js

@@ -11,8 +11,8 @@ module.exports = {
   "react": "18.2.0",
   "@formily/core": "2.3.7",
   "@formily/react": "2.3.7",
-  "@nocobase/client": "2.1.30",
-  "@nocobase/utils": "2.1.30",
+  "@nocobase/client": "2.1.31",
+  "@nocobase/utils": "2.1.31",
   "antd": "5.24.2",
   "@ant-design/icons": "5.6.1",
   "react-router-dom": "6.30.1",
@@ -20,20 +20,20 @@ module.exports = {
   "lodash": "4.18.1",
   "@dnd-kit/core": "6.1.0",
   "@formily/shared": "2.3.7",
-  "@nocobase/flow-engine": "2.1.30",
-  "@nocobase/plugin-mobile": "2.1.30",
+  "@nocobase/flow-engine": "2.1.31",
+  "@nocobase/plugin-mobile": "2.1.31",
   "sequelize": "6.35.2",
-  "@nocobase/server": "2.1.30",
-  "@nocobase/database": "2.1.30",
-  "@nocobase/data-source-manager": "2.1.30",
-  "@nocobase/logger": "2.1.30",
-  "@nocobase/evaluators": "2.1.30",
+  "@nocobase/server": "2.1.31",
+  "@nocobase/database": "2.1.31",
+  "@nocobase/data-source-manager": "2.1.31",
+  "@nocobase/logger": "2.1.31",
+  "@nocobase/evaluators": "2.1.31",
   "@formily/antd-v5": "1.2.3",
   "@formily/reactive": "2.3.7",
   "@emotion/css": "11.13.0",
   "@formily/json-schema": "2.3.7",
-  "@nocobase/actions": "2.1.30",
+  "@nocobase/actions": "2.1.31",
   "dayjs": "1.11.13",
-  "@nocobase/plugin-workflow-test": "2.1.30",
-  "@nocobase/test": "2.1.30"
+  "@nocobase/plugin-workflow-test": "2.1.31",
+  "@nocobase/test": "2.1.31"
 };

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":"2026-07-24T00:53:30.365Z"}
+{"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":"2026-07-27T15:40:38.691Z"}

package/dist/node_modules/joi/package.json

@@ -1 +1 @@
-{"name":"joi","description":"Object schema validation","version":"17.13.3","repository":"git://github.com/hapijs/joi","main":"lib/index.js","types":"lib/index.d.ts","browser":"dist/joi-browser.min.js","files":["lib/**/*","dist/*"],"keywords":["schema","validation"],"dependencies":{"@hapi/hoek":"^9.3.0","@hapi/topo":"^5.1.0","@sideway/address":"^4.1.5","@sideway/formula":"^3.0.1","@sideway/pinpoint":"^2.0.0"},"devDependencies":{"@hapi/bourne":"2.x.x","@hapi/code":"8.x.x","@hapi/joi-legacy-test":"npm:@hapi/joi@15.x.x","@hapi/lab":"^25.1.3","@types/node":"^14.18.63","typescript":"4.3.x"},"scripts":{"prepublishOnly":"cd browser && npm install && npm run build","test":"lab -t 100 -a @hapi/code -L -Y","test-cov-html":"lab -r html -o coverage.html -a @hapi/code"},"license":"BSD-3-Clause","_lastModified":"2026-07-24T00:53:30.097Z"}
+{"name":"joi","description":"Object schema validation","version":"17.13.3","repository":"git://github.com/hapijs/joi","main":"lib/index.js","types":"lib/index.d.ts","browser":"dist/joi-browser.min.js","files":["lib/**/*","dist/*"],"keywords":["schema","validation"],"dependencies":{"@hapi/hoek":"^9.3.0","@hapi/topo":"^5.1.0","@sideway/address":"^4.1.5","@sideway/formula":"^3.0.1","@sideway/pinpoint":"^2.0.0"},"devDependencies":{"@hapi/bourne":"2.x.x","@hapi/code":"8.x.x","@hapi/joi-legacy-test":"npm:@hapi/joi@15.x.x","@hapi/lab":"^25.1.3","@types/node":"^14.18.63","typescript":"4.3.x"},"scripts":{"prepublishOnly":"cd browser && npm install && npm run build","test":"lab -t 100 -a @hapi/code -L -Y","test-cov-html":"lab -r html -o coverage.html -a @hapi/code"},"license":"BSD-3-Clause","_lastModified":"2026-07-27T15:40:38.384Z"}

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":"11.3.5","author":"Isaac Z. Schlueter <i@izs.me>","keywords":["mru","lru","cache"],"sideEffects":false,"scripts":{"build":"npm run prepare","prepare":"tshy && bash scripts/build.sh","pretest":"npm run prepare","presnap":"npm run prepare","test":"tap","snap":"tap","preversion":"npm test","postversion":"npm publish","prepublishOnly":"git push origin --follow-tags","format":"prettier --write .","typedoc":"typedoc --tsconfig ./.tshy/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","lint":"oxlint --fix src test","postsnap":"npm run lint","postlint":"npm run format"},"main":"./dist/commonjs/index.min.js","types":"./dist/commonjs/index.d.ts","tshy":{"esmDialects":["node","browser"],"exports":{"./raw":"./src/index.ts",".":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.min.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.min.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.min.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.min.js"}}},"selfLink":false},"repository":{"type":"git","url":"git+ssh://git@github.com/isaacs/node-lru-cache.git"},"devDependencies":{"benchmark":"^2.1.4","esbuild":"^0.25.9","marked":"^4.2.12","mkdirp":"^3.0.1","oxlint":"^1.58.0","oxlint-tsgolint":"^0.19.0","prettier":"^3.8.1","tap":"^21.6.3","tshy":"^4.1.1","typedoc":"^0.28.18"},"license":"BlueOak-1.0.0","files":["dist"],"engines":{"node":"20 || >=22"},"exports":{"./raw":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.js"}},".":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.min.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.min.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.min.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.min.js"}}},"type":"module","module":"./dist/esm/index.min.js","_lastModified":"2026-07-24T00:53:29.314Z"}
+{"name":"lru-cache","description":"A cache object that deletes the least-recently-used items.","version":"11.3.5","author":"Isaac Z. Schlueter <i@izs.me>","keywords":["mru","lru","cache"],"sideEffects":false,"scripts":{"build":"npm run prepare","prepare":"tshy && bash scripts/build.sh","pretest":"npm run prepare","presnap":"npm run prepare","test":"tap","snap":"tap","preversion":"npm test","postversion":"npm publish","prepublishOnly":"git push origin --follow-tags","format":"prettier --write .","typedoc":"typedoc --tsconfig ./.tshy/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","lint":"oxlint --fix src test","postsnap":"npm run lint","postlint":"npm run format"},"main":"./dist/commonjs/index.min.js","types":"./dist/commonjs/index.d.ts","tshy":{"esmDialects":["node","browser"],"exports":{"./raw":"./src/index.ts",".":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.min.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.min.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.min.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.min.js"}}},"selfLink":false},"repository":{"type":"git","url":"git+ssh://git@github.com/isaacs/node-lru-cache.git"},"devDependencies":{"benchmark":"^2.1.4","esbuild":"^0.25.9","marked":"^4.2.12","mkdirp":"^3.0.1","oxlint":"^1.58.0","oxlint-tsgolint":"^0.19.0","prettier":"^3.8.1","tap":"^21.6.3","tshy":"^4.1.1","typedoc":"^0.28.18"},"license":"BlueOak-1.0.0","files":["dist"],"engines":{"node":"20 || >=22"},"exports":{"./raw":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.js"}},".":{"import":{"node":{"types":"./dist/esm/node/index.d.ts","default":"./dist/esm/node/index.min.js"},"browser":{"types":"./dist/esm/browser/index.d.ts","default":"./dist/esm/browser/index.min.js"},"types":"./dist/esm/index.d.ts","default":"./dist/esm/index.min.js"},"require":{"types":"./dist/commonjs/index.d.ts","default":"./dist/commonjs/index.min.js"}}},"type":"module","module":"./dist/esm/index.min.js","_lastModified":"2026-07-27T15:40:37.569Z"}

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":"2026-07-24T00:53:29.141Z"}
+{"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":"2026-07-27T15:40:37.383Z"}

package/dist/server/Dispatcher.d.ts

@@ -9,14 +9,21 @@
 import { Transactionable } from 'sequelize';
 import type { QueueEventOptions } from '@nocobase/server';
 import Processor, { ProcessorRerunOptions } from './Processor';
-import type { ExecutionModel, JobModel, WorkflowModel } from './types';
+import type { WorkflowModel } from './types';
 import type PluginWorkflowServer from './Plugin';
-type Pending = {
-    execution: ExecutionModel;
-    job?: JobModel;
-    immediate?: boolean;
-    rerun?: ProcessorRerunOptions;
-    dispatchAttempts?: number;
+type ID = number | string;
+type WorkflowQueueTask = {
+    executionId: ID;
+    jobId?: never;
+    rerun?: never;
+} | {
+    executionId: ID;
+    jobId: ID;
+    rerun?: never;
+} | {
+    executionId: ID;
+    jobId?: never;
+    rerun: ProcessorRerunOptions;
 };
 export type EventOptions = {
     eventKey?: string;
@@ -33,22 +40,26 @@ export default class Dispatcher {
     private readonly plugin;
     private ready;
     private executing;
+    private recovering;
     private saving;
-    private pending;
     private events;
     private eventsCount;
     get idle(): boolean;
     constructor(plugin: PluginWorkflowServer);
-    readonly onQueueExecution: QueueEventOptions['process'];
+    readonly onQueueTask: QueueEventOptions['process'];
     setReady(ready: boolean): void;
     getEventsCount(): number;
     trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null | void>;
     private saveEvent;
-    resume(job: JobModel): Promise<void>;
-    start(execution: ExecutionModel): Promise<void>;
     beforeStop(): Promise<void>;
-    dispatch(): void;
-    run(pending: Pending): Promise<void>;
+    recover(options?: {
+        gracePeriod?: number;
+    }): Promise<void>;
+    private recoverQueueTasks;
+    enqueue(task: WorkflowQueueTask): Promise<void>;
+    private loadJob;
+    private findQueueingExecutions;
+    private resolveTask;
     private triggerSync;
     private validateEvent;
     private handleTriggerFail;

package/dist/server/Dispatcher.js

@@ -35,30 +35,52 @@ var import_constants = require("./constants");
 var import_Plugin = require("./Plugin");
 var import_utils = require("./utils");
 const EXECUTION_ACQUIRE_MAX_ATTEMPTS = 5;
-const PENDING_DISPATCH_MAX_ATTEMPTS = 3;
+const QUEUE_TASK_MAX_ATTEMPTS = 3;
+const RECOVERY_BATCH_SIZE = 100;
+const RECOVERY_LOCK_TTL = 3e5;
 class Dispatcher {
   constructor(plugin) {
     this.plugin = plugin;
   }
   ready = false;
   executing = null;
+  recovering = null;
   saving = null;
-  pending = [];
   events = [];
   eventsCount = 0;
   get idle() {
-    return this.ready && !this.executing && !this.saving && !this.pending.length && !this.events.length;
+    return this.ready && !this.executing && !this.saving && !this.events.length;
   }
-  onQueueExecution = async (event) => {
-    const ExecutionRepo = this.plugin.db.getRepository("executions");
-    const execution = await ExecutionRepo.findOne({
-      filterByTk: event.executionId
-    });
-    if (!execution || execution.dispatched || execution.status !== import_constants.EXECUTION_STATUS.QUEUEING) {
-      return;
+  onQueueTask = async (event) => {
+    var _a;
+    const task = event;
+    let next = null;
+    const previous = this.executing;
+    const executing = (async () => {
+      await (previous == null ? void 0 : previous.catch(() => void 0));
+      this.plugin.getLogger("dispatcher").info(`workflow queue task for execution (${task.executionId}) received from queue`);
+      next = await this.resolveTask(task);
+      if (!next) {
+        return;
+      }
+      this.plugin.getLogger(next[0].workflowId).info(`queued execution (${next[0].id}) ready to process`);
+      await this.process(next[0], next[1], { rerun: next[2] });
+    })();
+    this.executing = executing;
+    try {
+      await executing;
+    } catch (error) {
+      const workflowId = ((_a = next == null ? void 0 : next[0]) == null ? void 0 : _a.workflowId) ?? task.executionId;
+      this.plugin.getLogger(workflowId).error(`workflow queue task failed`, { error });
+      throw error;
+    } finally {
+      if (this.executing === executing) {
+        this.executing = null;
+      }
+      if (this.events.length) {
+        this.saveEvent();
+      }
     }
-    this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) received from queue, adding to pending list`);
-    await this.run({ execution });
   };
   setReady(ready) {
     this.ready = ready;
@@ -118,20 +140,12 @@ class Dispatcher {
           try {
             const execution = await this.createExecution(...event);
             if (!execution.dispatched) {
-              if (this.plugin.serving() && !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(
-                  `instance is not serving as worker or local pending list is not empty, sending execution (${execution.id}) to queue`
-                );
-                try {
-                  await this.plugin.app.eventQueue.publish(this.plugin.channelPendingExecution, {
-                    executionId: execution.id
-                  });
-                } catch (qErr) {
-                  logger.error(`publishing execution (${execution.id}) to queue failed:`, { error: qErr });
-                }
+              try {
+                await this.enqueue({
+                  executionId: execution.id
+                });
+              } catch (qErr) {
+                logger.error(`publishing execution (${execution.id}) to queue failed:`, { error: qErr });
               }
             }
           } catch (error) {
@@ -142,31 +156,17 @@ class Dispatcher {
         this.saving = null;
         if (this.events.length) {
           this.saveEvent();
-        } else {
-          this.dispatch();
         }
       }
     })();
   }
-  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`);
-    await this.run({ execution, job });
-  }
-  async start(execution) {
-    if (execution.status) {
-      return;
-    }
-    this.plugin.getLogger(execution.workflowId).info(`starting deferred execution (${execution.id})`);
-    await this.run({ execution });
-  }
   async beforeStop() {
     this.ready = false;
     this.plugin.getLogger("dispatcher").info("app is stopping, draining local queues...");
-    while (this.saving || this.executing || this.events.length || this.pending.length) {
+    if (this.recovering) {
+      await this.recovering;
+    }
+    while (this.saving || this.executing || this.events.length) {
       if (this.saving) {
         await this.saving;
       }
@@ -176,85 +176,131 @@ class Dispatcher {
       if (this.events.length && !this.saving) {
         this.saveEvent();
       }
-      if (this.pending.length && !this.executing) {
-        this.dispatch();
-      }
       await new Promise((resolve) => setImmediate(resolve));
     }
     this.plugin.getLogger("dispatcher").info("local queues drained");
   }
-  dispatch() {
-    if (!this.ready && !this.pending.length && !this.events.length) {
+  async recover(options = {}) {
+    if (!this.ready) {
       return;
     }
-    if (this.executing) {
-      this.plugin.getLogger("dispatcher").warn(`workflow executing is not finished, new dispatching will be ignored`);
+    if (this.recovering) {
+      await this.recovering;
       return;
     }
-    if (this.events.length) {
-      this.saveEvent();
-      return;
+    const recovering = this.recoverQueueTasks(options.gracePeriod ?? 0);
+    this.recovering = recovering;
+    try {
+      await recovering;
+    } finally {
+      if (this.recovering === recovering) {
+        this.recovering = null;
+      }
     }
-    this.executing = (async () => {
-      let next = null;
-      let pending = null;
+  }
+  async recoverQueueTasks(gracePeriod) {
+    const logger = this.plugin.getLogger("dispatcher");
+    try {
+      if (!this.plugin.serving()) {
+        logger.warn(
+          `${import_Plugin.WORKER_JOB_WORKFLOW_PROCESS} is not serving on this instance, workflow queue recovery will be ignored`
+        );
+        return;
+      }
+      let lock;
       try {
-        pending = this.pending.shift() ?? null;
-        if (pending || this.ready && this.plugin.serving()) {
-          const execution = await this.prepare((pending == null ? void 0 : pending.execution) ?? null, {
-            immediate: pending == null ? void 0 : pending.immediate
-          });
-          if (execution) {
-            next = [execution, pending == null ? void 0 : pending.job, pending == null ? void 0 : pending.rerun];
-          }
-          if (pending && next) {
-            this.plugin.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
-          }
-        } else {
-          this.plugin.getLogger("dispatcher").warn(
-            `${import_Plugin.WORKER_JOB_WORKFLOW_PROCESS} is not serving on this instance or app not ready, new dispatching will be ignored`
-          );
+        lock = await this.plugin.app.lockManager.tryAcquire(`workflow:recover:${this.plugin.app.name}`);
+      } catch (error) {
+        if ((0, import_utils.isLockAcquireError)(error)) {
+          logger.debug(`workflow queue recovery is already running on another instance`);
+          return;
         }
-        if (next) {
-          try {
-            await this.process(next[0], next[1], { rerun: next[2] });
-          } catch (error) {
-            this.plugin.getLogger(next[0].workflowId).error(`execution (${next[0].id}) process failed`, { error });
-            if (pending && (0, import_utils.isLockAcquireError)(error)) {
-              this.pending.unshift({ ...pending, execution: next[0], immediate: true });
-            }
+        throw error;
+      }
+      await lock.runExclusive(async () => {
+        let executionCursor = null;
+        while (this.ready) {
+          const executions = await this.findQueueingExecutions(executionCursor, gracePeriod);
+          if (!executions.length) {
+            break;
           }
-        }
-      } catch (error) {
-        this.plugin.getLogger("dispatcher").error(`workflow dispatch failed`, { error });
-        if (pending) {
-          const dispatchAttempts = (pending.dispatchAttempts ?? 0) + 1;
-          if (dispatchAttempts < PENDING_DISPATCH_MAX_ATTEMPTS) {
-            this.pending.push({ ...pending, dispatchAttempts });
-          } else {
-            this.plugin.getLogger(pending.execution.workflowId).error(`pending execution (${pending.execution.id}) dispatch failed, local retry limit reached`, {
-              error,
-              dispatchAttempts
-            });
+          for (const execution of executions) {
+            if (!this.ready) {
+              return;
+            }
+            await this.enqueue({ executionId: execution.id });
           }
+          executionCursor = executions[executions.length - 1].id;
         }
-      } finally {
-        setImmediate(() => {
-          this.executing = null;
-          if (next || this.pending.length) {
-            this.plugin.getLogger("dispatcher").debug(`last process finished, will do another dispatch`);
-            this.dispatch();
-          }
-        });
-      }
-    })();
+      }, RECOVERY_LOCK_TTL);
+    } catch (error) {
+      logger.error(`workflow queue recovery failed`, { error });
+    }
+  }
+  async enqueue(task) {
+    await this.plugin.app.eventQueue.publish(this.plugin.channelPendingExecution, task, {
+      maxRetries: QUEUE_TASK_MAX_ATTEMPTS - 1
+    });
   }
-  async run(pending) {
-    this.pending.push({
-      ...pending,
-      immediate: !this.executing && !this.pending.length && !this.saving && !this.events.length
+  async loadJob(jobId) {
+    if (jobId == null) {
+      return null;
+    }
+    return this.plugin.db.getRepository("jobs").findOne({
+      filterByTk: jobId
     });
-    this.dispatch();
+  }
+  async findQueueingExecutions(afterId, gracePeriod) {
+    const executions = await this.plugin.db.getRepository("executions").find({
+      filter: {
+        ...afterId == null ? {} : { id: { $gt: afterId } },
+        ...gracePeriod > 0 ? { createdAt: { $lt: new Date(Date.now() - gracePeriod) } } : {},
+        dispatched: false,
+        status: import_constants.EXECUTION_STATUS.QUEUEING,
+        startedAt: null,
+        "workflow.enabled": true
+      },
+      sort: "id",
+      limit: RECOVERY_BATCH_SIZE
+    });
+    for (const execution of executions) {
+      this.plugin.getLogger(execution.workflowId).info(`queueing execution (${execution.id}) found, publishing task`);
+    }
+    return executions;
+  }
+  async resolveTask(task) {
+    const executionInput = await this.plugin.db.getRepository("executions").findOne({
+      filterByTk: task.executionId
+    });
+    if (!executionInput) {
+      this.plugin.getLogger("dispatcher").warn(`execution (${task.executionId}) not found, queue task ignored`);
+      return null;
+    }
+    if (task.jobId == null && task.rerun == null && executionInput.status === import_constants.EXECUTION_STATUS.STARTED && executionInput.startedAt) {
+      this.plugin.getLogger(executionInput.workflowId).warn(`execution (${executionInput.id}) has already started, start task ignored`);
+      return null;
+    }
+    let job = null;
+    if (task.jobId != null) {
+      job = await this.loadJob(task.jobId);
+      if (!job) {
+        this.plugin.getLogger(executionInput.workflowId).warn(`job (${task.jobId}) not found, resume ignored`);
+        return null;
+      }
+      if (String(job.executionId) !== String(executionInput.id)) {
+        this.plugin.getLogger(executionInput.workflowId).warn(`job (${job.id}) does not belong to execution (${executionInput.id}), resume ignored`);
+        return null;
+      }
+    }
+    const execution = await this.prepare(executionInput);
+    if (!execution) {
+      return null;
+    }
+    if (job) {
+      job.execution = execution;
+      return [execution, job];
+    }
+    return [execution, void 0, task.rerun];
   }
   async triggerSync(workflow, context, { deferred, ...options } = {}) {
     let execution;
@@ -367,7 +413,7 @@ class Dispatcher {
     return execution;
   }
   async prepare(input, options = {}) {
-    const logger = input ? this.plugin.getLogger(input.workflowId) : this.plugin.getLogger("dispatcher");
+    const logger = this.plugin.getLogger(input.workflowId);
     if (options.transaction) {
       try {
         return await this.acquireExecution(input, options, options.transaction);
@@ -402,8 +448,8 @@ class Dispatcher {
         },
         {
           logger,
-          conflictMessage: input ? `acquiring pending execution (${input.id}) conflicted with another worker, retrying` : `acquiring execution conflicted with another worker, retrying`,
-          maxAttemptsMessage: input ? `acquiring pending execution (${input.id}) reached max retry attempts` : `acquiring execution reached max retry attempts, will retry on next dispatch`
+          conflictMessage: `acquiring queue task execution (${input.id}) conflicted with another worker, retrying`,
+          maxAttemptsMessage: `acquiring queue task execution (${input.id}) reached max retry attempts`
         }
       );
     } catch (error) {
@@ -415,39 +461,10 @@ class Dispatcher {
     return result;
   }
   async acquireExecution(input, options, transaction) {
-    let execution = input;
-    if (execution) {
-      if (!options.immediate || execution.status !== import_constants.EXECUTION_STATUS.QUEUEING) {
-        await execution.reload({ transaction });
-      }
-    } else {
-      const workflowIds = [...this.plugin.enabledCache.keys()];
-      if (!workflowIds.length) {
-        this.plugin.getLogger("dispatcher").debug(`no enabled workflow to process`);
-        return null;
-      }
-      execution = await this.plugin.db.getRepository("executions").findOne({
-        filter: {
-          dispatched: false,
-          status: import_constants.EXECUTION_STATUS.QUEUEING,
-          startedAt: null,
-          workflowId: workflowIds
-        },
-        sort: "id",
-        transaction,
-        lock: transaction.LOCK.UPDATE,
-        skipLocked: true
-      });
-      if (execution) {
-        this.plugin.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
-      } else {
-        this.plugin.getLogger("dispatcher").debug(`no execution in db queued to process`);
-      }
-    }
-    if (!execution) {
-      return null;
+    if (!options.immediate || input.status !== import_constants.EXECUTION_STATUS.QUEUEING) {
+      await input.reload({ transaction });
     }
-    return this.enter(execution, transaction);
+    return this.enter(input, transaction);
   }
   async acquireWithRetry(acquire, options) {
     for (let attempt = 1; attempt <= EXECUTION_ACQUIRE_MAX_ATTEMPTS; attempt++) {
@@ -528,7 +545,7 @@ class Dispatcher {
       var _a, _b, _c;
       if (!execution.dispatched) {
         await execution.update({ dispatched: true, status: import_constants.EXECUTION_STATUS.STARTED });
-        logger.info(`execution (${execution.id}) from pending list updated to started`);
+        logger.info(`execution (${execution.id}) from workflow queue updated to started`);
       }
       this.plugin.timeoutManager.scheduleExecutionTimeout(execution);
       const processor = this.plugin.createProcessor(execution, processorOptions);

package/dist/server/Plugin.d.ts

@@ -11,14 +11,14 @@ 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 { EventOptions } from './Dispatcher';
+import Processor, { ProcessorRerunOptions } from './Processor';
 import ExecutionTimeoutManager from './ExecutionTimeoutManager';
 import RunningExecutionRegistry from './RunningExecutionRegistry';
 import { CustomFunction } from './functions';
 import Trigger from './triggers';
 import { InstructionInterface } from './instructions';
-import type { ExecutionModel, WorkflowModel } from './types';
+import type { ExecutionModel, JobModel, WorkflowModel } from './types';
 import type { Transaction } from '@nocobase/database';
 type ID = number | string;
 export declare const WORKER_JOB_WORKFLOW_PROCESS = "workflow:process";
@@ -75,15 +75,24 @@ export default class PluginWorkflowServer extends Plugin {
     load(): Promise<void>;
     private toggle;
     trigger(workflow: WorkflowModel, context: object, options?: EventOptions): void | Promise<Processor | null | void>;
-    run(pending: Parameters<Dispatcher['run']>[0]): Promise<void>;
-    dispatch(): void;
-    resume(job: any): Promise<void>;
+    rerun(execution: ExecutionModel | ID, rerun?: ProcessorRerunOptions): Promise<void>;
+    recover(): Promise<void>;
+    /**
+     * Persist the current job state and publish a poke that evaluates that state.
+     *
+     * PENDING resume calls are valid for instructions such as delay and sequential approval.
+     * Callers that aggregate multiple user actions must only call this method when their
+     * atomic update changes the job from PENDING to a terminal status.
+     * Persistence and queue publication failures are logged and rethrown to awaiting callers.
+     */
+    resume(job: JobModel): Promise<void>;
     /**
      * Start a deferred execution
      * @experimental
      */
-    start(execution: ExecutionModel): Promise<void>;
+    start(execution: ExecutionModel | ID): Promise<void>;
     createProcessor(execution: ExecutionModel, options?: {}): Processor;
+    private getModelId;
     execute(workflow: WorkflowModel, values: any, options?: EventOptions): Promise<void | Processor>;
     /**
      * @experimental

package/dist/server/Plugin.js

@@ -53,6 +53,7 @@ var import_RunningExecutionRegistry = __toESM(require("./RunningExecutionRegistr
 var import_actions = __toESM(require("./actions"));
 var import_nodes = require("./actions/nodes");
 var import_workflows = require("./actions/workflows");
+var import_constants = require("./constants");
 var import_functions = __toESM(require("./functions"));
 var import_CollectionTrigger = __toESM(require("./triggers/CollectionTrigger"));
 var import_ScheduleTrigger = __toESM(require("./triggers/ScheduleTrigger"));
@@ -170,16 +171,16 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     }
     this.checker = setInterval(() => {
-      this.dispatcher.dispatch();
+      this.dispatcher.recover({ gracePeriod: 6e4 });
     }, 3e5);
     await this.timeoutManager.load();
-    this.app.on("workflow:dispatch", () => {
-      this.app.logger.info("workflow:dispatch");
-      this.dispatcher.dispatch();
+    this.app.on("workflow:recover", () => {
+      this.app.logger.info("workflow:recover");
+      this.dispatcher.recover();
     });
     this.dispatcher.setReady(true);
     this.getLogger("dispatcher").info("(starting) check for queueing executions");
-    this.dispatcher.dispatch();
+    this.dispatcher.recover();
   };
   onBeforeStop = async () => {
     if (this.checker) {
@@ -191,7 +192,6 @@ class PluginWorkflowServer extends import_server.Plugin {
     for (const workflow of this.enabledCache.values()) {
       this.toggle(workflow, false, { silent: true });
     }
-    this.app.eventQueue.unsubscribe(this.channelPendingExecution);
     this.loggerCache.clear();
   };
   async handleSyncMessage(message) {
@@ -401,7 +401,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     this.app.on("beforeStop", this.onBeforeStop);
     this.app.eventQueue.subscribe(this.channelPendingExecution, {
       idle: () => this.serving() && this.dispatcher.idle,
-      process: this.dispatcher.onQueueExecution
+      process: this.dispatcher.onQueueTask
     });
   }
   toggle(workflow, enable, { silent, transaction } = {}) {
@@ -448,25 +448,70 @@ class PluginWorkflowServer extends import_server.Plugin {
   trigger(workflow, context, options = {}) {
     return this.dispatcher.trigger(workflow, context, options);
   }
-  async run(pending) {
-    return this.dispatcher.run(pending);
+  async rerun(execution, rerun) {
+    return this.dispatcher.enqueue({ executionId: this.getModelId(execution), rerun: rerun ?? {} });
   }
-  dispatch() {
-    return this.dispatcher.dispatch();
+  recover() {
+    return this.dispatcher.recover();
   }
+  /**
+   * Persist the current job state and publish a poke that evaluates that state.
+   *
+   * PENDING resume calls are valid for instructions such as delay and sequential approval.
+   * Callers that aggregate multiple user actions must only call this method when their
+   * atomic update changes the job from PENDING to a terminal status.
+   * Persistence and queue publication failures are logged and rethrown to awaiting callers.
+   */
   async resume(job) {
-    return this.dispatcher.resume(job);
+    var _a;
+    const executionId = job.executionId ?? ((_a = job.execution) == null ? void 0 : _a.id);
+    if (executionId == null) {
+      this.getLogger("dispatcher").warn(`execution id of job (${job.id}) not found, resume ignored`);
+      return;
+    }
+    try {
+      if (job.changed()) {
+        await job.save();
+      }
+    } catch (error) {
+      this.getLogger("dispatcher").error(
+        `persisting job (${job.id}) before resuming execution (${executionId}) failed`,
+        { error, executionId, jobId: job.id }
+      );
+      throw error;
+    }
+    try {
+      await this.dispatcher.enqueue({ executionId, jobId: job.id });
+      this.getLogger("dispatcher").info(`execution (${executionId}) resuming from job (${job.id}) published to queue`);
+    } catch (error) {
+      this.getLogger("dispatcher").error(
+        `publishing resume task for execution (${executionId}) from job (${job.id}) failed`,
+        { error, executionId, jobId: job.id }
+      );
+      throw error;
+    }
   }
   /**
    * Start a deferred execution
    * @experimental
    */
   async start(execution) {
-    return this.dispatcher.start(execution);
+    if (typeof execution !== "string" && typeof execution !== "number") {
+      if (execution.status !== import_constants.EXECUTION_STATUS.QUEUEING && execution.status !== import_constants.EXECUTION_STATUS.STARTED && execution.status != null) {
+        return;
+      }
+      if (execution.status === import_constants.EXECUTION_STATUS.STARTED && execution.startedAt) {
+        return;
+      }
+    }
+    return this.dispatcher.enqueue({ executionId: this.getModelId(execution) });
   }
   createProcessor(execution, options = {}) {
     return new import_Processor.default(execution, { ...options, plugin: this });
   }
+  getModelId(input) {
+    return typeof input === "string" || typeof input === "number" ? input : input.id;
+  }
   async execute(workflow, values, options = {}) {
     const trigger = this.triggers.get(workflow.type);
     if (!trigger) {

package/dist/server/Processor.d.ts

@@ -94,13 +94,7 @@ export default class Processor {
     prepare(): Promise<void>;
     start(): Promise<any>;
     resume(job: JobModel): Promise<void>;
-    resolveRerun(options?: ProcessorRerunOptions): {
-        node: FlowNodeModel;
-        input: JobModel | {
-            result: any;
-        };
-        targetJob: JobModel;
-    };
+    private resolveRerun;
     rerun(options?: ProcessorRerunOptions): Promise<any>;
     private getRerunNode;
     private getRerunInput;

package/dist/server/actions/executions.js

@@ -98,12 +98,9 @@ async function rerun(context, next) {
   if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
     return context.throw(400, "Only started executions can be rerun");
   }
-  await workflowPlugin.run({
-    execution,
-    rerun: {
-      nodeId,
-      overwrite: overwrite === true
-    }
+  await workflowPlugin.rerun(execution, {
+    nodeId,
+    overwrite: overwrite === true
   });
   context.body = execution;
   context.status = 202;

package/dist/server/actions/jobs.js

@@ -82,8 +82,7 @@ async function resume(context, next) {
   context.body = job;
   context.status = 202;
   await next();
-  job.execution = execution;
-  workflowPlugin.resume(job);
+  await workflowPlugin.resume(job);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/types/Execution.d.ts

@@ -12,11 +12,13 @@ import WorkflowModel from './Workflow';
 export default class ExecutionModel extends Model {
     static readonly database: Database;
     id: number;
+    workflowId: number;
     title: string;
     context: any;
     status: number;
     reason?: string | null;
     dispatched: boolean;
+    manually?: boolean | null;
     parentExecutionId?: number | null;
     stack?: Array<number | string>;
     startedAt?: Date | null;

package/dist/server/types/Job.d.ts

@@ -8,8 +8,11 @@
  */
 import { BelongsToGetAssociationMixin, Model } from '@nocobase/database';
 import FlowNodeModel from './FlowNode';
+import ExecutionModel from './Execution';
 export default class JobModel extends Model {
     id: number;
+    executionId: number;
+    workflowId?: number;
     status: number;
     result?: any;
     meta?: any;
@@ -20,4 +23,6 @@ export default class JobModel extends Model {
     nodeId: number;
     node?: FlowNodeModel;
     getNode: BelongsToGetAssociationMixin<FlowNodeModel>;
+    execution?: ExecutionModel;
+    getExecution: BelongsToGetAssociationMixin<ExecutionModel>;
 }

package/dist/server/utils.d.ts

@@ -16,6 +16,7 @@ type AbortOptions = Transactionable & {
     reason?: (typeof EXECUTION_REASON)[keyof typeof EXECUTION_REASON];
 };
 export declare function getExecutionLockKey(executionId: number | string): string;
+export declare function getJobLockKey(jobId: number | string): string;
 export declare function isLockAcquireError(error: unknown): boolean;
 export declare function validateCollectionField(collection: string, dataSourceManager: DataSourceManager): Record<string, string> | null;
 export declare function getExecutionStatusName(status: number | null | undefined): string;

package/dist/server/utils.js

@@ -29,6 +29,7 @@ __export(utils_exports, {
   abortExecution: () => abortExecution,
   getExecutionLockKey: () => getExecutionLockKey,
   getExecutionStatusName: () => getExecutionStatusName,
+  getJobLockKey: () => getJobLockKey,
   getWorkflowExecutionLogMeta: () => getWorkflowExecutionLogMeta,
   isLockAcquireError: () => isLockAcquireError,
   toJSON: () => toJSON,
@@ -41,6 +42,9 @@ var import_constants = require("./constants");
 function getExecutionLockKey(executionId) {
   return `workflow:execution:${executionId}`;
 }
+function getJobLockKey(jobId) {
+  return `workflow:job:${jobId}`;
+}
 function isLockAcquireError(error) {
   return error instanceof Error && error.constructor.name === "LockAcquireError";
 }
@@ -197,6 +201,7 @@ function toJSON(data) {
   abortExecution,
   getExecutionLockKey,
   getExecutionStatusName,
+  getJobLockKey,
   getWorkflowExecutionLogMeta,
   isLockAcquireError,
   toJSON,

package/package.json

@@ -6,7 +6,7 @@
   "description": "A powerful BPM tool that provides foundational support for business automation, with the capability to extend unlimited triggers and nodes.",
   "description.zh-CN": "一个强大的 BPM 工具，为业务自动化提供基础支持，并且可任意扩展更多的触发器和节点。",
   "description.ru-RU": "Мощный инструмент BPM, обеспечивающий базовую поддержку автоматизации бизнес-процессов с возможностью неограниченного расширения триггеров и узлов.",
-  "version": "2.1.30",
+  "version": "2.1.31",
   "license": "Apache-2.0",
   "main": "./dist/server/index.js",
   "homepage": "https://docs.nocobase.com/handbook/workflow",
@@ -49,7 +49,7 @@
     "@nocobase/test": "2.x",
     "@nocobase/utils": "2.x"
   },
-  "gitHead": "c1a4bff0fd3c8b30e06fc6f50ad33e054b04061a",
+  "gitHead": "b5d46b76adb72b4fa736dd0e6c89d8a0bc83bfe8",
   "keywords": [
     "Workflow"
   ]