@logicflow/engine 0.0.10-beta.0 → 0.0.11-beta.0

package/es/FlowModel.js

@@ -1,23 +1,71 @@
-import { __awaiter } from "tslib";
-import { Scheduler } from './Scheduler';
-import { createExecId } from './utils';
-import { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, EVENT_INSTANCE_ERROR, } from './constant';
-import { ErrorCode, getErrorMsg } from './constant/logCode';
-export class FlowModel {
-    constructor({ nodeModelMap, recorder, context = {}, globalData = {}, startNodeType = 'StartNode', }) {
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, EVENT_INSTANCE_ERROR, } from './constant/constant';
+import { createExecId } from './util/ID';
+import Scheduler from './Scheduler';
+import { ErrorCode, getErrorMsg } from './constant/LogCode';
+var FlowModel = /** @class */ (function () {
+    function FlowModel(_a) {
+        var _this = this;
+        var nodeModelMap = _a.nodeModelMap, recorder = _a.recorder, _b = _a.context, context = _b === void 0 ? {} : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c, _d = _a.startNodeType, startNodeType = _d === void 0 ? 'StartNode' : _d;
         /**
-         * 当前流程模型中的所有节点，边会被转换成节点的 incoming 和 outgoing 属性
+         * 当前流程模型中的所有节点，边会被转换成节点的incoming和outgoing属性。
          */
         this.nodeConfigMap = new Map();
         /**
-         * 当前流程中开始节点组成的数组
+         * 当前流程中开始节点组成的数组。
          */
         this.startNodes = [];
         /**
-         * 用于存储全局数据，最终会传递给每个节点
+         * 用于存储全局数据，可以在流程中共享。
          */
         this.globalData = {};
-        // 流程包含的节点类型 ??? 在 load 代码中又初始化了一遍，为什么要传进来
+        // 流程包含的节点类型
         this.nodeModelMap = nodeModelMap;
         // 需要执行的队列
         this.executeList = [];
@@ -25,25 +73,28 @@ export class FlowModel {
         this.executingInstance = null;
         // 外部传入的上下文，最终会传递给每个节点
         this.context = context;
-        // 用于存储全局数据，可以在流程中共享
+        // 用于存储全局数据，可以在流程中共享。
         this.globalData = globalData;
-        // 开始节点类型，在执行流程时，会从这些节点开始执行
+        // 开始节点类型，在执行流程时，会从这些节点开始执行。
         this.startNodeType = startNodeType;
         this.isRunning = false;
         this.scheduler = new Scheduler({
             flowModel: this,
-            recorder,
+            recorder: recorder,
         });
-        this.scheduler.on(EVENT_INSTANCE_COMPLETE, (result) => {
-            this.onExecuteFinished(result);
+        this.scheduler.on(EVENT_INSTANCE_COMPLETE, function (result) {
+            _this.onExecuteFinished(result);
         });
-        this.scheduler.on(EVENT_INSTANCE_INTERRUPTED, (result) => {
-            this.onExecuteFinished(result);
+        this.scheduler.on(EVENT_INSTANCE_INTERRUPTED, function (result) {
+            _this.onExecuteFinished(result);
         });
-        this.scheduler.on(EVENT_INSTANCE_ERROR, (result) => {
-            this.onExecuteFinished(result);
+        this.scheduler.on(EVENT_INSTANCE_ERROR, function (result) {
+            _this.onExecuteFinished(result);
         });
     }
+    FlowModel.prototype.setStartNodeType = function (startNodeType) {
+        this.startNodeType = startNodeType;
+    };
     /**
      * 解析LogicFlow图数据，将nodes和edges转换成节点格式。
      * 例如：
@@ -77,29 +128,32 @@ export class FlowModel {
      * 同时此方法还会找到所有的开始节点，方便后续执行时，从开始节点开始执行。
      * @param graphData 流程图数据
      */
-    load(graphData) {
-        const { nodes = [], edges = [] } = graphData;
-        nodes.forEach((node) => {
-            if (this.nodeModelMap.has(node.type)) {
-                const nodeConfig = {
+    FlowModel.prototype.load = function (graphData) {
+        var _this = this;
+        var _a = graphData.nodes, nodes = _a === void 0 ? [] : _a, _b = graphData.edges, edges = _b === void 0 ? [] : _b;
+        this.startNodes = [];
+        this.nodeConfigMap = new Map();
+        nodes.forEach(function (node) {
+            if (_this.nodeModelMap.has(node.type)) {
+                var nodeConfig = {
                     id: node.id,
                     type: node.type,
                     properties: node.properties,
                     incoming: [],
                     outgoing: [],
                 };
-                this.nodeConfigMap.set(node.id, nodeConfig);
-                if (node.type === this.startNodeType) {
-                    this.startNodes.push(nodeConfig);
+                _this.nodeConfigMap.set(node.id, nodeConfig);
+                if (node.type === _this.startNodeType) {
+                    _this.startNodes.push(nodeConfig);
                 }
             }
             else {
-                console.warn(`未识别的节点类型：${node.type}`);
+                console.warn("\u672A\u8BC6\u522B\u7684\u8282\u70B9\u7C7B\u578B: " + node.type);
             }
         });
-        edges.forEach((edge) => {
-            const sourceNode = this.nodeConfigMap.get(edge.sourceNodeId);
-            const targetNode = this.nodeConfigMap.get(edge.targetNodeId);
+        edges.forEach(function (edge) {
+            var sourceNode = _this.nodeConfigMap.get(edge.sourceNodeId);
+            var targetNode = _this.nodeConfigMap.get(edge.targetNodeId);
             if (sourceNode) {
                 sourceNode.outgoing.push({
                     id: edge.id,
@@ -107,7 +161,7 @@ export class FlowModel {
                     target: edge.targetNodeId,
                 });
             }
-            if (targetNode && targetNode.type !== this.startNodeType) {
+            if (targetNode && targetNode.type !== _this.startNodeType) {
                 targetNode.incoming.push({
                     id: edge.id,
                     properties: edge.properties,
@@ -115,118 +169,107 @@ export class FlowModel {
                 });
             }
         });
-    }
+    };
+    /**
+     * 执行流程, 每次执行都会生成一个唯一的executionId，用于区分不同的执行。
+     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行。
+     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
+     * example：
+     * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
+     * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
+     * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
+     * TODO: 去掉此处的对列，直接使用调度器的队列。
+     */
+    FlowModel.prototype.execute = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.createExecution(params);
+                return [2 /*return*/];
+            });
+        });
+    };
+    FlowModel.prototype.resume = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.createExecution(params);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
+     * @param nodeId 节点Id
+     * @returns 节点示例
+     */
+    FlowModel.prototype.createAction = function (nodeId) {
+        var nodeConfig = this.nodeConfigMap.get(nodeId);
+        var NodeModel = this.nodeModelMap.get(nodeConfig.type);
+        var action = new NodeModel({
+            nodeConfig: nodeConfig,
+            globalData: this.globalData,
+            context: this.context,
+        });
+        return action;
+    };
+    /**
+     * 更新流程全局数据
+     */
+    FlowModel.prototype.updateGlobalData = function (data) {
+        this.globalData = __assign(__assign({}, this.globalData), data);
+    };
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
+    FlowModel.prototype.onExecuteFinished = function (result) {
+        var index = this.executeList.findIndex(function (i) { return i.executionId === result.executionId; });
+        if (index !== -1) {
+            var callback = this.executeList[index].callback;
+            this.executeList.splice(index, 1);
+            callback && callback(result);
+        }
+    };
     /**
      * 从待执行队列中取出需要执行的内容。
-     * 会依次判断是否有 actionId、nodeId、executionId。
-     * 若存在 actionId，那么表示恢复执行
-     * 若存在 nodeId，那么表示从指定节点开始执行
-     * 若都不存在，那么新建一个 executionId，从开始节点开始执行
-     * @private
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
      */
-    createExecution(execParam) {
-        var _a;
-        this.executeList.push(execParam);
-        // 如果有 actionId，则表示恢复执行
-        // TODO: 待测试，确认该流程
-        if (execParam.actionId && execParam.nodeId && execParam.executionId) {
+    FlowModel.prototype.createExecution = function (execParams) {
+        var _this = this;
+        this.executeList.push(execParams);
+        // 如果有taskId，那么表示恢复执行
+        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
-                executionId: execParam.executionId,
-                actionId: execParam.actionId,
-                nodeId: execParam.nodeId,
-                data: execParam.data,
+                executionId: execParams.executionId,
+                actionId: execParams.actionId,
+                nodeId: execParams.nodeId,
+                data: execParams.data,
             });
             return;
         }
-        // 否则，判断 executionId 是否存在，使用 executionId 或创建新的 execution，从开始节点开始执行
-        // const executionId = execParam?.executionId || createExecId()
-        const executionId = createExecId();
-        execParam.executionId = executionId;
-        // 当指定了具体需要执行的节点时，执行下面方法
-        if (execParam === null || execParam === void 0 ? void 0 : execParam.nodeId) {
-            const nodeConfig = this.nodeConfigMap.get(execParam.nodeId);
+        var executionId = createExecId();
+        execParams.executionId = executionId;
+        if (execParams.nodeId) {
+            var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
-                (_a = execParam === null || execParam === void 0 ? void 0 : execParam.onError) === null || _a === void 0 ? void 0 : _a.call(execParam, new Error(`${getErrorMsg(ErrorCode.NONE_NODE_ID)}(${execParam.nodeId})`));
+                execParams.onError(new Error(getErrorMsg(ErrorCode.NONE_NODE_ID) + "(" + execParams.nodeId + ")"));
                 return;
             }
-            // 当指定了开始节点，且该节点存在，则直接以这个节点开始执行
             this.startNodes = [nodeConfig];
         }
-        this.startNodes.forEach((startNode) => {
-            this.scheduler.addAction({
-                executionId,
+        this.startNodes.forEach(function (startNode) {
+            _this.scheduler.addAction({
+                executionId: executionId,
                 nodeId: startNode.id,
             });
         });
-        // 所有的开始节点都执行
         this.scheduler.run({
-            executionId,
+            executionId: executionId,
         });
-    }
-    /**
-     * 执行流程，每次执行都会生成一个唯一的 executionId，用于区分不同的执行。
-     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行
-     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
-     * 例如：
-     * 一个流程存在两个开始节点，A 和 B，A 和 B 的下一个节点都是 C，C 的下两个节点是 D 和 E
-     * 外部分别触发了 A 和 B 的执行，那么 A 和 B 的执行是串行（即 A 执行完再执行 B），但是 D 和 E 的执行是并行的。
-     * 如果希望 A 和 B 的执行时并行的，就不能使用同一个流程模型执行，应该初始化两个。
-     * 下面直接使用调度器的队列
-     * @param params
-     */
-    execute(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.createExecution(params);
-        });
-    }
-    resume(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.createExecution(params);
-        });
-    }
-    /**
-     * 创建节点实例，每个节点实例都会有一个唯一的 actionId
-     * 通过 executionId, nodeId, actionId 可以唯一确定一个节点的某一次执行
-     * @param nodeId
-     * @returns 节点实例
-     */
-    // TODO: 确认下面这种场景，类型如何定义
-    createAction(nodeId) {
-        const nodeConfig = this.nodeConfigMap.get(nodeId);
-        if (nodeConfig) {
-            const NodeModel = this.nodeModelMap.get(nodeConfig.type);
-            if (!NodeModel) {
-                throw new Error('该 NodeModel 不存在，抛出异常');
-            }
-            return new NodeModel({
-                nodeConfig,
-                globalData: this.globalData,
-                context: this.context,
-            });
-        }
-    }
-    setStartNodeType(type) {
-        this.startNodeType = type;
-    }
-    updateGlobalData(data) {
-        // TODO: 数据的合并，是否考虑子项的合并（默认值的替换）
-        this.globalData = Object.assign(Object.assign({}, this.globalData), data);
-        return this.globalData;
-    }
-    /**
-     * 在执行完成后，通知外部此次之行完成
-     * 如果还存在待执行的任务，那么继续执行
-     * @param result
-     * @private
-     */
-    onExecuteFinished(result) {
-        const index = this.executeList.findIndex((i) => i.executionId === result.executionId);
-        if (index > -1) {
-            const { callback } = this.executeList[index];
-            this.executeList.splice(index, 1);
-            callback === null || callback === void 0 ? void 0 : callback(result);
-        }
-    }
-}
+    };
+    return FlowModel;
+}());
 export default FlowModel;
-//# sourceMappingURL=FlowModel.js.map

package/es/Scheduler.d.ts

@@ -1,78 +1,62 @@
-import { Engine } from '.';
-import Recorder from './recorder';
-import FlowModel from './FlowModel';
 import EventEmitter from './EventEmitter';
+import type { ActionParam, NodeParam, ResumeParam } from './types.d';
+import type FlowModel from './FlowModel';
+import type Recorder from './recorder';
+declare type ActionParamMap = Map<string, ActionParam>;
+declare type ExecutionId = string;
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
  */
-export declare class Scheduler extends EventEmitter {
+export default class Scheduler extends EventEmitter {
     /**
      * 当前需要执行的节点队列
      */
-    nodeQueueMap: Map<Engine.Key, Engine.NodeParam[]>;
+    nodeQueueMap: Map<ExecutionId, NodeParam[]>;
     /**
      * 当前正在执行的节点集合
-     * 在每个节点执行完成后，会从集合中删除
-     * 同时会判断次集合中是否还存在和此节点相同的 executionId，如果不存在，说明该流程已经执行完成
+     * 在每个节点执行完成后，会从集合中删除。
+     * 同时会判断此集合中是否还存在和此节点相同的executionId，如果不存在，说明此流程已经执行完成。
      */
-    actionRunningMap: Map<Engine.Key, Scheduler.ActionParamMap>;
+    actionRunningMap: Map<ExecutionId, ActionParamMap>;
     /**
-     * 流程模型，用于创建节点模型
+     * 流程模型，用于创建节点模型。
      */
     flowModel: FlowModel;
     /**
      * 执行记录存储器
-     * 用于存储节点执行的结果
+     * 用于存储节点执行的结果。
      */
-    recorder?: Recorder;
-    constructor(config: Scheduler.ISchedulerProps);
+    recorder: Recorder;
+    constructor(config: any);
     /**
      * 添加一个任务到队列中。
-     * 1. 由流程模型将所有的开始及诶带你添加到队列中
-     * 2. 当一个节点执行完成后，将后续的节点添加到队列中
-     * @param nodeParam
+     * 1. 由流程模型将所有的开始节点添加到队列中。
+     * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    addAction(nodeParam: Engine.NodeParam): void;
-    private pushActionToRunningMap;
-    private removeActionFromRunningMap;
-    /**
-     * 为了防止多次添加导致
-     * @param actionParam
-     */
-    private saveActionResult;
-    private hasRunningAction;
+    addAction(nodeParam: NodeParam): void;
     /**
      * 调度器执行下一个任务
-     * 1. 提供给流程模型，用户开始执行第一个任务
-     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务
-     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件
-     * @param runParam
+     * 1. 提供给流程模型，用户开始执行第一个任务。
+     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务。
+     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件。
      */
-    run(runParam: Scheduler.ActionParam): void;
-    private next;
+    run(runParams: {
+        executionId: string;
+        [key: string]: any;
+    }): void;
     /**
-     * 恢复某个任务的执行
-     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行
-     * @param resumeParam
+     * 恢复某个任务的执行。
+     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
      */
-    resume(resumeParam: Engine.ResumeParam): Promise<void>;
+    resume(resumeParam: ResumeParam): Promise<void>;
+    private pushActionToRunningMap;
+    private removeActionFromRunningMap;
+    private hasRunningAction;
+    private exec;
     private interrupted;
     private error;
-    private exec;
-}
-export declare namespace Scheduler {
-    type ActionParam = {
-        executionId: Engine.Key;
-        actionId?: Engine.Key;
-        nodeId?: Engine.Key;
-        data?: Record<string, unknown>;
-        [key: string]: unknown;
-    };
-    type ActionParamMap = Map<Engine.Key, ActionParam>;
-    interface ISchedulerProps {
-        flowModel: FlowModel;
-        recorder?: Recorder;
-    }
+    private next;
+    private saveActionResult;
 }
-export default Scheduler;
+export {};