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

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/actions/nodes.js

@@ -49,12 +49,22 @@ async function create(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
+  const workflowPlugin = context.app.pm.get(import__.default);
   context.body = await db.sequelize.transaction(async (transaction) => {
-    const workflow = await repository.getSourceModel(transaction);
-    workflow.versionStats = await workflow.getVersionStats({ transaction });
+    const workflow = workflowPlugin.enabledCache.get(Number.parseInt(workflowId, 10)) || await repository.getSourceModel(transaction);
+    if (!workflow.versionStats) {
+      workflow.versionStats = await workflow.getVersionStats({ transaction });
+    }
     if (workflow.versionStats.executed > 0) {
       context.throw(400, "Node could not be created in executed workflow");
     }
+    const NODES_LIMIT = process.env.WORKFLOW_NODES_LIMIT ? parseInt(process.env.WORKFLOW_NODES_LIMIT, 10) : null;
+    if (NODES_LIMIT) {
+      const nodesCount = await workflow.countNodes({ transaction });
+      if (nodesCount >= NODES_LIMIT) {
+        context.throw(400, `The number of nodes in a workflow cannot exceed ${NODES_LIMIT}`);
+      }
+    }
     const instance = await repository.create({
       values,
       whitelist,
@@ -136,38 +146,32 @@ function searchBranchDownstreams(nodes, from) {
   }
   return result;
 }
+function findBranchTail(branchHead) {
+  let tail = branchHead;
+  while (tail.downstream) {
+    tail = tail.downstream;
+  }
+  return tail;
+}
 async function destroy(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
+  const { filterByTk, keepBranch } = context.action.params;
+  const keepBranchIndex = keepBranch == null || keepBranch === "" ? null : Number.parseInt(keepBranch, 10);
   const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
   const instance = await repository.findOne({
     filterByTk,
     fields: [...fields, "workflowId"],
     appends: ["upstream", "downstream", "workflow.versionStats.executed"]
   });
+  if (!instance) {
+    context.throw(404, "Node not found");
+  }
   if (instance.workflow.versionStats.executed > 0) {
     context.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
-    if (upstream && upstream.downstreamId === instance.id) {
-      await upstream.update(
-        {
-          downstreamId: instance.downstreamId
-        },
-        { transaction }
-      );
-    }
-    if (downstream) {
-      await downstream.update(
-        {
-          upstreamId: instance.upstreamId,
-          branchIndex: instance.branchIndex
-        },
-        { transaction }
-      );
-    }
     const nodes = await repository.find({
       filter: {
         workflowId: instance.workflowId
@@ -187,9 +191,69 @@ async function destroy(context, next) {
         item.downstream = nodesMap.get(item.downstreamId);
       }
     });
-    const branchNodes = searchBranchNodes(nodes, nodesMap.get(instance.id));
+    const keepBranchHead = keepBranchIndex != null ? nodes.find((item) => item.upstreamId === instance.id && item.branchIndex == keepBranchIndex) : null;
+    if (keepBranchIndex != null && !keepBranchHead) {
+      context.throw(400, `Branch ${keepBranchIndex} not found`);
+    }
+    const keepBranchNodes = keepBranchHead ? searchBranchDownstreams(nodes, keepBranchHead) : [];
+    const keepBranchNodeIds = new Set(keepBranchNodes.map((item) => item.id));
+    const branchNodes = instance ? searchBranchNodes(nodes, instance) : [];
+    const branchNodesToDelete = keepBranchHead ? branchNodes.filter((item) => !keepBranchNodeIds.has(item.id)) : branchNodes;
+    if (keepBranchHead) {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: keepBranchHead.id
+          },
+          { transaction }
+        );
+      }
+      await keepBranchHead.update(
+        {
+          upstreamId: instance.upstreamId,
+          branchIndex: instance.branchIndex
+        },
+        { transaction }
+      );
+      if (downstream) {
+        const branchTail = findBranchTail(keepBranchHead);
+        await branchTail.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+        branchTail.downstreamId = instance.downstreamId;
+        branchTail.downstream = downstream;
+        await downstream.update(
+          {
+            upstreamId: branchTail.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+      }
+    } else {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+      }
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.upstreamId,
+            branchIndex: instance.branchIndex
+          },
+          { transaction }
+        );
+      }
+    }
     await repository.destroy({
-      filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
+      filterByTk: [instance.id, ...branchNodesToDelete.map((item) => item.id)],
       transaction
     });
   });

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>;