@nocobase/plugin-workflow 0.7.0-alpha.83 → 0.7.1-alpha.5

package/lib/collections/jobs.js

@@ -6,42 +6,23 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _default = {
   name: 'jobs',
-  title: '流程记录',
   fields: [{
-    interface: 'linkTo',
     type: 'belongsTo',
-    name: 'execution',
-    title: '所属流程'
+    name: 'execution'
   }, {
-    interface: 'linkTo',
     type: 'belongsTo',
     name: 'node',
-    target: 'flow_nodes',
-    title: '所属节点'
+    target: 'flow_nodes'
   }, {
-    interface: 'linkTo',
     type: 'belongsTo',
     name: 'upstream',
-    target: 'jobs',
-    title: '上游记录'
-  }, // pending / resolved / rejected
-  {
-    interface: 'status',
+    target: 'jobs'
+  }, {
     type: 'integer',
-    name: 'status',
-    title: '处理状态'
+    name: 'status'
   }, {
-    interface: 'json',
     type: 'jsonb',
-    name: 'result',
-    title: '处理结果'
-  } // TODO: possibly need node snapshot in case if node has been changed
-  // {
-  //   interface: 'json',
-  //   type: 'jsonb',
-  //   name: 'nodeSnapshot',
-  //   title: 'node snapshot'
-  // }
-  ]
+    name: 'result'
+  }]
 };
 exports.default = _default;

package/lib/collections/workflows.d.ts

@@ -1,3 +1,2 @@
 import { CollectionOptions } from '@nocobase/database';
-declare const _default: CollectionOptions;
-export default _default;
+export default function (): CollectionOptions;

package/lib/collections/workflows.js

@@ -3,70 +3,70 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _default = {
-  name: 'workflows',
-  model: 'WorkflowModel',
-  title: '自动化',
-  fields: [{
-    name: 'key',
-    type: 'uid'
-  }, {
-    type: 'string',
-    name: 'title',
-    title: '工作流名称',
-    required: true
-  }, {
-    type: 'boolean',
-    name: 'enabled',
-    title: '启用',
-    defaultValue: false
-  }, {
-    type: 'text',
-    name: 'description',
-    title: '描述'
-  }, {
-    type: 'string',
-    title: '触发方式',
-    name: 'type',
-    required: true
-  }, {
-    type: 'jsonb',
-    title: '触发配置',
-    name: 'config',
-    required: true,
-    defaultValue: {}
-  }, {
-    type: 'boolean',
-    title: '使用事务',
-    name: 'useTransaction',
-    defaultValue: true
-  }, {
-    type: 'hasMany',
-    name: 'nodes',
-    target: 'flow_nodes',
-    title: '流程节点'
-  }, {
-    type: 'hasMany',
-    name: 'executions',
-    target: 'executions',
-    title: '触发执行'
-  }, {
-    type: 'integer',
-    name: 'executed',
-    defaultValue: 0
-  }, {
-    type: 'boolean',
-    name: 'current',
-    defaultValue: false
-  }, {
-    type: 'hasMany',
-    name: 'revisions',
-    target: 'workflows',
-    foreignKey: 'key',
-    sourceKey: 'key',
-    // NOTE: no constraints needed here because tricky self-referencing
-    constraints: false
-  }]
-};
-exports.default = _default;
+exports.default = _default;
+
+function _default() {
+  return {
+    name: 'workflows',
+    fields: [{
+      name: 'key',
+      type: 'uid'
+    }, {
+      type: 'string',
+      name: 'title',
+      required: true
+    }, {
+      type: 'boolean',
+      name: 'enabled',
+      defaultValue: false
+    }, {
+      type: 'text',
+      name: 'description'
+    }, {
+      type: 'string',
+      name: 'type',
+      required: true
+    }, {
+      type: 'jsonb',
+      name: 'config',
+      required: true,
+      defaultValue: {}
+    }, {
+      type: 'boolean',
+      name: 'useTransaction',
+      defaultValue: true
+    }, {
+      type: 'hasMany',
+      name: 'nodes',
+      target: 'flow_nodes'
+    }, {
+      type: 'hasMany',
+      name: 'executions'
+    }, {
+      type: 'integer',
+      name: 'executed',
+      defaultValue: 0
+    }, {
+      type: 'integer',
+      name: 'allExecuted',
+      defaultValue: 0
+    }, {
+      type: 'boolean',
+      name: 'current',
+      defaultValue: null
+    }, {
+      type: 'hasMany',
+      name: 'revisions',
+      target: 'workflows',
+      foreignKey: 'key',
+      sourceKey: 'key',
+      // NOTE: no constraints needed here because tricky self-referencing
+      constraints: false
+    }],
+    // NOTE: use unique index for avoiding deadlock in mysql when setCurrent
+    indexes: [{
+      unique: true,
+      fields: ['key', 'current']
+    }]
+  };
+}

package/lib/index.d.ts

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

package/lib/index.js

@@ -7,10 +7,24 @@ var _exportNames = {};
 Object.defineProperty(exports, "default", {
   enumerable: true,
   get: function get() {
-    return _server.default;
+    return _Plugin.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) {
@@ -25,16 +39,16 @@ Object.keys(_constants).forEach(function (key) {
   });
 });
 
-var _calculators = require("./calculators");
+var _instructions = require("./instructions");
 
-Object.keys(_calculators).forEach(function (key) {
+Object.keys(_instructions).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;
+  if (key in exports && exports[key] === _instructions[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _calculators[key];
+      return _instructions[key];
     }
   });
 });
@@ -53,20 +67,20 @@ Object.keys(_triggers).forEach(function (key) {
   });
 });
 
-var _instructions = require("./instructions");
+var _Processor = require("./Processor");
 
-Object.keys(_instructions).forEach(function (key) {
+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] === _instructions[key]) return;
+  if (key in exports && exports[key] === _Processor[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _instructions[key];
+      return _Processor[key];
     }
   });
 });
 
-var _server = _interopRequireDefault(require("./server"));
+var _Plugin = _interopRequireDefault(require("./Plugin"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/instructions/calculation.d.ts

@@ -1,6 +1,6 @@
 import FlowNodeModel from "../models/FlowNode";
 declare const _default: {
-    run(this: FlowNodeModel, prevJob: any, execution: any): Promise<{
+    run(node: FlowNodeModel, prevJob: any, processor: any): Promise<{
         result: any;
         status: number;
     }>;

package/lib/instructions/calculation.js

@@ -40,17 +40,15 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
 //   ]
 // }
 var _default = {
-  run(prevJob, execution) {
-    var _this = this;
-
+  run(node, prevJob, processor) {
     return _asyncToGenerator(function* () {
-      const _ref = _this.config || {},
+      const _ref = node.config || {},
             calculation = _ref.calculation;
 
       const result = calculation ? (0, _calculators.calculate)({
         type: '$calculation',
-        options: execution.getParsedValue(calculation)
-      }, prevJob, execution) : null;
+        options: processor.getParsedValue(calculation)
+      }, prevJob, processor) : null;
       return {
         result,
         status: _constants.JOB_STATUS.RESOLVED

package/lib/instructions/condition.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    run(this: any, prevJob: any, execution: any): Promise<any>;
-    resume(this: any, branchJob: any, execution: any): Promise<any>;
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    resume(node: any, branchJob: any, processor: any): Promise<any>;
 };
 export default _default;

package/lib/instructions/condition.js

@@ -44,7 +44,7 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
 //     ]
 //   }
 // }
-function logicCalculate(calculation, input, execution) {
+function logicCalculate(calculation, input, processor) {
   if (!calculation) {
     return true;
   }
@@ -55,9 +55,9 @@ function logicCalculate(calculation, input, execution) {
 
   if (group) {
     const method = group.type === 'and' ? 'every' : 'some';
-    result = group.calculations[method](item => logicCalculate(item, input, execution));
+    result = group.calculations[method](item => logicCalculate(item, input, processor));
   } else {
-    const args = calculation.operands.map(operand => (0, _calculators.calculate)(operand, input, execution));
+    const args = calculation.operands.map(operand => (0, _calculators.calculate)(operand, input, processor));
 
     const fn = _calculators.default.get(calculation.calculator);
 
@@ -72,17 +72,15 @@ function logicCalculate(calculation, input, execution) {
 }
 
 var _default = {
-  run(prevJob, execution) {
-    var _this = this;
-
+  run(node, prevJob, processor) {
     return _asyncToGenerator(function* () {
-      // TODO(optimize): loading of jobs could be reduced and turned into incrementally in execution
-      // const jobs = await execution.getJobs();
-      const _ref = _this.config || {},
+      // TODO(optimize): loading of jobs could be reduced and turned into incrementally in processor
+      // const jobs = await processor.getJobs();
+      const _ref = node.config || {},
             calculation = _ref.calculation,
             rejectOnFalse = _ref.rejectOnFalse;
 
-      const result = logicCalculate(calculation, prevJob, execution);
+      const result = logicCalculate(calculation, prevJob, processor);
 
       if (!result && rejectOnFalse) {
         return {
@@ -95,31 +93,29 @@ var _default = {
         status: _constants.JOB_STATUS.RESOLVED,
         result,
         // TODO(optimize): try unify the building of job
-        nodeId: _this.id,
+        nodeId: node.id,
         upstreamId: prevJob && prevJob.id || null
       };
-      const branchNode = execution.nodes.find(item => item.upstream === _this && Boolean(item.branchIndex) === result);
+      const branchNode = processor.nodes.find(item => item.upstream === node && Boolean(item.branchIndex) === result);
 
       if (!branchNode) {
         return job;
       }
 
-      const savedJob = yield execution.saveJob(job);
-      return execution.run(branchNode, savedJob);
+      const savedJob = yield processor.saveJob(job);
+      return processor.run(branchNode, savedJob);
     })();
   },
 
-  resume(branchJob, execution) {
-    var _this2 = this;
-
+  resume(node, branchJob, processor) {
     return _asyncToGenerator(function* () {
       if (branchJob.status === _constants.JOB_STATUS.RESOLVED) {
-        // return to continue this.downstream
+        // return to continue node.downstream
         return branchJob;
       } // pass control to upper scope by ending current scope
 
 
-      return execution.end(_this2, branchJob);
+      return processor.end(node, branchJob);
     })();
   }
 

package/lib/instructions/create.d.ts

@@ -1,6 +1,6 @@
 import FlowNodeModel from "../models/FlowNode";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: any): Promise<{
+    run(node: FlowNodeModel, input: any, processor: any): Promise<{
         result: any;
         status: number;
     }>;

package/lib/instructions/create.js

@@ -18,20 +18,16 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 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); }); }; }
 
 var _default = {
-  run(input, execution) {
-    var _this = this;
-
+  run(node, input, processor) {
     return _asyncToGenerator(function* () {
-      const _this$config = _this.config,
-            collection = _this$config.collection,
-            _this$config$params = _this$config.params,
-            params = _this$config$params === void 0 ? {} : _this$config$params;
-
-      const repo = _this.constructor.database.getRepository(collection);
-
-      const options = execution.getParsedValue(params);
+      const _node$config = node.config,
+            collection = _node$config.collection,
+            _node$config$params = _node$config.params,
+            params = _node$config$params === void 0 ? {} : _node$config$params;
+      const repo = node.constructor.database.getRepository(collection);
+      const options = processor.getParsedValue(params);
       const result = yield repo.create(_objectSpread(_objectSpread({}, options), {}, {
-        transaction: execution.tx
+        transaction: processor.transaction
       }));
       return {
         // NOTE: get() for non-proxied instance (#380)

package/lib/instructions/delay.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import Plugin from '..';
+import Processor from '../Processor';
+export default class {
+    protected plugin: Plugin;
+    timers: Map<number, NodeJS.Timeout>;
+    constructor(plugin: Plugin);
+    load(): Promise<void>;
+    unload(): void;
+    schedule(job: any, duration: number): void;
+    trigger(job: any): Promise<void>;
+    run: (node: any, prevJob: any, processor: Processor) => Promise<any>;
+    resume: (node: any, prevJob: any, processor: Processor) => Promise<any>;
+}

package/lib/instructions/delay.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+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 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 _default {
+  constructor(plugin) {
+    var _this = this;
+
+    this.plugin = void 0;
+    this.timers = new Map();
+
+    this.run = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (node, prevJob, processor) {
+        var _prevJob$id;
+
+        const job = yield processor.saveJob({
+          status: _constants.JOB_STATUS.PENDING,
+          result: null,
+          nodeId: node.id,
+          upstreamId: (_prevJob$id = prevJob === null || prevJob === void 0 ? void 0 : prevJob.id) !== null && _prevJob$id !== void 0 ? _prevJob$id : null
+        });
+        const duration = node.config.duration; // add to schedule
+
+        _this.schedule(job, duration);
+
+        return processor.end(node, job);
+      });
+
+      return function (_x, _x2, _x3) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    this.resume = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (node, prevJob, processor) {
+        const endStatus = node.config.endStatus;
+        prevJob.set('status', endStatus);
+        return prevJob;
+      });
+
+      return function (_x4, _x5, _x6) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+
+    this.plugin = plugin;
+    plugin.app.on('beforeStart', () => this.load());
+    plugin.app.on('beforeStop', () => this.unload());
+  }
+
+  load() {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const _this2$plugin$db$getC = _this2.plugin.db.getCollection('jobs'),
+            model = _this2$plugin$db$getC.model;
+
+      const jobs = yield model.findAll({
+        where: {
+          status: _constants.JOB_STATUS.PENDING
+        },
+        include: [{
+          association: 'execution'
+        }, {
+          association: 'node',
+          where: {
+            type: 'delay'
+          },
+          required: true
+        }]
+      });
+      jobs.forEach(job => {
+        _this2.schedule(job, job.node.config.duration);
+      });
+    })();
+  }
+
+  unload() {
+    var _iterator = _createForOfIteratorHelper(this.timers.values()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const timer = _step.value;
+        clearTimeout(timer);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    this.timers = new Map();
+  }
+
+  schedule(job, duration) {
+    const now = new Date();
+    const createdAt = Date.parse(job.createdAt);
+    const delay = createdAt + duration - now.getTime();
+    const trigger = this.trigger.bind(this, job);
+    this.timers.set(job.id, setTimeout(trigger, Math.max(0, delay)));
+  }
+
+  trigger(job) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      const _job$execution = job.execution,
+            execution = _job$execution === void 0 ? yield job.getExecution() : _job$execution;
+
+      const processor = _this3.plugin.createProcessor(execution);
+
+      yield processor.resume(job);
+
+      if (_this3.timers.get(job.id)) {
+        _this3.timers.delete(job.id);
+      }
+    })();
+  }
+
+}
+
+exports.default = _default;

package/lib/instructions/destroy.d.ts

@@ -1,6 +1,6 @@
 import FlowNodeModel from "../models/FlowNode";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: any): Promise<{
+    run(node: FlowNodeModel, input: any, processor: any): Promise<{
         result: any;
         status: number;
     }>;

package/lib/instructions/destroy.js

@@ -18,20 +18,16 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 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); }); }; }
 
 var _default = {
-  run(input, execution) {
-    var _this = this;
-
+  run(node, input, processor) {
     return _asyncToGenerator(function* () {
-      const _this$config = _this.config,
-            collection = _this$config.collection,
-            _this$config$params = _this$config.params,
-            params = _this$config$params === void 0 ? {} : _this$config$params;
-
-      const repo = _this.constructor.database.getRepository(collection);
-
-      const options = execution.getParsedValue(params);
+      const _node$config = node.config,
+            collection = _node$config.collection,
+            _node$config$params = _node$config.params,
+            params = _node$config$params === void 0 ? {} : _node$config$params;
+      const repo = node.constructor.database.getRepository(collection);
+      const options = processor.getParsedValue(params);
       const result = yield repo.destroy(_objectSpread(_objectSpread({}, options), {}, {
-        transaction: execution.tx
+        transaction: processor.transaction
       }));
       return {
         result,

package/lib/instructions/index.d.ts

@@ -1,15 +1,18 @@
-import { Registry } from '@nocobase/utils';
-import ExecutionModel from '../models/Execution';
 import FlowNodeModel from '../models/FlowNode';
-export interface Job {
+import Plugin from '..';
+import Processor from '../Processor';
+export declare type Job = {
     status: number;
     result?: unknown;
     [key: string]: unknown;
-}
+} | null;
 export declare type InstructionResult = Job | Promise<Job>;
 export interface Instruction {
-    run(this: FlowNodeModel, input: any, execution: ExecutionModel): InstructionResult;
-    resume?(this: FlowNodeModel, input: any, execution: ExecutionModel): InstructionResult;
+    run(node: FlowNodeModel, input: any, processor: Processor): InstructionResult;
+    resume?(node: FlowNodeModel, input: any, processor: Processor): InstructionResult;
 }
-export declare const instructions: Registry<Instruction>;
-export default instructions;
+export default function <T extends Instruction>(plugin: any, more?: {
+    [key: string]: T | {
+        new (p: Plugin): T;
+    };
+}): void;