@nocobase/plugin-workflow 2.1.30 → 2.1.32

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.32",
   "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": "737a1324f650d7bc66594203b68eb0180553a551",
   "keywords": [
     "Workflow"
   ]