@nocobase/plugin-workflow 1.7.0-alpha.1 → 1.7.0-alpha.11

package/dist/server/Dispatcher.js

@@ -0,0 +1,35 @@
+/**
+ * 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 Dispatcher_exports = {};
+__export(Dispatcher_exports, {
+  default: () => Dispatcher
+});
+module.exports = __toCommonJS(Dispatcher_exports);
+class Dispatcher {
+  constructor() {
+  }
+}

package/dist/server/Plugin.d.ts

@@ -6,6 +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 { Snowflake } from 'nodejs-snowflake';
 import { Transactionable } from 'sequelize';
 import { Plugin } from '@nocobase/server';
 import { Registry } from '@nocobase/utils';
@@ -31,6 +32,7 @@ export default class PluginWorkflowServer extends Plugin {
     triggers: Registry<Trigger>;
     functions: Registry<CustomFunction>;
     enabledCache: Map<number, WorkflowModel>;
+    snowflake: Snowflake;
     private ready;
     private executing;
     private pending;
@@ -40,6 +42,11 @@ export default class PluginWorkflowServer extends Plugin {
     private meter;
     private checker;
     private onBeforeSave;
+    private onAfterCreate;
+    private onAfterUpdate;
+    private onAfterDestroy;
+    private onAfterStart;
+    private onBeforeStop;
     handleSyncMessage(message: any): Promise<void>;
     /**
      * @experimental
@@ -91,6 +98,6 @@ export default class PluginWorkflowServer extends Plugin {
     /**
      * @experimental
      */
-    toggleTaskStatus(task: WorkflowTaskModel, done: boolean, { transaction }: Transactionable): Promise<void>;
+    toggleTaskStatus(task: WorkflowTaskModel, on: boolean, { transaction }: Transactionable): Promise<void>;
 }
 export {};

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_nodejs_snowflake = require("nodejs-snowflake");
 var import_sequelize = require("sequelize");
 var import_lru_cache = __toESM(require("lru-cache"));
 var import_database = require("@nocobase/database");
@@ -66,6 +67,7 @@ class PluginWorkflowServer extends import_server.Plugin {
   triggers = new import_utils.Registry();
   functions = new import_utils.Registry();
   enabledCache = /* @__PURE__ */ new Map();
+  snowflake;
   ready = false;
   executing = null;
   pending = [];
@@ -76,6 +78,9 @@ class PluginWorkflowServer extends import_server.Plugin {
   checker = null;
   onBeforeSave = async (instance, { transaction }) => {
     const Model = instance.constructor;
+    if (!instance.key) {
+      instance.set("key", (0, import_utils.uid)());
+    }
     if (instance.enabled) {
       instance.set("current", true);
     }
@@ -103,6 +108,82 @@ class PluginWorkflowServer extends import_server.Plugin {
       this.toggle(previous, false, { transaction });
     }
   };
+  onAfterCreate = async (model, { transaction }) => {
+    const WorkflowStatsModel = this.db.getModel("workflowStats");
+    let stats = await WorkflowStatsModel.findOne({
+      where: { key: model.key },
+      transaction
+    });
+    if (!stats) {
+      stats = await model.createStats({ executed: 0 }, { transaction });
+    }
+    model.stats = stats;
+    model.versionStats = await model.createVersionStats({ id: model.id }, { transaction });
+    if (model.enabled) {
+      this.toggle(model, true, { transaction });
+    }
+  };
+  onAfterUpdate = async (model, { transaction }) => {
+    model.stats = await model.getStats({ transaction });
+    model.versionStats = await model.getVersionStats({ transaction });
+    this.toggle(model, model.enabled, { transaction });
+  };
+  onAfterDestroy = async (model, { transaction }) => {
+    this.toggle(model, false, { transaction });
+    const TaskRepo = this.db.getRepository("workflowTasks");
+    await TaskRepo.destroy({
+      filter: {
+        workflowId: model.id
+      },
+      transaction
+    });
+  };
+  // [Life Cycle]:
+  //   * load all workflows in db
+  //   * add all hooks for enabled workflows
+  //   * add hooks for create/update[enabled]/delete workflow to add/remove specific hooks
+  onAfterStart = async () => {
+    this.ready = true;
+    const collection = this.db.getCollection("workflows");
+    const workflows = await collection.repository.find({
+      filter: { enabled: true },
+      appends: ["stats", "versionStats"]
+    });
+    for (const workflow of workflows) {
+      if (!workflow.stats) {
+        workflow.stats = await workflow.createStats({ executed: 0 });
+      }
+      if (!workflow.versionStats) {
+        workflow.versionStats = await workflow.createVersionStats({ executed: 0 });
+      }
+      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();
+  };
+  onBeforeStop = async () => {
+    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;
+    }
+    if (this.checker) {
+      clearInterval(this.checker);
+    }
+  };
   async handleSyncMessage(message) {
     if (message.type === "statusChange") {
       if (message.enabled) {
@@ -196,6 +277,13 @@ class PluginWorkflowServer extends import_server.Plugin {
       WorkflowRepository: import_WorkflowRepository.default,
       WorkflowTasksRepository: import_WorkflowTasksRepository.default
     });
+    const PluginRepo = this.db.getRepository("applicationPlugins");
+    const pluginRecord = await PluginRepo.findOne({
+      filter: { name: this.name }
+    });
+    this.snowflake = new import_nodejs_snowflake.Snowflake({
+      custom_epoch: pluginRecord == null ? void 0 : pluginRecord.createdAt.getTime()
+    });
   }
   /**
    * @internal
@@ -247,54 +335,11 @@ class PluginWorkflowServer extends import_server.Plugin {
       }
     });
     db.on("workflows.beforeSave", this.onBeforeSave);
-    db.on("workflows.afterCreate", (model, { transaction }) => {
-      if (model.enabled) {
-        this.toggle(model, true, { transaction });
-      }
-    });
-    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.ready = true;
-      const collection = db.getCollection("workflows");
-      const workflows = await collection.repository.find({
-        filter: { enabled: true }
-      });
-      workflows.forEach((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, { silent: true });
-      }
-      this.ready = false;
-      if (this.events.length) {
-        await this.prepare();
-      }
-      if (this.executing) {
-        await this.executing;
-      }
-      if (this.checker) {
-        clearInterval(this.checker);
-      }
-    });
+    db.on("workflows.afterCreate", this.onAfterCreate);
+    db.on("workflows.afterUpdate", this.onAfterUpdate);
+    db.on("workflows.afterDestroy", this.onAfterDestroy);
+    this.app.on("afterStart", this.onAfterStart);
+    this.app.on("beforeStop", this.onBeforeStop);
   }
   toggle(workflow, enable, { silent, transaction } = {}) {
     const type = workflow.get("type");
@@ -308,11 +353,14 @@ class PluginWorkflowServer extends import_server.Plugin {
       const prev = workflow.previous();
       if (prev.config) {
         trigger.off({ ...workflow.get(), ...prev });
+        this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id} based on configuration before updated`);
       }
       trigger.on(workflow);
+      this.getLogger(workflow.id).info(`toggle ON workflow ${workflow.id}`);
       this.enabledCache.set(workflow.id, workflow);
     } else {
       trigger.off(workflow);
+      this.getLogger(workflow.id).info(`toggle OFF workflow ${workflow.id}`);
       this.enabledCache.delete(workflow.id);
     }
     if (!silent) {
@@ -464,21 +512,20 @@ class PluginWorkflowServer extends import_server.Plugin {
       throw err;
     }
     this.getLogger(workflow.id).info(`execution of workflow ${workflow.id} created as ${execution.id}`);
-    await workflow.increment(["executed", "allExecuted"], { transaction });
+    if (!workflow.stats) {
+      workflow.stats = await workflow.getStats({ transaction });
+    }
+    await workflow.stats.increment("executed", { transaction });
     if (this.db.options.dialect !== "postgres") {
-      await workflow.reload({ transaction });
+      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 });
     }
-    await workflow.constructor.update(
-      {
-        allExecuted: workflow.allExecuted
-      },
-      {
-        where: {
-          key: workflow.key
-        },
-        transaction
-      }
-    );
     if (!sameTransaction) {
       await transaction.commit();
     }
@@ -632,10 +679,16 @@ class PluginWorkflowServer extends import_server.Plugin {
   /**
    * @experimental
    */
-  async toggleTaskStatus(task, done, { transaction }) {
+  async toggleTaskStatus(task, on, { transaction }) {
     const { db } = this.app;
     const repository = db.getRepository("workflowTasks");
-    if (done) {
+    if (on) {
+      await repository.updateOrCreate({
+        filterKeys: ["key", "type"],
+        values: task,
+        transaction
+      });
+    } else {
       await repository.destroy({
         filter: {
           type: task.type,
@@ -643,17 +696,12 @@ class PluginWorkflowServer extends import_server.Plugin {
         },
         transaction
       });
-    } else {
-      await repository.updateOrCreate({
-        filterKeys: ["key", "type"],
-        values: task,
-        transaction
-      });
     }
     if (task.userId) {
       const counts = await repository.countAll({
         where: {
-          userId: task.userId
+          userId: task.userId,
+          workflowId: { [import_database.Op.ne]: null }
         },
         transaction
       }) || [];

package/dist/server/Processor.d.ts

@@ -44,16 +44,9 @@ export default class Processor {
      * @experimental
      */
     nodesMap: Map<number, FlowNodeModel>;
-    /**
-     * @experimental
-     */
-    jobsMap: Map<number, JobModel>;
-    /**
-     * @experimental
-     */
-    jobsMapByNodeKey: {
-        [key: string]: any;
-    };
+    private jobsMapByNodeKey;
+    private jobResultsMapByNodeKey;
+    private jobsToSave;
     /**
      * @experimental
      */
@@ -72,7 +65,7 @@ export default class Processor {
     /**
      * @experimental
      */
-    saveJob(payload: JobModel | Record<string, any>): Promise<JobModel>;
+    saveJob(payload: JobModel | Record<string, any>): JobModel;
     /**
      * @experimental
      */

package/dist/server/Processor.js

@@ -78,14 +78,9 @@ class Processor {
    * @experimental
    */
   nodesMap = /* @__PURE__ */ new Map();
-  /**
-   * @experimental
-   */
-  jobsMap = /* @__PURE__ */ new Map();
-  /**
-   * @experimental
-   */
   jobsMapByNodeKey = {};
+  jobResultsMapByNodeKey = {};
+  jobsToSave = /* @__PURE__ */ new Map();
   /**
    * @experimental
    */
@@ -107,9 +102,9 @@ class Processor {
   }
   makeJobs(jobs) {
     jobs.forEach((job) => {
-      this.jobsMap.set(job.id, job);
       const node = this.nodesMap.get(job.nodeId);
-      this.jobsMapByNodeKey[node.key] = job.result;
+      this.jobsMapByNodeKey[node.key] = job;
+      this.jobResultsMapByNodeKey[node.key] = job.result;
     });
   }
   async prepare() {
@@ -179,11 +174,10 @@ class Processor {
       }
     }
     if (!(job instanceof import_database.Model)) {
-      job.upstreamId = prevJob instanceof import_database.Model ? prevJob.get("id") : null;
       job.nodeId = node.id;
       job.nodeKey = node.key;
     }
-    const savedJob = await this.saveJob(job);
+    const savedJob = this.saveJob(job);
     this.logger.info(
       `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) finished as status: ${savedJob.status}`
     );
@@ -230,6 +224,30 @@ class Processor {
     return this.exec(instruction.resume.bind(instruction), node, job);
   }
   async exit(s) {
+    if (this.jobsToSave.size) {
+      const newJobs = [];
+      for (const job of this.jobsToSave.values()) {
+        if (job.isNewRecord) {
+          newJobs.push(job);
+        } else {
+          await job.save({ transaction: this.mainTransaction });
+        }
+      }
+      if (newJobs.length) {
+        const JobsModel = this.options.plugin.db.getModel("jobs");
+        await JobsModel.bulkCreate(
+          newJobs.map((job) => job.toJSON()),
+          {
+            transaction: this.mainTransaction,
+            returning: false
+          }
+        );
+        for (const job of newJobs) {
+          job.isNewRecord = false;
+        }
+      }
+      this.jobsToSave.clear();
+    }
     if (typeof s === "number") {
       const status = this.constructor.StatusMap[s] ?? Math.sign(s);
       await this.execution.update({ status }, { transaction: this.mainTransaction });
@@ -240,32 +258,29 @@ class Processor {
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`);
     return null;
   }
-  // TODO(optimize)
   /**
    * @experimental
    */
-  async saveJob(payload) {
+  saveJob(payload) {
     const { database } = this.execution.constructor;
-    const { mainTransaction: transaction } = this;
     const { model } = database.getCollection("jobs");
     let job;
     if (payload instanceof model) {
-      job = await payload.save({ transaction });
-    } else if (payload.id) {
-      job = await model.findByPk(payload.id, { transaction });
-      await job.update(payload, { transaction });
+      job = payload;
+      job.set("updatedAt", /* @__PURE__ */ new Date());
     } else {
-      job = await model.create(
-        {
-          ...payload,
-          executionId: this.execution.id
-        },
-        { transaction }
-      );
+      job = model.build({
+        ...payload,
+        id: this.options.plugin.snowflake.getUniqueID().toString(),
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date(),
+        executionId: this.execution.id
+      });
     }
-    this.jobsMap.set(job.id, job);
+    this.jobsToSave.set(job.id, job);
     this.lastSavedJob = job;
-    this.jobsMapByNodeKey[job.nodeKey] = job.result;
+    this.jobsMapByNodeKey[job.nodeKey] = job;
+    this.jobResultsMapByNodeKey[job.nodeKey] = job.result;
     return job;
   }
   /**
@@ -319,31 +334,19 @@ class Processor {
    * @experimental
    */
   findBranchParentJob(job, node) {
-    for (let j = job; j; j = this.jobsMap.get(j.upstreamId)) {
-      if (j.nodeId === node.id) {
-        return j;
-      }
-    }
-    return null;
+    return this.jobsMapByNodeKey[node.key];
   }
   /**
    * @experimental
    */
   findBranchLastJob(node, job) {
-    const allJobs = Array.from(this.jobsMap.values());
+    const allJobs = Object.values(this.jobsMapByNodeKey);
     const branchJobs = [];
     for (let n = this.findBranchEndNode(node); n && n !== node.upstream; n = n.upstream) {
       branchJobs.push(...allJobs.filter((item) => item.nodeId === n.id));
     }
-    branchJobs.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-    for (let i = branchJobs.length - 1; i >= 0; i -= 1) {
-      for (let j = branchJobs[i]; j && j.id !== job.id; j = this.jobsMap.get(j.upstreamId)) {
-        if (j.upstreamId === job.id) {
-          return branchJobs[i];
-        }
-      }
-    }
-    return null;
+    branchJobs.sort((a, b) => a.updatedAt.getTime() - b.updatedAt.getTime());
+    return branchJobs[branchJobs.length - 1] || null;
   }
   /**
    * @experimental
@@ -362,12 +365,12 @@ class Processor {
     for (let n = includeSelfScope ? node : this.findBranchParentNode(node); n; n = this.findBranchParentNode(n)) {
       const instruction = this.options.plugin.instructions.get(n.type);
       if (typeof (instruction == null ? void 0 : instruction.getScope) === "function") {
-        $scopes[n.id] = $scopes[n.key] = instruction.getScope(n, this.jobsMapByNodeKey[n.key], this);
+        $scopes[n.id] = $scopes[n.key] = instruction.getScope(n, this.jobResultsMapByNodeKey[n.key], this);
       }
     }
     return {
       $context: this.execution.context,
-      $jobsMapByNodeKey: this.jobsMapByNodeKey,
+      $jobsMapByNodeKey: this.jobResultsMapByNodeKey,
       $system: systemFns,
       $scopes,
       $env: this.options.plugin.app.environment.getVariables()

package/dist/server/actions/nodes.js

@@ -51,7 +51,9 @@ async function create(context, next) {
   const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
   context.body = await db.sequelize.transaction(async (transaction) => {
     const workflow = await repository.getSourceModel(transaction);
-    if (workflow.executed) {
+    workflow.versionStats = await workflow.getVersionStats({ transaction });
+    const { executed } = workflow.versionStats;
+    if (executed) {
       context.throw(400, "Node could not be created in executed workflow");
     }
     const instance = await repository.create({
@@ -143,9 +145,9 @@ async function destroy(context, next) {
   const instance = await repository.findOne({
     filterByTk,
     fields: [...fields, "workflowId"],
-    appends: ["upstream", "downstream", "workflow"]
+    appends: ["upstream", "downstream", "workflow.versionStats.executed"]
   });
-  if (instance.workflow.executed) {
+  if (instance.workflow.versionStats.executed) {
     context.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
@@ -202,10 +204,10 @@ async function update(context, next) {
   context.body = await db.sequelize.transaction(async (transaction) => {
     const { workflow } = await repository.findOne({
       filterByTk,
-      appends: ["workflow.executed"],
+      appends: ["workflow.versionStats.executed"],
       transaction
     });
-    if (workflow.executed) {
+    if (workflow.versionStats.executed) {
       context.throw(400, "Nodes in executed workflow could not be reconfigured");
     }
     return repository.update({

package/dist/server/actions/workflowTasks.js

@@ -29,15 +29,17 @@ __export(workflowTasks_exports, {
   countMine: () => countMine
 });
 module.exports = __toCommonJS(workflowTasks_exports);
+var import_sequelize = require("sequelize");
 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
+      userId: context.state.currentUser.id,
+      workflowId: { [import_sequelize.Op.ne]: null }
     }
   }) || [];
-  next();
+  await next();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/actions/workflows.js

@@ -53,8 +53,11 @@ async function update(context, next) {
     whitelist: ["title", "description", "enabled", "triggerTitle", "config", "options"]
   });
   if (Object.keys(values).includes("config")) {
-    const workflow = await repository.findById(filterByTk);
-    if (workflow.get("executed")) {
+    const workflow = await repository.findOne({
+      filterByTk,
+      appends: ["versionStats"]
+    });
+    if (workflow.versionStats.executed) {
       return context.throw(400, "config of executed workflow can not be updated");
     }
   }

package/dist/server/collections/executions.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -23,53 +25,19 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var executions_exports = {};
 __export(executions_exports, {
   default: () => executions_default
 });
 module.exports = __toCommonJS(executions_exports);
-var executions_default = {
-  dumpRules: {
-    group: "log"
-  },
-  migrationRules: ["schema-only"],
-  name: "executions",
-  shared: true,
-  fields: [
-    {
-      type: "belongsTo",
-      name: "workflow"
-    },
-    {
-      type: "string",
-      name: "key"
-    },
-    {
-      type: "string",
-      name: "eventKey",
-      unique: true
-    },
-    {
-      type: "hasMany",
-      name: "jobs",
-      onDelete: "CASCADE"
-    },
-    {
-      type: "json",
-      name: "context"
-    },
-    {
-      type: "integer",
-      name: "status"
-    },
-    {
-      type: "json",
-      name: "stack"
-    },
-    {
-      type: "json",
-      name: "output"
-    }
-  ]
-};
+var import_executions = __toESM(require("../../common/collections/executions"));
+var executions_default = import_executions.default;