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

package/lib/instructions/create.js

@@ -1,27 +1,41 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+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); }); }; }
+
+var _default = {
+  run(node, input, processor) {
+    return _asyncToGenerator(function* () {
+      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: processor.transaction
+      }));
+      return {
+        // NOTE: get() for non-proxied instance (#380)
+        result: result.get(),
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-exports.default = {
-    run(input, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { collection, params = {} } = this.config;
-            const repo = this.constructor.database.getRepository(collection);
-            const options = execution.getParsedValue(params);
-            const result = yield repo.create(Object.assign(Object.assign({}, options), { transaction: execution.transaction }));
-            return {
-                result,
-                status: constants_1.JOB_STATUS.RESOLVED
-            };
-        });
-    }
-};
-//# sourceMappingURL=create.js.map
+exports.default = _default;

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

@@ -1,27 +1,40 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+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); }); }; }
+
+var _default = {
+  run(node, input, processor) {
+    return _asyncToGenerator(function* () {
+      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: processor.transaction
+      }));
+      return {
+        result,
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-exports.default = {
-    run(input, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { collection, params = {} } = this.config;
-            const repo = this.constructor.database.getRepository(collection);
-            const options = execution.getParsedValue(params);
-            const result = yield repo.destroy(Object.assign(Object.assign({}, options), { transaction: execution.transaction }));
-            return {
-                result,
-                status: constants_1.JOB_STATUS.RESOLVED
-            };
-        });
-    }
-};
-//# sourceMappingURL=destroy.js.map
+exports.default = _default;

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;

package/lib/instructions/index.js

@@ -1,26 +1,77 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.instructions = void 0;
-const utils_1 = require("@nocobase/utils");
-const prompt_1 = __importDefault(require("./prompt"));
-const calculation_1 = __importDefault(require("./calculation"));
-const condition_1 = __importDefault(require("./condition"));
-const parallel_1 = __importDefault(require("./parallel"));
-const query_1 = __importDefault(require("./query"));
-const create_1 = __importDefault(require("./create"));
-const update_1 = __importDefault(require("./update"));
-const destroy_1 = __importDefault(require("./destroy"));
-exports.instructions = new utils_1.Registry();
-exports.instructions.register('prompt', prompt_1.default);
-exports.instructions.register('calculation', calculation_1.default);
-exports.instructions.register('condition', condition_1.default);
-exports.instructions.register('parallel', parallel_1.default);
-exports.instructions.register('query', query_1.default);
-exports.instructions.register('create', create_1.default);
-exports.instructions.register('update', update_1.default);
-exports.instructions.register('destroy', destroy_1.default);
-exports.default = exports.instructions;
-//# sourceMappingURL=index.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _prompt = _interopRequireDefault(require("./prompt"));
+
+var _calculation = _interopRequireDefault(require("./calculation"));
+
+var _condition = _interopRequireDefault(require("./condition"));
+
+var _parallel = _interopRequireDefault(require("./parallel"));
+
+var _query = _interopRequireDefault(require("./query"));
+
+var _create = _interopRequireDefault(require("./create"));
+
+var _update = _interopRequireDefault(require("./update"));
+
+var _destroy = _interopRequireDefault(require("./destroy"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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 _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

@@ -1,91 +1,102 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PARALLEL_MODE = void 0;
-const constants_1 = require("../constants");
-exports.PARALLEL_MODE = {
-    ALL: 'all',
-    ANY: 'any',
-    RACE: 'race'
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PARALLEL_MODE = void 0;
+
+var _constants = require("../constants");
+
+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); }); }; }
+
+const PARALLEL_MODE = {
+  ALL: 'all',
+  ANY: 'any',
+  RACE: 'race'
 };
+exports.PARALLEL_MODE = PARALLEL_MODE;
 const StatusGetters = {
-    [exports.PARALLEL_MODE.ALL](result) {
-        if (result.some(j => j && j.status === constants_1.JOB_STATUS.REJECTED)) {
-            return constants_1.JOB_STATUS.REJECTED;
-        }
-        if (result.every(j => j && j.status === constants_1.JOB_STATUS.RESOLVED)) {
-            return constants_1.JOB_STATUS.RESOLVED;
-        }
-        return constants_1.JOB_STATUS.PENDING;
-    },
-    [exports.PARALLEL_MODE.ANY](result) {
-        return result.some(j => j && j.status === constants_1.JOB_STATUS.RESOLVED)
-            ? constants_1.JOB_STATUS.RESOLVED
-            : (result.some(j => j && j.status === constants_1.JOB_STATUS.PENDING)
-                ? constants_1.JOB_STATUS.PENDING
-                : constants_1.JOB_STATUS.REJECTED);
-    },
-    [exports.PARALLEL_MODE.RACE](result) {
-        return result.some(j => j && j.status === constants_1.JOB_STATUS.RESOLVED)
-            ? constants_1.JOB_STATUS.RESOLVED
-            : (result.some(j => j && j.status === constants_1.JOB_STATUS.REJECTED)
-                ? constants_1.JOB_STATUS.REJECTED
-                : constants_1.JOB_STATUS.PENDING);
+  [PARALLEL_MODE.ALL](result) {
+    if (result.some(j => j && j.status === _constants.JOB_STATUS.REJECTED)) {
+      return _constants.JOB_STATUS.REJECTED;
+    }
+
+    if (result.every(j => j && j.status === _constants.JOB_STATUS.RESOLVED)) {
+      return _constants.JOB_STATUS.RESOLVED;
     }
+
+    return _constants.JOB_STATUS.PENDING;
+  },
+
+  [PARALLEL_MODE.ANY](result) {
+    return result.some(j => j && j.status === _constants.JOB_STATUS.RESOLVED) ? _constants.JOB_STATUS.RESOLVED : result.some(j => j && j.status === _constants.JOB_STATUS.PENDING) ? _constants.JOB_STATUS.PENDING : _constants.JOB_STATUS.REJECTED;
+  },
+
+  [PARALLEL_MODE.RACE](result) {
+    return result.some(j => j && j.status === _constants.JOB_STATUS.RESOLVED) ? _constants.JOB_STATUS.RESOLVED : result.some(j => j && j.status === _constants.JOB_STATUS.REJECTED) ? _constants.JOB_STATUS.REJECTED : _constants.JOB_STATUS.PENDING;
+  }
+
 };
-exports.default = {
-    run(prevJob, execution) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const branches = execution.nodes
-                .filter(item => item.upstream === this && item.branchIndex !== null)
-                .sort((a, b) => a.branchIndex - b.branchIndex);
-            const job = yield execution.saveJob({
-                status: constants_1.JOB_STATUS.PENDING,
-                result: Array(branches.length).fill(null),
-                nodeId: this.id,
-                upstreamId: (_a = prevJob === null || prevJob === void 0 ? void 0 : prevJob.id) !== null && _a !== void 0 ? _a : 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.
-            yield branches.reduce((promise, branch) => promise.then(() => execution.run(branch, job)), Promise.resolve());
-            return execution.end(this, job);
+var _default = {
+  run(node, prevJob, processor) {
+    return _asyncToGenerator(function* () {
+      var _prevJob$id;
+
+      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: 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 benifit of this is, it could handle sequenced branches in future.
+
+      yield branches.reduce((promise, branch) => promise.then(() => processor.run(branch, job)), Promise.resolve());
+      return processor.end(node, job);
+    })();
+  },
+
+  resume(node, branchJob, processor) {
+    return _asyncToGenerator(function* () {
+      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.
+
+      if (status !== _constants.JOB_STATUS.PENDING) {
+        return null;
+      } // find the index of the node which start the branch
+
+
+      const jobNode = processor.nodesMap.get(branchJob.nodeId);
+
+      const _processor$findBranch = processor.findBranchStartNode(jobNode),
+            branchIndex = _processor$findBranch.branchIndex;
+
+      const _ref = node.config || {},
+            _ref$mode = _ref.mode,
+            mode = _ref$mode === void 0 ? PARALLEL_MODE.ALL : _ref$mode;
+
+      const newResult = [...result.slice(0, branchIndex), branchJob.get(), ...result.slice(branchIndex + 1)];
+      job.set({
+        result: newResult,
+        status: StatusGetters[mode](newResult)
+      });
+
+      if (job.status === _constants.JOB_STATUS.PENDING) {
+        yield job.save({
+          transaction: processor.transaction
         });
-    },
-    resume(branchJob, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const job = execution.findBranchParentJob(branchJob, this);
-            const { result, status } = job;
-            // if parallel has been done (resolved / rejected), do not care newly executed branch jobs.
-            if (status !== constants_1.JOB_STATUS.PENDING) {
-                return null;
-            }
-            // find the index of the node which start the branch
-            const jobNode = execution.nodesMap.get(branchJob.nodeId);
-            const { branchIndex } = execution.findBranchStartNode(jobNode);
-            const { mode = exports.PARALLEL_MODE.ALL } = this.config || {};
-            const newResult = [...result.slice(0, branchIndex), branchJob.get(), ...result.slice(branchIndex + 1)];
-            job.set({
-                result: newResult,
-                status: StatusGetters[mode](newResult)
-            });
-            if (job.status === constants_1.JOB_STATUS.PENDING) {
-                yield job.save({ transaction: execution.transaction });
-                return execution.end(this, job);
-            }
-            return job;
-        });
-    }
+        return processor.end(node, job);
+      }
+
+      return job;
+    })();
+  }
+
 };
-//# sourceMappingURL=parallel.js.map
+exports.default = _default;

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;