@nocobase/plugin-workflow 1.6.0-alpha.3 → 1.6.0-alpha.31

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");
@@ -59,6 +60,7 @@ 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"));
+var import_WorkflowTasksRepository = __toESM(require("./repositories/WorkflowTasksRepository"));
 class PluginWorkflowServer extends import_server.Plugin {
   instructions = new import_utils.Registry();
   triggers = new import_utils.Registry();
@@ -126,7 +128,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}}`;
@@ -191,7 +193,8 @@ class PluginWorkflowServer extends import_server.Plugin {
   }
   async beforeLoad() {
     this.db.registerRepositories({
-      WorkflowRepository: import_WorkflowRepository.default
+      WorkflowRepository: import_WorkflowRepository.default,
+      WorkflowTasksRepository: import_WorkflowTasksRepository.default
     });
   }
   /**
@@ -226,13 +229,15 @@ class PluginWorkflowServer extends import_server.Plugin {
         "executions:destroy",
         "flow_nodes:update",
         "flow_nodes:destroy",
-        "flow_nodes:test"
+        "flow_nodes:test",
+        "jobs:get"
       ]
     });
     this.app.acl.registerSnippet({
       name: "ui.workflows",
       actions: ["workflows:list"]
     });
+    this.app.acl.allow("workflowTasks", "countMine", "loggedIn");
     this.app.acl.allow("*", ["trigger"], "loggedIn");
     this.db.addMigrations({
       namespace: this.name,
@@ -256,7 +261,6 @@ class PluginWorkflowServer extends import_server.Plugin {
       (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({
@@ -266,8 +270,14 @@ class PluginWorkflowServer extends import_server.Plugin {
         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 () => {
@@ -323,10 +333,19 @@ class PluginWorkflowServer extends import_server.Plugin {
       logger.debug(`ignored event data:`, context);
       return;
     }
-    if (!options.manually && !workflow.enabled) {
+    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;
@@ -340,9 +359,10 @@ 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);
+    setImmediate(this.prepare);
   }
   async triggerSync(workflow, context, { deferred, ...options } = {}) {
     let execution;
@@ -367,33 +387,63 @@ 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.getLogger(execution.workflowId).info(`starting deferred execution (${execution.id})`);
     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
+      });
+      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 trigger = this.triggers.get(workflow.type);
-    const valid = await trigger.validateEvent(workflow, context, { ...options, transaction });
+    const valid = await this.validateEvent(workflow, context, { ...options, transaction });
     if (!valid) {
       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 {
@@ -402,6 +452,7 @@ 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 }
@@ -441,7 +492,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);
@@ -451,12 +502,16 @@ 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();
     } else {
+      this.getLogger("dispatcher").info("no more events need to be prepared, dispatching...");
+      if (this.executing) {
+        await this.executing;
+      }
       this.dispatch();
     }
   };
@@ -474,59 +529,78 @@ 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.pending.length) {
+        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;
+    const logger = this.getLogger(execution.workflowId);
     if (execution.status === import_constants.EXECUTION_STATUS.QUEUEING) {
       const transaction = await this.useDataSourceTransaction("main", options.transaction);
       await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED }, { transaction });
+      logger.info(`queueing execution (${execution.id}) from pending list updated to started`);
     }
-    const logger = this.getLogger(execution.workflowId);
     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();
+        await execution.destroy({ transaction: processor.mainTransaction });
       }
     } catch (err) {
       logger.error(`execution (${execution.id}) error: ${err.message}`, err);
     }
     return processor;
   }
-  async execute(workflow, context, options = {}) {
+  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`);
@@ -534,7 +608,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     if (!trigger.execute) {
       throw new Error(`"execute" method of trigger ${workflow.type} is not implemented`);
     }
-    return trigger.execute(workflow, context, options);
+    return trigger.execute(workflow, values, options);
   }
   /**
    * @experimental
@@ -555,4 +629,39 @@ class PluginWorkflowServer extends import_server.Plugin {
       return db.sequelize.transaction();
     }
   }
+  /**
+   * @experimental
+   */
+  async toggleTaskStatus(task, done, { transaction }) {
+    const { db } = this.app;
+    const repository = db.getRepository("workflowTasks");
+    if (done) {
+      await repository.destroy({
+        filter: {
+          type: task.type,
+          key: `${task.key}`
+        },
+        transaction
+      });
+    } else {
+      await repository.updateOrCreate({
+        filterKeys: ["key", "type"],
+        values: task,
+        transaction
+      });
+    }
+    if (task.userId) {
+      const counts = await repository.countAll({
+        where: {
+          userId: task.userId
+        },
+        transaction
+      }) || [];
+      this.app.emit("ws:sendToTag", {
+        tagKey: "userId",
+        tagValue: `${task.userId}`,
+        message: { type: "workflow:tasks:updated", payload: counts }
+      });
+    }
+  }
 }

package/dist/server/Processor.d.ts

@@ -109,6 +109,7 @@ export default class Processor {
         };
         $system: {};
         $scopes: {};
+        $env: {};
     };
     /**
      * @experimental

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({
@@ -212,7 +212,7 @@ class Processor {
     if (parentNode) {
       this.logger.debug(`not on main, recall to parent entry node (${node.id})})`);
       await this.recall(parentNode, job);
-      return job;
+      return null;
     }
     return this.exit(job.status);
   }
@@ -369,7 +369,8 @@ class Processor {
       $context: this.execution.context,
       $jobsMapByNodeKey: this.jobsMapByNodeKey,
       $system: systemFns,
-      $scopes
+      $scopes,
+      $env: this.options.plugin.app.environment.getVariables()
     };
   }
   /**

package/dist/server/actions/index.js

@@ -42,6 +42,7 @@ module.exports = __toCommonJS(actions_exports);
 var workflows = __toESM(require("./workflows"));
 var nodes = __toESM(require("./nodes"));
 var executions = __toESM(require("./executions"));
+var workflowTasks = __toESM(require("./workflowTasks"));
 function make(name, mod) {
   return Object.keys(mod).reduce(
     (result, key) => ({
@@ -62,6 +63,7 @@ function actions_default({ app }) {
       destroy: nodes.destroy,
       test: nodes.test
     }),
-    ...make("executions", executions)
+    ...make("executions", executions),
+    ...make("workflowTasks", workflowTasks)
   });
 }

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

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * 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 { Context } from '@nocobase/actions';
+export declare function countMine(context: Context, next: any): Promise<void>;

package/dist/server/actions/workflowTasks.js

@@ -0,0 +1,45 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workflowTasks_exports = {};
+__export(workflowTasks_exports, {
+  countMine: () => countMine
+});
+module.exports = __toCommonJS(workflowTasks_exports);
+var import_actions = require("@nocobase/actions");
+async function countMine(context, next) {
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  context.body = await repository.countAll({
+    where: {
+      userId: context.state.currentUser.id
+    }
+  }) || [];
+  next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countMine
+});

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

@@ -15,5 +15,4 @@ 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

@@ -40,7 +40,6 @@ __export(workflows_exports, {
   execute: () => execute,
   revision: () => revision,
   sync: () => sync,
-  trigger: () => trigger,
   update: () => update
 });
 module.exports = __toCommonJS(workflows_exports);
@@ -116,12 +115,12 @@ async function sync(context, next) {
   context.status = 204;
   await next();
 }
-async function trigger(context, next) {
-  return next();
-}
 async function execute(context, next) {
   const plugin = context.app.pm.get(import_Plugin.default);
-  const { filterByTk, autoRevision } = context.action.params;
+  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");
   }
@@ -137,7 +136,7 @@ async function execute(context, next) {
   const { executed } = workflow;
   let processor;
   try {
-    processor = await plugin.execute(workflow, context, { manually: true });
+    processor = await plugin.execute(workflow, values, { manually: true });
     if (!processor) {
       return context.throw(400, "workflow not triggered");
     }
@@ -174,6 +173,5 @@ async function execute(context, next) {
   execute,
   revision,
   sync,
-  trigger,
   update
 });

package/dist/server/collections/executions.js

@@ -33,6 +33,7 @@ var executions_default = {
   dumpRules: {
     group: "log"
   },
+  migrationRules: ["schema-only"],
   name: "executions",
   shared: true,
   fields: [
@@ -61,6 +62,14 @@ var executions_default = {
     {
       type: "integer",
       name: "status"
+    },
+    {
+      type: "json",
+      name: "stack"
+    },
+    {
+      type: "json",
+      name: "output"
     }
   ]
 };

package/dist/server/collections/flow_nodes.js

@@ -31,6 +31,7 @@ __export(flow_nodes_exports, {
 module.exports = __toCommonJS(flow_nodes_exports);
 var flow_nodes_default = {
   dumpRules: "required",
+  migrationRules: ["overwrite", "schema-only"],
   name: "flow_nodes",
   shared: true,
   fields: [

package/dist/server/collections/jobs.js

@@ -33,6 +33,7 @@ var jobs_default = {
   dumpRules: {
     group: "log"
   },
+  migrationRules: ["schema-only"],
   name: "jobs",
   shared: true,
   fields: [

package/dist/server/collections/workflowTasks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * 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 { CollectionOptions } from '@nocobase/database';
+export default function (): CollectionOptions;

package/dist/server/collections/workflowTasks.js

@@ -0,0 +1,64 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workflowTasks_exports = {};
+__export(workflowTasks_exports, {
+  default: () => workflowTasks_default
+});
+module.exports = __toCommonJS(workflowTasks_exports);
+function workflowTasks_default() {
+  return {
+    dumpRules: "required",
+    migrationRules: ["overwrite", "schema-only"],
+    name: "workflowTasks",
+    shared: true,
+    repository: "WorkflowTasksRepository",
+    fields: [
+      {
+        name: "user",
+        type: "belongsTo"
+      },
+      {
+        name: "workflow",
+        type: "belongsTo"
+      },
+      {
+        type: "string",
+        name: "type"
+      },
+      {
+        type: "string",
+        name: "key"
+      }
+    ],
+    indexes: [
+      {
+        unique: true,
+        fields: ["type", "key"]
+      }
+    ]
+  };
+}

package/dist/server/collections/workflows.js

@@ -32,6 +32,7 @@ module.exports = __toCommonJS(workflows_exports);
 function workflows_default() {
   return {
     dumpRules: "required",
+    migrationRules: ["overwrite", "schema-only"],
     name: "workflows",
     shared: true,
     repository: "WorkflowRepository",
@@ -43,7 +44,13 @@ function workflows_default() {
       {
         type: "string",
         name: "title",
-        required: true
+        interface: "input",
+        uiSchema: {
+          title: '{{t("Name")}}',
+          type: "string",
+          "x-component": "Input",
+          required: true
+        }
       },
       {
         type: "boolean",