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

package/lib/instructions/index.js

@@ -3,7 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.instructions = exports.default = void 0;
+exports.default = _default;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
 
 function _utils() {
   const data = require("@nocobase/utils");
@@ -33,15 +43,35 @@ var _destroy = _interopRequireDefault(require("./destroy"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const instructions = new (_utils().Registry)();
-exports.instructions = instructions;
-instructions.register('prompt', _prompt.default);
-instructions.register('calculation', _calculation.default);
-instructions.register('condition', _condition.default);
-instructions.register('parallel', _parallel.default);
-instructions.register('query', _query.default);
-instructions.register('create', _create.default);
-instructions.register('update', _update.default);
-instructions.register('destroy', _destroy.default);
-var _default = instructions;
-exports.default = _default;
+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 _default(plugin, more = {}) {
+  const instructions = plugin.instructions;
+  instructions.register('prompt', _prompt.default);
+  instructions.register('calculation', _calculation.default);
+  instructions.register('condition', _condition.default);
+  instructions.register('parallel', _parallel.default);
+  instructions.register('query', _query.default);
+  instructions.register('create', _create.default);
+  instructions.register('update', _update.default);
+  instructions.register('destroy', _destroy.default);
+  instructions.register('delay', new ((0, _utils().requireModule)(_path().default.join(__dirname, 'delay')))(plugin));
+
+  for (var _i = 0, _Object$entries = Object.entries(more); _i < _Object$entries.length; _i++) {
+    const _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          name = _Object$entries$_i[0],
+          instruction = _Object$entries$_i[1];
+
+    instructions.register(name, typeof instruction === 'function' ? new instruction(plugin) : instruction);
+  }
+}

package/lib/instructions/parallel.d.ts

@@ -1,13 +1,13 @@
-import ExecutionModel from "../models/Execution";
 import FlowNodeModel from "../models/FlowNode";
 import JobModel from "../models/Job";
+import Processor from "../Processor";
 export declare const PARALLEL_MODE: {
     readonly ALL: "all";
     readonly ANY: "any";
     readonly RACE: "race";
 };
 declare const _default: {
-    run(this: FlowNodeModel, prevJob: JobModel, execution: ExecutionModel): Promise<any>;
-    resume(this: any, branchJob: any, execution: ExecutionModel): Promise<any>;
+    run(node: FlowNodeModel, prevJob: JobModel, processor: Processor): Promise<any>;
+    resume(node: FlowNodeModel, branchJob: any, processor: Processor): Promise<any>;
 };
 export default _default;

package/lib/instructions/parallel.js

@@ -40,34 +40,30 @@ const StatusGetters = {
 
 };
 var _default = {
-  run(prevJob, execution) {
-    var _this = this;
-
+  run(node, prevJob, processor) {
     return _asyncToGenerator(function* () {
       var _prevJob$id;
 
-      const branches = execution.nodes.filter(item => item.upstream === _this && item.branchIndex !== null).sort((a, b) => a.branchIndex - b.branchIndex);
-      const job = yield execution.saveJob({
+      const branches = processor.nodes.filter(item => item.upstream === node && item.branchIndex !== null).sort((a, b) => a.branchIndex - b.branchIndex);
+      const job = yield processor.saveJob({
         status: _constants.JOB_STATUS.PENDING,
         result: Array(branches.length).fill(null),
-        nodeId: _this.id,
+        nodeId: node.id,
         upstreamId: (_prevJob$id = prevJob === null || prevJob === void 0 ? void 0 : prevJob.id) !== null && _prevJob$id !== void 0 ? _prevJob$id : null
       }); // NOTE:
       // use `reduce` but not `Promise.all` here to avoid racing manupulating db.
       // for users, this is almost equivalent to `Promise.all`,
       // because of the delay is not significant sensible.
-      // another better aspect of this is, it could handle sequenced branches in future.
+      // another benifit of this is, it could handle sequenced branches in future.
 
-      yield branches.reduce((promise, branch) => promise.then(() => execution.run(branch, job)), Promise.resolve());
-      return execution.end(_this, job);
+      yield branches.reduce((promise, branch) => promise.then(() => processor.run(branch, job)), Promise.resolve());
+      return processor.end(node, job);
     })();
   },
 
-  resume(branchJob, execution) {
-    var _this2 = this;
-
+  resume(node, branchJob, processor) {
     return _asyncToGenerator(function* () {
-      const job = execution.findBranchParentJob(branchJob, _this2);
+      const job = processor.findBranchParentJob(branchJob, node);
       const result = job.result,
             status = job.status; // if parallel has been done (resolved / rejected), do not care newly executed branch jobs.
 
@@ -76,12 +72,12 @@ var _default = {
       } // find the index of the node which start the branch
 
 
-      const jobNode = execution.nodesMap.get(branchJob.nodeId);
+      const jobNode = processor.nodesMap.get(branchJob.nodeId);
 
-      const _execution$findBranch = execution.findBranchStartNode(jobNode),
-            branchIndex = _execution$findBranch.branchIndex;
+      const _processor$findBranch = processor.findBranchStartNode(jobNode),
+            branchIndex = _processor$findBranch.branchIndex;
 
-      const _ref = _this2.config || {},
+      const _ref = node.config || {},
             _ref$mode = _ref.mode,
             mode = _ref$mode === void 0 ? PARALLEL_MODE.ALL : _ref$mode;
 
@@ -93,9 +89,9 @@ var _default = {
 
       if (job.status === _constants.JOB_STATUS.PENDING) {
         yield job.save({
-          transaction: execution.tx
+          transaction: processor.transaction
         });
-        return execution.end(_this2, job);
+        return processor.end(node, job);
       }
 
       return job;

package/lib/instructions/prompt.d.ts

@@ -1,7 +1,7 @@
 declare const _default: {
-    run(this: any, input: any, execution: any): {
+    run(node: any, input: any, processor: any): {
         status: number;
     };
-    resume(this: any, job: any, execution: any): any;
+    resume(node: any, job: any, processor: any): any;
 };
 export default _default;

package/lib/instructions/prompt.js

@@ -8,13 +8,13 @@ exports.default = void 0;
 var _constants = require("../constants");
 
 var _default = {
-  run(input, execution) {
+  run(node, input, processor) {
     return {
       status: _constants.JOB_STATUS.PENDING
     };
   },
 
-  resume(job, execution) {
+  resume(node, job, processor) {
     job.set('status', _constants.JOB_STATUS.RESOLVED);
     return job;
   }

package/lib/instructions/query.d.ts

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

package/lib/instructions/query.js

@@ -18,21 +18,17 @@ 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,
-            multiple = _this$config.multiple,
-            _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,
+            multiple = _node$config.multiple,
+            _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 (multiple ? repo.find : repo.findOne).call(repo, _objectSpread(_objectSpread({}, options), {}, {
-        transaction: execution.tx
+        transaction: processor.transaction
       })); // NOTE: `toJSON()` to avoid getting undefined value from Proxied model instance (#380)
       // e.g. Object.prototype.hasOwnProperty.call(result, 'id') // false
       // so the properties can not be get by json-templates(object-path)

package/lib/instructions/update.d.ts

@@ -1,7 +1,7 @@
-import ExecutionModel from "../models/Execution";
 import FlowNodeModel from "../models/FlowNode";
+import Processor from "../Processor";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: ExecutionModel): Promise<{
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
         result: import("@nocobase/database").Model<any, any> | import("@nocobase/database").Model<any, any>[];
         status: number;
     }>;

package/lib/instructions/update.js

@@ -18,22 +18,18 @@ 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$multiple = _this$config.multiple,
-            multiple = _this$config$multiple === void 0 ? false : _this$config$multiple,
-            _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$multiple = _node$config.multiple,
+            multiple = _node$config$multiple === void 0 ? false : _node$config$multiple,
+            _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.update(_objectSpread(_objectSpread({}, options), {}, {
-        transaction: execution.tx
+        transaction: processor.transaction
       }));
       return {
         result: multiple ? result : result[0] || null,

package/lib/models/Execution.d.ts

@@ -1,11 +1,7 @@
 import { Database, Model } from '@nocobase/database';
-import { BelongsToGetAssociationMixin, HasManyGetAssociationsMixin, Transaction } from 'sequelize';
+import { BelongsToGetAssociationMixin, HasManyGetAssociationsMixin } from 'sequelize';
 import WorkflowModel from './Workflow';
-import FlowNodeModel from './FlowNode';
 import JobModel from './Job';
-export interface ExecutionOptions {
-    transaction?: Transaction;
-}
 export default class ExecutionModel extends Model {
     static readonly database: Database;
     id: number;
@@ -16,36 +12,9 @@ export default class ExecutionModel extends Model {
     transaction: string;
     createdAt: Date;
     updatedAt: Date;
+    key: string;
     workflow?: WorkflowModel;
     getWorkflow: BelongsToGetAssociationMixin<WorkflowModel>;
     jobs?: JobModel[];
     getJobs: HasManyGetAssociationsMixin<JobModel>;
-    options: ExecutionOptions;
-    tx: Transaction;
-    nodes: Array<FlowNodeModel>;
-    nodesMap: Map<number, FlowNodeModel>;
-    jobsMap: Map<number, JobModel>;
-    jobsMapByNodeId: {
-        [key: number]: any;
-    };
-    static StatusMap: {
-        [x: number]: number;
-    };
-    makeNodes(nodes?: any[]): void;
-    makeJobs(jobs: Array<JobModel>): void;
-    getTransaction(): Promise<Transaction>;
-    prepare(options: any, commit?: boolean): Promise<void>;
-    start(options: ExecutionOptions): Promise<void>;
-    resume(job: JobModel, options: ExecutionOptions): 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<JobModel>;
-    findBranchStartNode(node: FlowNodeModel): FlowNodeModel | null;
-    findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null;
-    findBranchParentJob(job: JobModel, node: FlowNodeModel): JobModel | null;
-    getParsedValue(value: any, node?: any): any;
 }