@nocobase/plugin-workflow 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/Plugin.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from '@nocobase/server';
+import { Transactionable } from '@nocobase/database';
+import { Registry } from '@nocobase/utils';
+import { Trigger } from './triggers';
+import { Instruction } from './instructions';
+import Processor from './Processor';
+import WorkflowModel from './models/Workflow';
+import ExecutionModel from './models/Execution';
+export default class WorkflowPlugin extends Plugin {
+    instructions: Registry<Instruction>;
+    triggers: Registry<Trigger>;
+    onBeforeSave: (instance: WorkflowModel, options: any) => Promise<void>;
+    getName(): string;
+    load(): Promise<void>;
+    toggle(workflow: WorkflowModel, enable?: boolean): void;
+    trigger(workflow: any, context: Object, options?: Transactionable): Promise<any>;
+    createProcessor(execution: ExecutionModel, options?: {}): Processor;
+}

package/lib/Plugin.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _server() {
+  const data = require("@nocobase/server");
+
+  _server = function _server() {
+    return data;
+  };
+
+  return data;
+}
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _actions = _interopRequireDefault(require("./actions"));
+
+var _triggers = _interopRequireDefault(require("./triggers"));
+
+var _instructions = _interopRequireDefault(require("./instructions"));
+
+var _Processor = _interopRequireDefault(require("./Processor"));
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+class WorkflowPlugin extends _server().Plugin {
+  constructor(...args) {
+    var _this;
+
+    super(...args);
+    _this = this;
+    this.instructions = new (_utils().Registry)();
+    this.triggers = new (_utils().Registry)();
+
+    this.onBeforeSave = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (instance, options) {
+        const Model = instance.constructor;
+
+        if (instance.enabled) {
+          instance.set('current', true);
+        } else if (!instance.current) {
+          const count = yield Model.count({
+            where: {
+              key: instance.key
+            },
+            transaction: options.transaction
+          });
+
+          if (!count) {
+            instance.set('current', true);
+          }
+        }
+
+        if (!instance.changed('enabled') || !instance.enabled) {
+          return;
+        }
+
+        const previous = yield Model.findOne({
+          where: {
+            key: instance.key,
+            current: true,
+            id: {
+              [_database().Op.ne]: instance.id
+            }
+          },
+          transaction: options.transaction
+        });
+
+        if (previous) {
+          // NOTE: set to `null` but not `false` will not violate the unique index
+          yield previous.update({
+            enabled: false,
+            current: null
+          }, {
+            transaction: options.transaction,
+            hooks: false
+          });
+
+          _this.toggle(previous, false);
+        }
+      });
+
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  }
+
+  getName() {
+    return this.getPackageName(__dirname);
+  }
+
+  load() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const db = _this2.db,
+            options = _this2.options;
+      yield db.import({
+        directory: _path().default.resolve(__dirname, 'collections')
+      });
+      (0, _actions.default)(_this2);
+      (0, _triggers.default)(_this2, options.triggers);
+      (0, _instructions.default)(_this2, options.instructions);
+      db.on('workflows.beforeSave', _this2.onBeforeSave);
+      db.on('workflows.afterSave', model => _this2.toggle(model));
+      db.on('workflows.afterDestroy', model => _this2.toggle(model, false)); // [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
+
+      _this2.app.on('beforeStart', /*#__PURE__*/_asyncToGenerator(function* () {
+        const collection = db.getCollection('workflows');
+        const workflows = yield collection.repository.find({
+          filter: {
+            enabled: true
+          }
+        });
+        workflows.forEach(workflow => {
+          _this2.toggle(workflow);
+        });
+      }));
+
+      _this2.app.on('beforeStop', /*#__PURE__*/_asyncToGenerator(function* () {
+        const collection = db.getCollection('workflows');
+        const workflows = yield collection.repository.find({
+          filter: {
+            enabled: true
+          }
+        });
+        workflows.forEach(workflow => {
+          _this2.toggle(workflow, false);
+        });
+      }));
+    })();
+  }
+
+  toggle(workflow, enable) {
+    const type = workflow.get('type');
+    const trigger = this.triggers.get(type);
+
+    if (typeof enable !== 'undefined' ? enable : workflow.get('enabled')) {
+      // NOTE: remove previous listener if config updated
+      const prev = workflow.previous();
+
+      if (prev.config) {
+        trigger.off(_objectSpread(_objectSpread({}, workflow.get()), prev));
+      }
+
+      trigger.on(workflow);
+    } else {
+      trigger.off(workflow);
+    }
+  }
+
+  trigger(workflow, context, options = {}) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      // `null` means not to trigger
+      if (context === null) {
+        return;
+      }
+
+      let transaction = null;
+
+      if (workflow.useTransaction) {
+        // @ts-ignore
+        transaction = options.transaction && !options.transaction.finished ? options.transaction : yield workflow.constructor.database.sequelize.transaction();
+        const existed = yield workflow.countExecutions({
+          where: {
+            transaction: transaction.id
+          },
+          transaction
+        });
+
+        if (existed) {
+          console.warn(`workflow ${workflow.id} has already been triggered in same execution (${transaction.id}), and newly triggering will be skipped.`);
+          return;
+        }
+      }
+
+      const execution = yield workflow.createExecution({
+        context,
+        key: workflow.key,
+        status: _constants.EXECUTION_STATUS.STARTED,
+        useTransaction: workflow.useTransaction,
+        transaction: transaction.id
+      }, {
+        transaction
+      });
+      const executed = yield workflow.countExecutions({
+        transaction
+      }); // NOTE: not to trigger afterUpdate hook here
+
+      yield workflow.update({
+        executed
+      }, {
+        transaction,
+        hooks: false
+      });
+      const allExecuted = yield execution.constructor.count({
+        where: {
+          key: workflow.key
+        },
+        transaction
+      });
+      yield workflow.constructor.update({
+        allExecuted
+      }, {
+        where: {
+          key: workflow.key
+        },
+        individualHooks: true,
+        transaction
+      });
+      execution.workflow = workflow;
+
+      const processor = _this3.createProcessor(execution, {
+        transaction
+      });
+
+      yield processor.start(); // @ts-ignore
+
+      if (transaction && (!options.transaction || options.transaction.finished)) {
+        yield transaction.commit();
+      }
+
+      return execution;
+    })();
+  }
+
+  createProcessor(execution, options = {}) {
+    return new _Processor.default(execution, _objectSpread(_objectSpread({}, options), {}, {
+      plugin: this
+    }));
+  }
+
+}
+
+exports.default = WorkflowPlugin;

package/lib/Processor.d.ts

@@ -0,0 +1,40 @@
+import { Transaction, Transactionable } from 'sequelize';
+import Plugin from '.';
+import ExecutionModel from './models/Execution';
+import JobModel from './models/Job';
+import FlowNodeModel from './models/FlowNode';
+export interface ProcessorOptions extends Transactionable {
+    plugin: Plugin;
+}
+export default class Processor {
+    execution: ExecutionModel;
+    private options;
+    static StatusMap: {
+        [x: number]: number;
+    };
+    transaction: Transaction;
+    nodes: FlowNodeModel[];
+    nodesMap: Map<number, FlowNodeModel>;
+    jobsMap: Map<number, JobModel>;
+    jobsMapByNodeId: {
+        [key: number]: any;
+    };
+    constructor(execution: ExecutionModel, options: ProcessorOptions);
+    private makeNodes;
+    private makeJobs;
+    private getTransaction;
+    prepare(commit?: boolean): Promise<void>;
+    start(): Promise<void>;
+    resume(job: JobModel): Promise<void>;
+    private commit;
+    private exec;
+    run(node: any, input?: any): any;
+    end(node: any, job: any): any;
+    recall(node: any, job: any): any;
+    exit(job: JobModel | null): Promise<any>;
+    saveJob(payload: any): Promise<any>;
+    findBranchStartNode(node: FlowNodeModel): FlowNodeModel | null;
+    findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null;
+    findBranchParentJob(job: JobModel, node: FlowNodeModel): JobModel | null;
+    getParsedValue(value: any, node?: any): any;
+}