@nocobase/plugin-workflow 1.9.0-beta.8 → 2.0.0-alpha.2

package/dist/server/Plugin.js

@@ -40,16 +40,14 @@ __export(Plugin_exports, {
 });
 module.exports = __toCommonJS(Plugin_exports);
 var import_path = __toESM(require("path"));
-var import_crypto = require("crypto");
 var import_nodejs_snowflake = require("nodejs-snowflake");
-var import_sequelize = require("sequelize");
 var import_lru_cache = __toESM(require("lru-cache"));
 var import_database = require("@nocobase/database");
 var import_server = require("@nocobase/server");
 var import_utils = require("@nocobase/utils");
+var import_Dispatcher = __toESM(require("./Dispatcher"));
 var import_Processor = __toESM(require("./Processor"));
 var import_actions = __toESM(require("./actions"));
-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"));
@@ -61,37 +59,16 @@ var import_DestroyInstruction = __toESM(require("./instructions/DestroyInstructi
 var import_QueryInstruction = __toESM(require("./instructions/QueryInstruction"));
 var import_UpdateInstruction = __toESM(require("./instructions/UpdateInstruction"));
 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();
   functions = new import_utils.Registry();
   enabledCache = /* @__PURE__ */ new Map();
   snowflake;
-  ready = false;
-  executing = null;
-  pending = [];
-  events = [];
-  eventsCount = 0;
+  dispatcher = new import_Dispatcher.default(this);
   loggerCache;
   meter = null;
   checker = null;
-  onQueueExecution = async (event) => {
-    const ExecutionRepo = this.db.getRepository("executions");
-    const execution = await ExecutionRepo.findOne({
-      filterByTk: event.executionId
-    });
-    if (!execution || execution.dispatched) {
-      this.getLogger("dispatcher").info(
-        `execution (${event.executionId}) from queue not found or not in queueing status, skip`
-      );
-      return;
-    }
-    this.getLogger(execution.workflowId).info(
-      `execution (${execution.id}) received from queue, adding to pending list`
-    );
-    this.run(execution);
-  };
   onBeforeSave = async (instance, { transaction, cycling }) => {
     if (cycling) {
       return;
@@ -161,7 +138,7 @@ 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.ready = true;
+    this.dispatcher.setReady(true);
     const collection = this.db.getCollection("workflows");
     const workflows = await collection.repository.find({
       appends: ["versionStats"]
@@ -182,28 +159,22 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
     this.checker = setInterval(() => {
       this.getLogger("dispatcher").debug(`(cycling) check for queueing executions`);
-      this.dispatch();
+      this.dispatcher.dispatch();
     }, 3e5);
     this.app.on("workflow:dispatch", () => {
       this.app.logger.info("workflow:dispatch");
-      this.dispatch();
+      this.dispatcher.dispatch();
     });
     this.getLogger("dispatcher").info("(starting) check for queueing executions");
-    this.dispatch();
-    this.ready = true;
+    this.dispatcher.dispatch();
+    this.dispatcher.setReady(true);
   };
   onBeforeStop = async () => {
     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 });
     }
-    this.ready = false;
-    if (this.events.length) {
-      await this.prepare();
-    }
-    if (this.executing) {
-      await this.executing;
-    }
+    await this.dispatcher.beforeStop();
     if (this.checker) {
       clearInterval(this.checker);
     }
@@ -309,8 +280,8 @@ class PluginWorkflowServer extends import_server.Plugin {
       custom_epoch: pluginRecord == null ? void 0 : pluginRecord.createdAt.getTime()
     });
     this.app.backgroundJobManager.subscribe(`${this.name}.pendingExecution`, {
-      idle: () => this.app.serving(WORKER_JOB_WORKFLOW_PROCESS) && !this.executing && !this.pending.length && !this.events.length,
-      process: this.onQueueExecution
+      idle: () => this.app.serving(import_Dispatcher.WORKER_JOB_WORKFLOW_PROCESS) && this.dispatcher.idle,
+      process: this.dispatcher.onQueueExecution
     });
   }
   /**
@@ -332,7 +303,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     this.meter = this.app.telemetry.metric.getMeter();
     const counter = this.meter.createObservableGauge("workflow.events.counter");
     counter.addCallback((result) => {
-      result.observe(this.eventsCount);
+      result.observe(this.dispatcher.getEventsCount());
     });
     this.app.acl.registerSnippet({
       name: `pm.${this.name}.workflows`,
@@ -397,295 +368,24 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
   }
   trigger(workflow, context, options = {}) {
-    const logger = this.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.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);
+    return this.dispatcher.trigger(workflow, context, options);
   }
-  async triggerSync(workflow, context, { deferred, ...options } = {}) {
-    let execution;
-    try {
-      execution = await this.createExecution(workflow, context, options);
-    } catch (err) {
-      this.getLogger(workflow.id).error(`creating execution failed: ${err.message}`, err);
-      return null;
-    }
-    try {
-      return this.process(execution, null, options);
-    } catch (err) {
-      this.getLogger(execution.workflowId).error(`execution (${execution.id}) error: ${err.message}`, err);
-    }
-    return null;
-  }
-  async run(execution, job) {
-    while (this.executing) {
-      await this.executing;
-    }
-    this.executing = this.process(execution, job);
-    await this.executing;
-    this.executing = null;
-    this.dispatch();
+  async run(pending) {
+    return this.dispatcher.run(pending);
   }
   async resume(job) {
-    let { execution } = job;
-    if (!execution) {
-      execution = await job.getExecution();
-    }
-    this.getLogger(execution.workflowId).info(
-      `execution (${execution.id}) resuming from job (${job.id}) added to pending list`
-    );
-    this.run(execution, job);
+    return this.dispatcher.resume(job);
   }
   /**
    * Start a deferred execution
    * @experimental
    */
   async start(execution) {
-    if (execution.status) {
-      return;
-    }
-    this.getLogger(execution.workflowId).info(`starting deferred execution (${execution.id})`);
-    this.run(execution);
-  }
-  async validateEvent(workflow, context, options) {
-    const trigger = this.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.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.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,
-          dispatched: deferred ?? false
-        },
-        { transaction }
-      );
-    } catch (err) {
-      if (!sameTransaction) {
-        await transaction.rollback();
-      }
-      throw err;
-    }
-    this.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.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.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.db.options.dialect === "sqlite") {
-      await this.executing;
-    }
-    const event = this.events.shift();
-    this.eventsCount = this.events.length;
-    if (!event) {
-      this.getLogger("dispatcher").info(`events queue is empty, no need to prepare`);
-      return;
-    }
-    const logger = this.getLogger(event[0].id);
-    logger.info(`preparing execution for event`);
-    try {
-      const execution = await this.createExecution(...event);
-      if (!(execution == null ? void 0 : execution.dispatched)) {
-        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.app.backgroundJobManager.publish(`${this.name}.pendingExecution`, { executionId: execution.id });
-          }
-        }
-      }
-    } catch (error) {
-      logger.error(`failed to create execution:`, { error });
-    }
-    if (this.events.length) {
-      await this.prepare();
-    } else {
-      this.getLogger("dispatcher").info("no more events need to be prepared, dispatching...");
-      if (this.executing) {
-        await this.executing;
-      }
-      this.dispatch();
-    }
-  };
-  dispatch() {
-    if (!this.ready) {
-      this.getLogger("dispatcher").warn(`app is not ready, new dispatching will be ignored`);
-      return;
-    }
-    if (!this.app.serving(WORKER_JOB_WORKFLOW_PROCESS)) {
-      this.getLogger("dispatcher").warn(
-        `${WORKER_JOB_WORKFLOW_PROCESS} is not serving, new dispatching will be ignored`
-      );
-      return;
-    }
-    if (this.executing) {
-      this.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;
-      if (this.pending.length) {
-        next = this.pending.shift();
-        this.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
-      } else {
-        try {
-          await this.db.sequelize.transaction(
-            {
-              isolationLevel: this.db.options.dialect === "sqlite" ? [][0] : import_sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ
-            },
-            async (transaction) => {
-              const execution = await this.db.getRepository("executions").findOne({
-                filter: {
-                  dispatched: false,
-                  "workflow.enabled": true
-                },
-                sort: "id",
-                transaction
-              });
-              if (execution) {
-                this.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
-                await execution.update(
-                  {
-                    dispatched: true,
-                    status: import_constants.EXECUTION_STATUS.STARTED
-                  },
-                  { transaction }
-                );
-                execution.workflow = this.enabledCache.get(execution.workflowId);
-                next = [execution];
-              } else {
-                this.getLogger("dispatcher").debug(`no execution in db queued to process`);
-              }
-            }
-          );
-        } catch (error) {
-          this.getLogger("dispatcher").error(`fetching execution from db failed: ${error.message}`, { error });
-        }
-      }
-      if (next) {
-        await this.process(...next);
-      }
-      this.executing = null;
-      if (next || this.pending.length) {
-        this.getLogger("dispatcher").debug(`last process finished, will do another dispatch`);
-        this.dispatch();
-      }
-    })();
+    return this.dispatcher.start(execution);
   }
   createProcessor(execution, options = {}) {
     return new import_Processor.default(execution, { ...options, plugin: this });
   }
-  async process(execution, job, options = {}) {
-    var _a, _b;
-    const logger = this.getLogger(execution.workflowId);
-    if (!execution.dispatched) {
-      const transaction = await this.useDataSourceTransaction("main", options.transaction);
-      await execution.update({ dispatched: true, status: import_constants.EXECUTION_STATUS.STARTED }, { transaction });
-      logger.info(`execution (${execution.id}) from pending list updated to started`);
-    }
-    const processor = this.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;
-  }
   async execute(workflow, values, options = {}) {
     const trigger = this.triggers.get(workflow.type);
     if (!trigger) {

package/dist/server/index.d.ts

@@ -12,6 +12,7 @@ export * from './instructions';
 export * from './functions';
 export * from './logicCalculate';
 export { Trigger } from './triggers';
+export type { EventOptions } from './Dispatcher';
 export { default as Processor } from './Processor';
-export { default, EventOptions } from './Plugin';
+export { default } from './Plugin';
 export * from './types';

package/dist/server/index.js

@@ -37,7 +37,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  EventOptions: () => import_Plugin.EventOptions,
   Processor: () => import_Processor.default,
   Trigger: () => import_triggers.Trigger,
   default: () => import_Plugin.default
@@ -54,7 +53,6 @@ var import_Plugin = __toESM(require("./Plugin"));
 __reExport(server_exports, require("./types"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  EventOptions,
   Processor,
   Trigger,
   ...require("./utils"),

package/dist/server/triggers/CollectionTrigger.d.ts

@@ -9,7 +9,7 @@
 import { Model } from '@nocobase/database';
 import Trigger from '.';
 import type { WorkflowModel } from '../types';
-import type { EventOptions } from '../Plugin';
+import type { EventOptions } from '../Dispatcher';
 export interface CollectionChangeTriggerConfig {
     collection: string;
     mode: number;

package/dist/server/triggers/ScheduleTrigger/DateFieldScheduleTrigger.d.ts

@@ -6,7 +6,7 @@
  * 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 '@nocobase/database';
+import { Model, Transactionable } from '@nocobase/database';
 import type Plugin from '../../Plugin';
 import type { WorkflowModel } from '../../types';
 export type ScheduleOnField = {
@@ -32,10 +32,10 @@ export default class DateFieldScheduleTrigger {
     constructor(workflow: Plugin);
     reload(): void;
     inspect(workflow: WorkflowModel): Promise<void>;
-    loadRecordsToSchedule({ id, config: { collection, limit, startsOn, repeat, endsOn }, stats }: WorkflowModel, currentDate: Date): Promise<import("@nocobase/database").Model<any, any>[]>;
-    getRecordNextTime(workflow: WorkflowModel, record: any, nextSecond?: boolean): any;
-    schedule(workflow: WorkflowModel, record: any, nextTime: any, toggle?: boolean, options?: {}): Promise<void>;
-    trigger(workflow: WorkflowModel, record: any, nextTime: any, { transaction }?: Transactionable): Promise<void>;
+    loadRecordsToSchedule({ id, config: { collection, limit, startsOn, repeat, endsOn }, stats }: WorkflowModel, currentDate: Date): Promise<Model<any, any>[]>;
+    getRecordNextTime(workflow: WorkflowModel, record: Model, nextSecond?: boolean): any;
+    schedule(workflow: WorkflowModel, record: Model, nextTime: number, toggle?: boolean, options?: {}): Promise<void>;
+    trigger(workflow: WorkflowModel, record: Model, nextTime: number, { transaction }?: Transactionable): Promise<void>;
     on(workflow: WorkflowModel): void;
     off(workflow: WorkflowModel): void;
     execute(workflow: any, values: any, options: any): Promise<void | import("../..").Processor>;

package/dist/server/triggers/ScheduleTrigger/DateFieldScheduleTrigger.js

@@ -45,7 +45,7 @@ var import_utils = require("./utils");
 var import_data_source_manager = require("@nocobase/data-source-manager");
 var import_lodash = require("lodash");
 var import_utils2 = require("../../utils");
-function getOnTimestampWithOffset({ field, offset = 0, unit = 1e3 }, now) {
+function getOnTimestampWithOffset({ field, offset = 0, unit = 864e5 }, now) {
   if (!field) {
     return null;
   }
@@ -62,7 +62,7 @@ function getDataOptionTime(record, on, dir = 1) {
       return time ? time : null;
     }
     case "object": {
-      const { field, offset = 0, unit = 1e3 } = on;
+      const { field, offset = 0, unit = 864e5 } = on;
       if (!field || !record.get(field)) {
         return null;
       }
@@ -188,13 +188,14 @@ class DateFieldScheduleTrigger {
       if (typeof repeat === "number") {
         const tsFn = DialectTimestampFnMap[db.options.dialect];
         if (repeat > range && tsFn) {
+          const offsetSeconds = Math.round((startsOn.offset || 0) * (startsOn.unit || 1e3) / 1e3);
+          const repeatSeconds = Math.round(repeat / 1e3);
+          const nowSeconds = Math.round(timestamp / 1e3);
           const { field } = model.getAttributes()[startsOn.field];
-          const modExp = (0, import_database.fn)(
-            "MOD",
-            (0, import_database.literal)(
-              `${Math.round(timestamp / 1e3)} - ${tsFn(db.sequelize.getQueryInterface().quoteIdentifiers(field))}`
-            ),
-            Math.round(repeat / 1e3)
+          const modExp = (0, import_database.literal)(
+            `MOD(MOD(${tsFn(
+              db.sequelize.getQueryInterface().quoteIdentifiers(field)
+            )} + ${offsetSeconds} - ${nowSeconds}, ${repeatSeconds}) + ${repeatSeconds}, ${repeatSeconds})`
           );
           conditions.push((0, import_database.where)(modExp, { [import_database.Op.lt]: Math.round(range / 1e3) }));
         }
@@ -241,6 +242,7 @@ class DateFieldScheduleTrigger {
     if (limit && stats.executed >= limit) {
       return null;
     }
+    const logger = this.workflow.getLogger(workflow.id);
     const range = this.cacheCycle;
     const now = /* @__PURE__ */ new Date();
     now.setMilliseconds(nextSecond ? 1e3 : 0);
@@ -249,37 +251,50 @@ class DateFieldScheduleTrigger {
     const endTime = getDataOptionTime(record, endsOn);
     let nextTime = null;
     if (!startTime) {
+      logger.debug(`[Schedule on date field] getNextTime: startsOn not configured`);
       return null;
     }
     if (startTime > timestamp + range) {
+      logger.debug(`[Schedule on date field] getNextTime: startsOn is out of caching window`);
       return null;
     }
     if (startTime >= timestamp) {
-      return !endTime || endTime >= startTime && endTime < timestamp + range ? startTime : null;
+      if (!endTime || startTime <= endTime) {
+        return startTime;
+      }
+      logger.debug(`[Schedule on date field] getNextTime: endsOn is before startsOn or out of caching window`);
+      return null;
     } else {
       if (!repeat) {
+        logger.debug(
+          `[Schedule on date field] getNextTime: startsOn is before current time and repeat is not configured`
+        );
         return null;
       }
     }
     if (typeof repeat === "number") {
-      const nextRepeatTime = (startTime - timestamp) % repeat + repeat;
-      if (nextRepeatTime > range) {
+      nextTime = timestamp + repeat - (timestamp - startTime) % repeat;
+      if (nextTime - timestamp > range) {
+        logger.debug(`[Schedule on date field] getNextTime: nextTime (${nextTime}) is out of caching window`);
         return null;
       }
-      if (endTime && endTime < timestamp + nextRepeatTime) {
+      if (endTime && endTime < nextTime) {
+        logger.debug(`[Schedule on date field] getNextTime: nextTime is after endsOn`);
         return null;
       }
-      nextTime = timestamp + nextRepeatTime;
     } else if (typeof repeat === "string") {
       nextTime = getCronNextTime(repeat, now);
       if (nextTime - timestamp > range) {
+        logger.debug(`[Schedule on date field] getNextTime: nextTime (${nextTime}) is out of caching window`);
         return null;
       }
       if (endTime && endTime < nextTime) {
+        logger.debug(`[Schedule on date field] getNextTime: nextTime is after endsOn`);
         return null;
       }
     }
     if (endTime && endTime <= timestamp) {
+      logger.debug(`[Schedule on date field] getNextTime: nextTime is after endsOn`);
       return null;
     }
     return nextTime;
@@ -316,6 +331,10 @@ class DateFieldScheduleTrigger {
       appends: workflow.config.appends,
       transaction
     });
+    if (!data) {
+      this.workflow.getLogger(workflow.id).warn(`[Schedule on date field] record (${recordPk}) not exists, will not trigger`);
+      return;
+    }
     const eventKey = `${workflow.id}:${recordPk}@${nextTime}`;
     this.cache.delete(eventKey);
     const json = (0, import_utils2.toJSON)(data);
@@ -355,6 +374,7 @@ class DateFieldScheduleTrigger {
     }
     const listener = async (data, { transaction }) => {
       const nextTime = this.getRecordNextTime(workflow, data);
+      this.workflow.getLogger().debug(`[Schedule on date field] record saved, nextTime: ${nextTime}`);
       return this.schedule(workflow, data, nextTime, Boolean(nextTime), { transaction });
     };
     this.events.set(name, listener);

package/package.json

@@ -4,7 +4,7 @@
   "displayName.zh-CN": "工作流",
   "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 工具，为业务自动化提供基础支持，并且可任意扩展更多的触发器和节点。",
-  "version": "1.9.0-beta.8",
+  "version": "2.0.0-alpha.2",
   "license": "AGPL-3.0",
   "main": "./dist/server/index.js",
   "homepage": "https://docs.nocobase.com/handbook/workflow",
@@ -30,22 +30,22 @@
     "tinybench": "4.x"
   },
   "peerDependencies": {
-    "@nocobase/actions": "1.x",
-    "@nocobase/client": "1.x",
-    "@nocobase/database": "1.x",
-    "@nocobase/evaluators": "1.x",
-    "@nocobase/logger": "1.x",
-    "@nocobase/plugin-data-source-main": "1.x",
-    "@nocobase/plugin-error-handler": "1.x",
-    "@nocobase/plugin-mobile": "1.x",
-    "@nocobase/plugin-users": "1.x",
-    "@nocobase/plugin-workflow-test": "1.x",
-    "@nocobase/resourcer": "1.x",
-    "@nocobase/server": "1.x",
-    "@nocobase/test": "1.x",
-    "@nocobase/utils": "1.x"
+    "@nocobase/actions": "2.x",
+    "@nocobase/client": "2.x",
+    "@nocobase/database": "2.x",
+    "@nocobase/evaluators": "2.x",
+    "@nocobase/logger": "2.x",
+    "@nocobase/plugin-data-source-main": "2.x",
+    "@nocobase/plugin-error-handler": "2.x",
+    "@nocobase/plugin-mobile": "2.x",
+    "@nocobase/plugin-users": "2.x",
+    "@nocobase/plugin-workflow-test": "2.x",
+    "@nocobase/resourcer": "2.x",
+    "@nocobase/server": "2.x",
+    "@nocobase/test": "2.x",
+    "@nocobase/utils": "2.x"
   },
-  "gitHead": "f3d4f3d1ba7adbf4d4c60e656c23da45565769c8",
+  "gitHead": "1322f486b248bef53ed8c8f42f0a39dfd02125fd",
   "keywords": [
     "Workflow"
   ]