@nocobase/plugin-workflow 1.5.0-beta.3 → 1.5.0-beta.30

package/dist/server/Plugin.js

@@ -41,6 +41,7 @@ __export(Plugin_exports, {
 module.exports = __toCommonJS(Plugin_exports);
 var import_path = __toESM(require("path"));
 var import_crypto = require("crypto");
+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");
@@ -58,6 +59,7 @@ var import_CreateInstruction = __toESM(require("./instructions/CreateInstruction
 var import_DestroyInstruction = __toESM(require("./instructions/DestroyInstruction"));
 var import_QueryInstruction = __toESM(require("./instructions/QueryInstruction"));
 var import_UpdateInstruction = __toESM(require("./instructions/UpdateInstruction"));
+var import_WorkflowRepository = __toESM(require("./repositories/WorkflowRepository"));
 class PluginWorkflowServer extends import_server.Plugin {
   instructions = new import_utils.Registry();
   triggers = new import_utils.Registry();
@@ -71,23 +73,10 @@ class PluginWorkflowServer extends import_server.Plugin {
   loggerCache;
   meter = null;
   checker = null;
-  onBeforeSave = async (instance, options) => {
+  onBeforeSave = async (instance, { transaction }) => {
     const Model = instance.constructor;
     if (instance.enabled) {
       instance.set("current", true);
-    } else if (!instance.current) {
-      const count = await Model.count({
-        where: {
-          key: instance.key
-        },
-        transaction: options.transaction
-      });
-      if (!count) {
-        instance.set("current", true);
-      }
-    }
-    if (!instance.changed("enabled") || !instance.enabled) {
-      return;
     }
     const previous = await Model.findOne({
       where: {
@@ -97,39 +86,40 @@ class PluginWorkflowServer extends import_server.Plugin {
           [import_database.Op.ne]: instance.id
         }
       },
-      transaction: options.transaction
+      transaction
     });
-    if (previous) {
+    if (!previous) {
+      instance.set("current", true);
+    }
+    if (instance.current && previous) {
       await previous.update(
         { enabled: false, current: null },
         {
-          transaction: options.transaction,
+          transaction,
           hooks: false
         }
       );
-      this.toggle(previous, false);
+      this.toggle(previous, false, { transaction });
     }
   };
-  async onSync(message) {
+  async handleSyncMessage(message) {
     if (message.type === "statusChange") {
-      const workflowId = Number.parseInt(message.workflowId, 10);
-      const enabled = Number.parseInt(message.enabled, 10);
-      if (enabled) {
-        let workflow = this.enabledCache.get(workflowId);
+      if (message.enabled) {
+        let workflow = this.enabledCache.get(message.workflowId);
         if (workflow) {
           await workflow.reload();
         } else {
           workflow = await this.db.getRepository("workflows").findOne({
-            filterByTk: workflowId
+            filterByTk: message.workflowId
           });
         }
         if (workflow) {
-          this.toggle(workflow, true, true);
+          this.toggle(workflow, true, { silent: true });
         }
       } else {
-        const workflow = this.enabledCache.get(workflowId);
+        const workflow = this.enabledCache.get(message.workflowId);
         if (workflow) {
-          this.toggle(workflow, false, true);
+          this.toggle(workflow, false, { silent: true });
         }
       }
     }
@@ -137,7 +127,7 @@ class PluginWorkflowServer extends import_server.Plugin {
   /**
    * @experimental
    */
-  getLogger(workflowId) {
+  getLogger(workflowId = "dispatcher") {
     const now = /* @__PURE__ */ new Date();
     const date = `${now.getFullYear()}-${`0${now.getMonth() + 1}`.slice(-2)}-${`0${now.getDate()}`.slice(-2)}`;
     const key = `${date}-${workflowId}}`;
@@ -200,6 +190,11 @@ class PluginWorkflowServer extends import_server.Plugin {
       this.registerInstruction(name, instruction);
     }
   }
+  async beforeLoad() {
+    this.db.registerRepositories({
+      WorkflowRepository: import_WorkflowRepository.default
+    });
+  }
   /**
    * @internal
    */
@@ -248,31 +243,42 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     });
     db.on("workflows.beforeSave", this.onBeforeSave);
-    db.on("workflows.afterCreate", (model) => {
+    db.on("workflows.afterCreate", (model, { transaction }) => {
       if (model.enabled) {
-        this.toggle(model);
+        this.toggle(model, true, { transaction });
       }
     });
-    db.on("workflows.afterUpdate", (model) => this.toggle(model));
-    db.on("workflows.beforeDestroy", (model) => this.toggle(model, false));
+    db.on(
+      "workflows.afterUpdate",
+      (model, { transaction }) => this.toggle(model, model.enabled, { transaction })
+    );
+    db.on(
+      "workflows.afterDestroy",
+      (model, { transaction }) => this.toggle(model, false, { transaction })
+    );
     this.app.on("afterStart", async () => {
-      this.app.setMaintainingMessage("check for not started executions");
       this.ready = true;
       const collection = db.getCollection("workflows");
       const workflows = await collection.repository.find({
         filter: { enabled: true }
       });
       workflows.forEach((workflow) => {
-        this.toggle(workflow);
+        this.toggle(workflow, true, { silent: true });
       });
       this.checker = setInterval(() => {
+        this.getLogger("dispatcher").info(`(cycling) check for queueing executions`);
         this.dispatch();
       }, 3e5);
+      this.app.on("workflow:dispatch", () => {
+        this.app.logger.info("workflow:dispatch");
+        this.dispatch();
+      });
+      this.getLogger("dispatcher").info("(starting) check for queueing executions");
       this.dispatch();
     });
     this.app.on("beforeStop", async () => {
       for (const workflow of this.enabledCache.values()) {
-        this.toggle(workflow, false);
+        this.toggle(workflow, false, { silent: true });
       }
       this.ready = false;
       if (this.events.length) {
@@ -286,7 +292,7 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     });
   }
-  toggle(workflow, enable, silent = false) {
+  toggle(workflow, enable, { silent, transaction } = {}) {
     const type = workflow.get("type");
     const trigger = this.triggers.get(type);
     if (!trigger) {
@@ -306,11 +312,14 @@ class PluginWorkflowServer extends import_server.Plugin {
       this.enabledCache.delete(workflow.id);
     }
     if (!silent) {
-      this.sync({
-        type: "statusChange",
-        workflowId: `${workflow.id}`,
-        enabled: `${Number(next)}`
-      });
+      this.sendSyncMessage(
+        {
+          type: "statusChange",
+          workflowId: workflow.id,
+          enabled: next
+        },
+        { transaction }
+      );
     }
   }
   trigger(workflow, context, options = {}) {
@@ -320,11 +329,24 @@ class PluginWorkflowServer extends import_server.Plugin {
       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 (this.isWorkflowSync(workflow)) {
+    if (options.manually || this.isWorkflowSync(workflow)) {
       return this.triggerSync(workflow, context, options);
     }
     const { transaction, ...rest } = options;
@@ -333,6 +355,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     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;
     }
     setTimeout(this.prepare);
@@ -360,31 +383,61 @@ class PluginWorkflowServer extends import_server.Plugin {
       `execution (${job.execution.id}) resuming from job (${job.id}) added to pending list`
     );
     this.pending.push([job.execution, job]);
+    if (this.executing) {
+      await this.executing;
+    }
     this.dispatch();
   }
   /**
    * Start a deferred execution
    * @experimental
    */
-  start(execution) {
+  async start(execution) {
     if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
       return;
     }
     this.pending.push([execution]);
+    if (this.executing) {
+      await this.executing;
+    }
     this.dispatch();
   }
-  createProcessor(execution, options = {}) {
-    return new import_Processor.default(execution, { ...options, plugin: this });
+  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
+      });
+      if (existed) {
+        this.getLogger(workflow.id).warn(
+          `workflow ${workflow.id} has already been triggered in stacks executions (${stack}), and newly triggering will be skipped.`
+        );
+        valid = false;
+      }
+    }
+    return valid;
   }
   async createExecution(workflow, context, options) {
-    const { transaction = await this.db.sequelize.transaction(), deferred } = options;
-    const trigger = this.triggers.get(workflow.type);
-    const valid = await trigger.validateEvent(workflow, context, { ...options, transaction });
+    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 (!options.transaction) {
+      if (!sameTransaction) {
         await transaction.commit();
       }
-      return null;
+      (_a = options.onTriggerFail) == null ? void 0 : _a.call(options, workflow, context, options);
+      return Promise.reject(new Error("event is not valid"));
     }
     let execution;
     try {
@@ -393,12 +446,13 @@ class PluginWorkflowServer extends import_server.Plugin {
           context,
           key: workflow.key,
           eventKey: options.eventKey ?? (0, import_crypto.randomUUID)(),
+          stack: options.stack,
           status: deferred ? import_constants.EXECUTION_STATUS.STARTED : import_constants.EXECUTION_STATUS.QUEUEING
         },
         { transaction }
       );
     } catch (err) {
-      if (!options.transaction) {
+      if (!sameTransaction) {
         await transaction.rollback();
       }
       throw err;
@@ -419,7 +473,7 @@ class PluginWorkflowServer extends import_server.Plugin {
         transaction
       }
     );
-    if (!options.transaction) {
+    if (!sameTransaction) {
       await transaction.commit();
     }
     execution.workflow = workflow;
@@ -432,7 +486,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     const event = this.events.shift();
     this.eventsCount = this.events.length;
     if (!event) {
-      this.getLogger("dispatcher").warn(`events queue is empty, no need to prepare`);
+      this.getLogger("dispatcher").info(`events queue is empty, no need to prepare`);
       return;
     }
     const logger = this.getLogger(event[0].id);
@@ -442,8 +496,8 @@ class PluginWorkflowServer extends import_server.Plugin {
       if ((execution == null ? void 0 : execution.status) === import_constants.EXECUTION_STATUS.QUEUEING && !this.executing && !this.pending.length) {
         this.pending.push([execution]);
       }
-    } catch (err) {
-      logger.error(`failed to create execution: ${err.message}`, err);
+    } catch (error) {
+      logger.error(`failed to create execution:`, { error });
     }
     if (this.events.length) {
       await this.prepare();
@@ -465,38 +519,56 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
     this.executing = (async () => {
       let next = null;
-      try {
-        if (this.pending.length) {
-          next = this.pending.shift();
-          this.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
-        } else {
-          const execution = await this.db.getRepository("executions").findOne({
-            filter: {
-              status: import_constants.EXECUTION_STATUS.QUEUEING,
-              "workflow.enabled": true,
-              "workflow.id": {
-                [import_database.Op.not]: 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
             },
-            appends: ["workflow"],
-            sort: "id"
-          });
-          if (execution) {
-            this.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
-            next = [execution];
-          }
-        }
-        if (next) {
-          await this.process(...next);
-        }
-      } finally {
-        this.executing = null;
-        if (next) {
-          this.dispatch();
+            async (transaction) => {
+              const execution = await this.db.getRepository("executions").findOne({
+                filter: {
+                  status: import_constants.EXECUTION_STATUS.QUEUEING,
+                  "workflow.enabled": true
+                },
+                sort: "id",
+                transaction
+              });
+              if (execution) {
+                this.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
+                await execution.update(
+                  {
+                    status: import_constants.EXECUTION_STATUS.STARTED
+                  },
+                  { transaction }
+                );
+                execution.workflow = this.enabledCache.get(execution.workflowId);
+                next = [execution];
+              } else {
+                this.getLogger("dispatcher").info(`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.getLogger("dispatcher").info(`last process finished, will do another dispatch`);
+        this.dispatch();
+      }
     })();
   }
+  createProcessor(execution, options = {}) {
+    return new import_Processor.default(execution, { ...options, plugin: this });
+  }
   async process(execution, job, options = {}) {
     var _a, _b;
     if (execution.status === import_constants.EXECUTION_STATUS.QUEUEING) {
@@ -510,13 +582,23 @@ class PluginWorkflowServer extends import_server.Plugin {
       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();
+        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) {
+      throw new Error(`trigger type "${workflow.type}" of workflow ${workflow.id} is not registered`);
+    }
+    if (!trigger.execute) {
+      throw new Error(`"execute" method of trigger ${workflow.type} is not implemented`);
+    }
+    return trigger.execute(workflow, values, options);
+  }
   /**
    * @experimental
    * @param {string} dataSourceName

package/dist/server/Processor.js

@@ -117,11 +117,11 @@ class Processor {
       execution,
       options: { plugin }
     } = this;
-    if (!execution.workflow) {
-      execution.workflow = plugin.enabledCache.get(execution.workflowId);
-    }
     this.mainTransaction = plugin.useDataSourceTransaction("main", this.transaction);
     const transaction = this.mainTransaction;
+    if (!execution.workflow) {
+      execution.workflow = plugin.enabledCache.get(execution.workflowId) || await execution.getWorkflow({ transaction });
+    }
     const nodes = await execution.workflow.getNodes({ transaction });
     this.makeNodes(nodes);
     const jobs = await execution.getJobs({

package/dist/server/actions/workflows.d.ts

@@ -11,4 +11,9 @@ export declare function update(context: Context, next: any): Promise<void>;
 export declare function destroy(context: Context, next: any): Promise<void>;
 export declare function revision(context: Context, next: any): Promise<void>;
 export declare function sync(context: Context, next: any): Promise<void>;
+/**
+ * @deprecated
+ * Keep for action trigger compatibility
+ */
 export declare function trigger(context: Context, next: any): Promise<any>;
+export declare function execute(context: Context, next: any): Promise<any>;

package/dist/server/actions/workflows.js

@@ -37,6 +37,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var workflows_exports = {};
 __export(workflows_exports, {
   destroy: () => destroy,
+  execute: () => execute,
   revision: () => revision,
   sync: () => sync,
   trigger: () => trigger,
@@ -90,69 +91,13 @@ async function destroy(context, next) {
   next();
 }
 async function revision(context, next) {
-  const plugin = context.app.getPlugin(import_Plugin.default);
   const repository = import_actions.utils.getRepositoryFromParams(context);
   const { filterByTk, filter = {}, values = {} } = context.action.params;
-  context.body = await context.db.sequelize.transaction(async (transaction) => {
-    const origin = await repository.findOne({
-      filterByTk,
-      filter,
-      appends: ["nodes"],
-      context,
-      transaction
-    });
-    const trigger2 = plugin.triggers.get(origin.type);
-    const revisionData = filter.key ? {
-      key: filter.key,
-      title: origin.title,
-      triggerTitle: origin.triggerTitle,
-      allExecuted: origin.allExecuted
-    } : values;
-    const instance = await repository.create({
-      values: {
-        title: `${origin.title} copy`,
-        description: origin.description,
-        ...revisionData,
-        sync: origin.sync,
-        type: origin.type,
-        config: typeof trigger2.duplicateConfig === "function" ? await trigger2.duplicateConfig(origin, { transaction }) : origin.config
-      },
-      transaction
-    });
-    const originalNodesMap = /* @__PURE__ */ new Map();
-    origin.nodes.forEach((node) => {
-      originalNodesMap.set(node.id, node);
-    });
-    const oldToNew = /* @__PURE__ */ new Map();
-    const newToOld = /* @__PURE__ */ new Map();
-    for await (const node of origin.nodes) {
-      const instruction = plugin.instructions.get(node.type);
-      const newNode = await instance.createNode(
-        {
-          type: node.type,
-          key: node.key,
-          config: typeof instruction.duplicateConfig === "function" ? await instruction.duplicateConfig(node, { transaction }) : node.config,
-          title: node.title,
-          branchIndex: node.branchIndex
-        },
-        { transaction }
-      );
-      oldToNew.set(node.id, newNode);
-      newToOld.set(newNode.id, node);
-    }
-    for await (const [oldId, newNode] of oldToNew.entries()) {
-      const oldNode = originalNodesMap.get(oldId);
-      const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
-      const newDownstream = oldNode.downstreamId ? oldToNew.get(oldNode.downstreamId) : null;
-      await newNode.update(
-        {
-          upstreamId: (newUpstream == null ? void 0 : newUpstream.id) ?? null,
-          downstreamId: (newDownstream == null ? void 0 : newDownstream.id) ?? null
-        },
-        { transaction }
-      );
-    }
-    return instance;
+  context.body = await repository.revision({
+    filterByTk,
+    filter,
+    values,
+    context
   });
   await next();
 }
@@ -174,9 +119,62 @@ async function sync(context, next) {
 async function trigger(context, next) {
   return next();
 }
+async function execute(context, next) {
+  const plugin = context.app.pm.get(import_Plugin.default);
+  const { filterByTk, values, autoRevision } = context.action.params;
+  if (!values) {
+    return context.throw(400, "values is required");
+  }
+  if (!filterByTk) {
+    return context.throw(400, "filterByTk is required");
+  }
+  const id = Number.parseInt(filterByTk, 10);
+  if (Number.isNaN(id)) {
+    return context.throw(400, "filterByTk is invalid");
+  }
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const workflow = plugin.enabledCache.get(id) || await repository.findOne({ filterByTk });
+  if (!workflow) {
+    return context.throw(404, "workflow not found");
+  }
+  const { executed } = workflow;
+  let processor;
+  try {
+    processor = await plugin.execute(workflow, values, { manually: true });
+    if (!processor) {
+      return context.throw(400, "workflow not triggered");
+    }
+  } catch (ex) {
+    return context.throw(400, ex.message);
+  }
+  context.action.mergeParams({
+    filter: { key: workflow.key }
+  });
+  let newVersion;
+  if (!executed && autoRevision) {
+    newVersion = await repository.revision({
+      filterByTk: workflow.id,
+      filter: { key: workflow.key },
+      values: {
+        current: workflow.current,
+        enabled: workflow.enabled
+      },
+      context
+    });
+  }
+  context.body = {
+    execution: {
+      id: processor.execution.id,
+      status: processor.execution.status
+    },
+    newVersionId: newVersion == null ? void 0 : newVersion.id
+  };
+  return next();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   destroy,
+  execute,
   revision,
   sync,
   trigger,

package/dist/server/collections/executions.js

@@ -61,6 +61,14 @@ var executions_default = {
     {
       type: "integer",
       name: "status"
+    },
+    {
+      type: "json",
+      name: "stack"
+    },
+    {
+      type: "json",
+      name: "output"
     }
   ]
 };

package/dist/server/collections/workflows.js

@@ -34,6 +34,7 @@ function workflows_default() {
     dumpRules: "required",
     name: "workflows",
     shared: true,
+    repository: "WorkflowRepository",
     fields: [
       {
         name: "key",
@@ -90,8 +91,7 @@ function workflows_default() {
       },
       {
         type: "boolean",
-        name: "current",
-        defaultValue: false
+        name: "current"
       },
       {
         type: "boolean",

package/dist/server/index.d.ts

@@ -13,5 +13,5 @@ export * from './functions';
 export * from './logicCalculate';
 export { Trigger } from './triggers';
 export { default as Processor } from './Processor';
-export { default } from './Plugin';
+export { default, EventOptions } from './Plugin';
 export * from './types';

package/dist/server/index.js

@@ -37,6 +37,7 @@ 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
@@ -53,6 +54,7 @@ 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"),