@nocobase/plugin-workflow 0.8.0-alpha.8 → 0.8.1-alpha.3

package/lib/server/Plugin.d.ts

@@ -1,21 +1,31 @@
-import { Transactionable } from '@nocobase/database';
 import { Plugin } from '@nocobase/server';
 import { Registry } from '@nocobase/utils';
 import { Instruction } from './instructions';
 import ExecutionModel from './models/Execution';
 import WorkflowModel from './models/Workflow';
-import Processor from './Processor';
 import { Trigger } from './triggers';
+import JobModel from './models/Job';
+declare type Pending = [ExecutionModel, JobModel?];
 export default class WorkflowPlugin extends Plugin {
     instructions: Registry<Instruction>;
     triggers: Registry<Trigger>;
     calculators: Registry<Function>;
     extensions: typeof import("./extensions/assignees").default[];
+    executing: ExecutionModel | null;
+    pending: Pending[];
+    events: [WorkflowModel, any, {
+        context?: any;
+    }][];
     onBeforeSave: (instance: WorkflowModel, options: any) => Promise<void>;
     load(): Promise<void>;
     toggle(workflow: WorkflowModel, enable?: boolean): void;
-    trigger(workflow: WorkflowModel, context: Object, options?: Transactionable & {
+    trigger(workflow: WorkflowModel, context: Object, options?: {
         context?: any;
-    }): Promise<ExecutionModel | null>;
-    createProcessor(execution: ExecutionModel, options?: {}): Processor;
+    }): void;
+    private prepare;
+    resume(job: any): Promise<void>;
+    private dispatch;
+    private process;
+    private createProcessor;
 }
+export {};

package/lib/server/Plugin.js

@@ -67,6 +67,18 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 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); }); }; }
@@ -81,6 +93,9 @@ class WorkflowPlugin extends _server().Plugin {
     this.triggers = new (_utils().Registry)();
     this.calculators = _calculators.default;
     this.extensions = _extensions.default;
+    this.executing = null;
+    this.pending = [];
+    this.events = [];
 
     this.onBeforeSave = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (instance, options) {
@@ -134,6 +149,89 @@ class WorkflowPlugin extends _server().Plugin {
         return _ref.apply(this, arguments);
       };
     }();
+
+    this.prepare = /*#__PURE__*/_asyncToGenerator(function* () {
+      var _options$context;
+
+      const event = _this.events.shift();
+
+      if (!event) {
+        return;
+      }
+
+      const _event = _slicedToArray(event, 3),
+            workflow = _event[0],
+            context = _event[1],
+            options = _event[2];
+
+      if ((_options$context = options.context) === null || _options$context === void 0 ? void 0 : _options$context.executionId) {
+        // NOTE: no transaction here for read-uncommitted execution
+        const existed = yield workflow.countExecutions({
+          where: {
+            id: options.context.executionId
+          }
+        });
+
+        if (existed) {
+          console.warn(`workflow ${workflow.id} has already been triggered in same execution (${options.context.executionId}), and newly triggering will be skipped.`);
+          return;
+        }
+      }
+
+      const execution = yield _this.db.sequelize.transaction( /*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator(function* (transaction) {
+          const execution = yield workflow.createExecution({
+            context,
+            key: workflow.key,
+            status: _constants.EXECUTION_STATUS.CREATED,
+            useTransaction: workflow.useTransaction
+          }, {
+            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;
+          return execution;
+        });
+
+        return function (_x3) {
+          return _ref3.apply(this, arguments);
+        };
+      }()); // NOTE: cache first execution for most cases
+
+      if (!_this.executing && !_this.pending.length) {
+        _this.pending.push([execution]);
+      }
+
+      if (_this.events.length) {
+        yield _this.prepare();
+      } else {
+        _this.dispatch();
+      }
+    });
   }
 
   load() {
@@ -145,6 +243,15 @@ class WorkflowPlugin extends _server().Plugin {
       yield db.import({
         directory: _path().default.resolve(__dirname, 'collections')
       });
+
+      _this2.db.addMigrations({
+        namespace: 'workflow',
+        directory: _path().default.resolve(__dirname, 'migrations'),
+        context: {
+          plugin: _this2
+        }
+      });
+
       (0, _actions.default)(_this2);
       (0, _triggers.default)(_this2, options.triggers);
       (0, _instructions.default)(_this2, options.instructions);
@@ -152,8 +259,8 @@ class WorkflowPlugin extends _server().Plugin {
       db.on('workflows.afterSave', model => _this2.toggle(model));
       db.on('workflows.afterDestroy', model => _this2.toggle(model, false));
 
-      _this2.app.on('afterLoadAll', /*#__PURE__*/_asyncToGenerator(function* () {
-        return _this2.extensions.reduce((promise, extend) => promise.then(() => extend(_this2)), Promise.resolve());
+      _this2.app.on('afterLoad', /*#__PURE__*/_asyncToGenerator(function* () {
+        _this2.extensions.reduce((promise, extend) => promise.then(() => extend(_this2)), Promise.resolve());
       })); // [Life Cycle]:
       //   * load all workflows in db
       //   * add all hooks for enabled workflows
@@ -169,7 +276,9 @@ class WorkflowPlugin extends _server().Plugin {
         });
         workflows.forEach(workflow => {
           _this2.toggle(workflow);
-        });
+        }); // check for not started executions
+
+        _this2.dispatch();
       }));
 
       _this2.app.on('beforeStop', /*#__PURE__*/_asyncToGenerator(function* () {
@@ -205,81 +314,87 @@ class WorkflowPlugin extends _server().Plugin {
   }
 
   trigger(workflow, context, options = {}) {
+    // `null` means not to trigger
+    if (context == null) {
+      return;
+    }
+
+    this.events.push([workflow, context, options]);
+
+    if (this.events.length > 1) {
+      return;
+    } // NOTE: no await for quick return
+
+
+    setTimeout(this.prepare);
+  }
+
+  resume(job) {
     var _this3 = this;
 
     return _asyncToGenerator(function* () {
-      // `null` means not to trigger
-      if (context === null) {
-        return null;
+      if (!job.execution) {
+        job.execution = yield job.getExecution();
       }
 
-      let transaction = null;
+      _this3.pending.push([job.execution, job]);
 
-      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
+      _this3.dispatch();
+    })();
+  }
+
+  dispatch() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_this4.executing) {
+        return;
+      }
+
+      let next = null; // resuming has high priority
+
+      if (_this4.pending.length) {
+        next = _this4.pending.shift();
+      } else {
+        const execution = yield _this4.db.getRepository('executions').findOne({
+          filter: {
+            status: _constants.EXECUTION_STATUS.CREATED
           },
-          transaction
+          sort: 'createdAt'
         });
 
-        if (existed) {
-          console.warn(`workflow ${workflow.id} has already been triggered in same execution (${transaction.id}), and newly triggering will be skipped.`);
-          return null;
+        if (execution) {
+          next = [execution];
         }
       }
 
-      const execution = yield workflow.createExecution({
-        context,
-        key: workflow.key,
-        status: _constants.EXECUTION_STATUS.STARTED,
-        useTransaction: workflow.useTransaction,
-        transaction: transaction.id
-      }, {
-        transaction
-      });
-      console.log('workflow triggered:', new Date(), workflow.id, execution.id);
-      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,
-        _context: options.context
-      });
+      if (next) {
+        _this4.process(...next);
+      }
+    })();
+  }
 
-      yield processor.start(); // @ts-ignore
+  process(execution, job) {
+    var _this5 = this;
 
-      if (transaction && (!options.transaction || options.transaction.finished)) {
-        yield transaction.commit();
+    return _asyncToGenerator(function* () {
+      _this5.executing = execution;
+
+      if (execution.status === _constants.EXECUTION_STATUS.CREATED) {
+        yield execution.update({
+          status: _constants.EXECUTION_STATUS.STARTED
+        });
       }
 
-      return execution;
+      const processor = _this5.createProcessor(execution);
+
+      console.log('workflow processing:', new Date(), execution.workflowId, execution.id);
+      yield job ? processor.resume(job) : processor.start();
+      _this5.executing = null;
+
+      _this5.dispatch();
     })();
   }
 

package/lib/server/Processor.d.ts

@@ -4,7 +4,6 @@ import ExecutionModel from './models/Execution';
 import JobModel from './models/Job';
 import FlowNodeModel from './models/FlowNode';
 export interface ProcessorOptions extends Transactionable {
-    _context?: any;
     plugin: Plugin;
 }
 export default class Processor {
@@ -24,7 +23,7 @@ export default class Processor {
     private makeNodes;
     private makeJobs;
     private getTransaction;
-    prepare(commit?: boolean): Promise<void>;
+    private prepare;
     start(): Promise<void>;
     resume(job: JobModel): Promise<void>;
     private commit;

package/lib/server/Processor.js

@@ -101,25 +101,13 @@ class Processor {
         return;
       }
 
-      const options = _this.options;
-      const sequelize = _this.execution.constructor.database.sequelize; // @ts-ignore
+      const options = _this.options; // @ts-ignore
 
-      const transaction = options.transaction && !options.transaction.finished ? options.transaction : yield sequelize.transaction(); // @ts-ignore
-
-      if (_this.execution.transaction !== transaction.id) {
-        // @ts-ignore
-        yield _this.execution.update({
-          transaction: transaction.id
-        }, {
-          transaction
-        });
-      }
-
-      return transaction;
+      return options.transaction && !options.transaction.finished ? options.transaction : yield options.plugin.db.sequelize.transaction();
     })();
   }
 
-  prepare(commit) {
+  prepare() {
     var _this2 = this;
 
     return _asyncToGenerator(function* () {
@@ -145,10 +133,6 @@ class Processor {
       });
 
       _this2.makeJobs(jobs);
-
-      if (commit) {
-        yield _this2.commit();
-      }
     })();
   }
 

package/lib/server/actions/jobs.js

@@ -31,10 +31,9 @@ function _submit() {
     });
     context.status = 202;
     yield next();
-    const plugin = context.app.pm.get('workflow');
-    const processor = plugin.createProcessor(instance.execution); // NOTE: resume the process and no `await` for quick returning
+    const plugin = context.app.pm.get('workflow'); // NOTE: resume the process and no `await` for quick returning
 
-    processor.resume(instance);
+    plugin.resume(instance);
   });
   return _submit.apply(this, arguments);
 }

package/lib/server/actions/workflows.js

@@ -138,23 +138,31 @@ function _revision() {
 
     const repository = _actions().utils.getRepositoryFromParams(context);
 
-    const filterByTk = context.action.params.filterByTk;
+    const _context$action$param2 = context.action.params,
+          filterByTk = _context$action$param2.filterByTk,
+          _context$action$param3 = _context$action$param2.filter,
+          filter = _context$action$param3 === void 0 ? {} : _context$action$param3;
     context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (transaction) {
         const origin = yield repository.findOne({
           filterByTk,
+          filter,
           appends: ['nodes'],
           context,
           transaction
         });
+        const revisionData = filter.key ? {
+          key: filter.key,
+          title: origin.title,
+          allExecuted: origin.allExecuted
+        } : {};
         const instance = yield repository.create({
-          values: {
-            key: origin.key,
-            title: origin.title,
+          values: _objectSpread({
+            title: `${origin.title} copy`,
             description: origin.description,
             type: origin.type,
             config: origin.config
-          },
+          }, revisionData),
           transaction
         });
         const originalNodesMap = new Map();

package/lib/server/calculators/index.d.ts

@@ -5,6 +5,7 @@ export declare const calculators: Registry<Function>;
 export default calculators;
 export declare type OperandType = '$context' | '$input' | '$jobsMapByNodeId' | '$calculation';
 export declare type ObjectGetterOptions = {
+    type?: string;
     path?: string;
 };
 export declare type JobGetterOptions = ObjectGetterOptions & {
@@ -14,6 +15,7 @@ export declare type CalculationOptions = {
     calculator: string;
     operands: Operand[];
 };
+export declare type ValueOperand = string | number | boolean | null | Date;
 export declare type ConstantOperand = {
     type?: 'constant';
     value: any;
@@ -34,5 +36,5 @@ export declare type Calculation = {
     type: '$calculation';
     options: CalculationOptions;
 };
-export declare type Operand = ContextOperand | InputOperand | JobOperand | ConstantOperand | Calculation;
-export declare function calculate(operand: Operand, lastJob: JobModel, processor: Processor): any;
+export declare type Operand = ValueOperand | ContextOperand | InputOperand | JobOperand | ConstantOperand | Calculation;
+export declare function calculate(operand: any, lastJob: JobModel, processor: Processor): any;

package/lib/server/calculators/index.js

@@ -44,17 +44,19 @@ function get(object, path) {
 
 
 function calculate(operand, lastJob, processor) {
+  if (typeof operand !== 'object' || operand == null) {
+    return operand;
+  } // @Deprecated
+
+
   switch (operand.type) {
-    // @Deprecated
     // from execution context
     case '$context':
-      return get(processor.execution.context, operand.options.path);
-    // @Deprecated
+      return get(processor.execution.context, [operand.options.type, operand.options.path].filter(Boolean).join('.'));
     // from last job (or input job)
 
     case '$input':
       return lastJob !== null && lastJob !== void 0 ? lastJob : get(lastJob.result, operand.options.path);
-    // @Deprecated
     // from job in execution
 
     case '$jobsMapByNodeId':

package/lib/server/collections/executions.js

@@ -16,7 +16,8 @@ var _default = {
     type: 'boolean',
     name: 'useTransaction',
     defaultValue: false
-  }, {
+  }, // @deprecated
+  {
     type: 'uuid',
     name: 'transaction',
     defaultValue: null

package/lib/server/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const EXECUTION_STATUS: {
+    CREATED: any;
     STARTED: number;
     RESOLVED: number;
     REJECTED: number;

package/lib/server/constants.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.JOB_STATUS = exports.EXECUTION_STATUS = exports.BRANCH_INDEX = void 0;
 const EXECUTION_STATUS = {
+  CREATED: null,
   STARTED: 0,
   RESOLVED: 1,
   REJECTED: -1,

package/lib/server/extensions/assignees/actions.js

@@ -67,10 +67,9 @@ function _submit() {
     context.status = 202;
     yield next();
     instance.job.latestUserJob = instance;
-    const plugin = context.app.pm.get('workflow');
-    const processor = plugin.createProcessor(instance.execution); // NOTE: resume the process and no `await` for quick returning
+    const plugin = context.app.pm.get('workflow'); // NOTE: resume the process and no `await` for quick returning
 
-    processor.resume(instance.job);
+    plugin.resume(instance.job);
   });
   return _submit.apply(this, arguments);
 }

package/lib/server/extensions/assignees/collections/users_jobs.js

@@ -7,10 +7,18 @@ exports.default = void 0;
 var _default = {
   name: 'users_jobs',
   fields: [{
-    type: 'integer',
+    type: 'bigInt',
     name: 'id',
     primaryKey: true,
     autoIncrement: true
+  }, {
+    type: 'bigInt',
+    name: 'userId',
+    primaryKey: false
+  }, {
+    type: 'bigInt',
+    name: 'jobId',
+    primaryKey: false
   }, {
     type: 'belongsTo',
     name: 'job'

package/lib/server/index.d.ts

@@ -1,6 +1,5 @@
-export * from './calculators';
 export * from './constants';
-export * from './instructions';
-export * from './triggers';
-export * from './Processor';
+export * from './calculators';
+export { Trigger } from './triggers';
+export { default as Processor } from './Processor';
 export { default } from './Plugin';

package/lib/server/index.js

@@ -3,7 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _exportNames = {};
+var _exportNames = {
+  Trigger: true,
+  Processor: true
+};
+Object.defineProperty(exports, "Processor", {
+  enumerable: true,
+  get: function get() {
+    return _Processor.default;
+  }
+});
+Object.defineProperty(exports, "Trigger", {
+  enumerable: true,
+  get: function get() {
+    return _triggers.Trigger;
+  }
+});
 Object.defineProperty(exports, "default", {
   enumerable: true,
   get: function get() {
@@ -11,20 +26,6 @@ Object.defineProperty(exports, "default", {
   }
 });
 
-var _calculators = require("./calculators");
-
-Object.keys(_calculators).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _calculators[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _calculators[key];
-    }
-  });
-});
-
 var _constants = require("./constants");
 
 Object.keys(_constants).forEach(function (key) {
@@ -39,47 +40,23 @@ Object.keys(_constants).forEach(function (key) {
   });
 });
 
-var _instructions = require("./instructions");
+var _calculators = require("./calculators");
 
-Object.keys(_instructions).forEach(function (key) {
+Object.keys(_calculators).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _instructions[key]) return;
+  if (key in exports && exports[key] === _calculators[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _instructions[key];
+      return _calculators[key];
     }
   });
 });
 
 var _triggers = require("./triggers");
 
-Object.keys(_triggers).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _triggers[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _triggers[key];
-    }
-  });
-});
-
-var _Processor = require("./Processor");
-
-Object.keys(_Processor).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _Processor[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _Processor[key];
-    }
-  });
-});
+var _Processor = _interopRequireDefault(require("./Processor"));
 
 var _Plugin = _interopRequireDefault(require("./Plugin"));
 

package/lib/server/instructions/condition.js

@@ -80,7 +80,7 @@ var _default = {
             calculation = _ref.calculation,
             rejectOnFalse = _ref.rejectOnFalse;
 
-      const result = logicCalculate(calculation, prevJob, processor);
+      const result = logicCalculate(processor.getParsedValue(calculation), prevJob, processor);
 
       if (!result && rejectOnFalse) {
         return {