@logicflow/engine 0.0.1 → 0.0.3

package/cjs/index.js

@@ -54,11 +54,12 @@ exports.StartNode = StartNode_1.default;
 var TaskNode_1 = require("./nodes/TaskNode");
 exports.TaskNode = TaskNode_1.default;
 var recorder_1 = require("./recorder");
+var ID_1 = require("./util/ID");
 var Engine = /** @class */ (function () {
-    function Engine() {
+    function Engine(options) {
         this.nodeModelMap = new Map();
+        this.id = ID_1.createEngineId();
         this.recorder = new recorder_1.default();
-        // register node
         this.register({
             type: StartNode_1.default.nodeTypeName,
             model: StartNode_1.default,
@@ -67,10 +68,11 @@ var Engine = /** @class */ (function () {
             type: TaskNode_1.default.nodeTypeName,
             model: TaskNode_1.default,
         });
+        this.context = (options === null || options === void 0 ? void 0 : options.context) || {};
     }
     /**
      * 注册节点
-     * @param nodeConfig { type: 'custom-node', model: Class }
+     * @param nodeConfig { type: 'custom-node', model: NodeClass }
      */
     Engine.prototype.register = function (nodeConfig) {
         this.nodeModelMap.set(nodeConfig.type, nodeConfig.model);
@@ -80,8 +82,8 @@ var Engine = /** @class */ (function () {
      * 注意：由于执行记录不会主动删除，所以需要自行清理。
      * nodejs环境建议自定义为持久化存储。
      * engine.setCustomRecorder({
-     *   async addTask(task) {}
-     *   async getTask(taskId) {}
+     *   async addActionRecord(task) {}
+     *   async getTask(actionId) {}
      *   async getExecutionTasks(executionId) {}
      *   clear() {}
      * });
@@ -93,11 +95,11 @@ var Engine = /** @class */ (function () {
      * 加载流程图数据
      */
     Engine.prototype.load = function (_a) {
-        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c, _d = _a.context, context = _d === void 0 ? {} : _d;
+        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c;
         this.flowModel = new FlowModel_1.default({
             nodeModelMap: this.nodeModelMap,
             recorder: this.recorder,
-            context: context,
+            context: this.context,
             globalData: globalData,
             startNodeType: startNodeType,
         });
@@ -124,6 +126,12 @@ var Engine = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 恢复执行
+     * 注意此方法只能恢复节点后面的执行，不能恢复流程其他分支的执行。
+     * 同理，中断执行也只能中断节点后面的执行，不会中断其他分支的执行。
+     * 在实际项目中，如果存在中断节点，建议流程所有的节点都是排他网关，这样可以保证执行的过程不存在分支。
+     */
     Engine.prototype.resume = function (resumeParam) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
@@ -143,18 +151,35 @@ var Engine = /** @class */ (function () {
             var tasks, records, i;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.recorder.getExecutionTasks(executionId)];
+                    case 0: return [4 /*yield*/, this.recorder.getExecutionActions(executionId)];
                     case 1:
                         tasks = _a.sent();
+                        if (!tasks) {
+                            return [2 /*return*/, null];
+                        }
                         records = [];
                         for (i = 0; i < tasks.length; i++) {
-                            records.push(this.recorder.getTask(tasks[i]));
+                            records.push(this.recorder.getActionRecord(tasks[i]));
                         }
                         return [2 /*return*/, Promise.all(records)];
                 }
             });
         });
     };
+    Engine.prototype.getGlobalData = function () {
+        var _a;
+        return (_a = this.flowModel) === null || _a === void 0 ? void 0 : _a.globalData;
+    };
+    Engine.prototype.setGlobalData = function (data) {
+        if (this.flowModel) {
+            this.flowModel.globalData = data;
+        }
+    };
+    Engine.prototype.updateGlobalData = function (data) {
+        if (this.flowModel) {
+            Object.assign(this.flowModel.globalData, data);
+        }
+    };
     return Engine;
 }());
 exports.Engine = Engine;

package/cjs/nodes/BaseNode.js

@@ -67,13 +67,13 @@ var BaseNode = /** @class */ (function () {
         this.incoming = nodeConfig.incoming;
         this.nodeId = nodeConfig.id;
         this.type = nodeConfig.type;
-        this.properties = nodeConfig.properties;
+        this.properties = nodeConfig.properties || {};
         this.context = context;
         this.globalData = globalData;
         this.baseType = 'base';
     }
     /**
-     * 节点的每一次执行都会生成一个唯一的taskId
+     * 节点的每一次执行都会生成一个唯一的actionId
      */
     BaseNode.prototype.execute = function (params) {
         return __awaiter(this, void 0, void 0, function () {
@@ -82,18 +82,18 @@ var BaseNode = /** @class */ (function () {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.action({
                             executionId: params.executionId,
-                            taskId: params.taskId,
+                            actionId: params.actionId,
                             nodeId: this.nodeId,
                         })];
                     case 1:
                         r = _a.sent();
-                        if (!(!r || r.status === constant_1.TaskStatus.SUCCESS)) return [3 /*break*/, 3];
+                        if (!(!r || r.status === constant_1.ActionStatus.SUCCESS)) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.getOutgoing()];
                     case 2:
                         outgoing = _a.sent();
                         params.next({
                             executionId: params.executionId,
-                            taskId: params.taskId,
+                            actionId: params.actionId,
                             nodeId: this.nodeId,
                             nodeType: this.type,
                             properties: this.properties,
@@ -104,7 +104,7 @@ var BaseNode = /** @class */ (function () {
                             status: r && r.status,
                             detail: r && r.detail,
                             executionId: params.executionId,
-                            taskId: params.taskId,
+                            actionId: params.actionId,
                             nodeId: this.nodeId,
                             nodeType: this.type,
                             properties: this.properties,
@@ -128,14 +128,14 @@ var BaseNode = /** @class */ (function () {
                         return [4 /*yield*/, this.onResume({
                                 executionId: params.executionId,
                                 nodeId: params.nodeId,
-                                taskId: params.taskId,
+                                actionId: params.actionId,
                                 data: params.data,
                             })];
                     case 2:
                         _a.sent();
                         params.next({
                             executionId: params.executionId,
-                            taskId: params.taskId,
+                            actionId: params.actionId,
                             nodeId: this.nodeId,
                             nodeType: this.type,
                             properties: this.properties,
@@ -213,7 +213,7 @@ var BaseNode = /** @class */ (function () {
      * 节点的执行逻辑
      * @overridable 可以自定义节点重写此方法。
      * @param params.executionId 流程执行记录ID
-     * @param params.taskId 此节点执行记录ID
+     * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
      */
     BaseNode.prototype.action = function (params) {
@@ -227,7 +227,7 @@ var BaseNode = /** @class */ (function () {
      * 节点的重新恢复执行逻辑
      * @overridable 可以自定义节点重写此方法。
      * @param params.executionId 流程执行记录ID
-     * @param params.taskId 此节点执行记录ID
+     * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
      */
     BaseNode.prototype.onResume = function (params) {

package/cjs/recorder/index.js

@@ -38,13 +38,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var storage_1 = require("../util/storage");
 var LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES';
+var MAX_RECORDER = 100;
 var Recorder = /** @class */ (function () {
     function Recorder() {
+        this.maxRecorder = MAX_RECORDER;
     }
+    Recorder.prototype.setMaxRecorderNumber = function (maxRecorder) {
+        this.maxRecorder = maxRecorder;
+    };
     /*
-    * @param {Object} task
+    * @param {Object} action
     * {
-    *   taskId: '',
+    *   actionId: '',
     *   nodeId: '',
     *   executionId: '',
     *   nodeType: '',
@@ -52,34 +57,34 @@ var Recorder = /** @class */ (function () {
     *   properties: {},
     * }
     */
-    Recorder.prototype.addTask = function (task) {
+    Recorder.prototype.addActionRecord = function (action) {
         return __awaiter(this, void 0, void 0, function () {
-            var executionId, taskId, instanceData;
+            var executionId, actionId, instanceData;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        executionId = task.executionId, taskId = task.taskId;
-                        return [4 /*yield*/, this.getExecutionTasks(executionId)];
+                        executionId = action.executionId, actionId = action.actionId;
+                        return [4 /*yield*/, this.getExecutionActions(executionId)];
                     case 1:
                         instanceData = _a.sent();
                         if (!instanceData) {
                             this.pushExecution(executionId);
                         }
-                        this.pushTaskToExecution(executionId, taskId);
-                        storage_1.default.setItem(taskId, task);
+                        this.pushActionToExecution(executionId, actionId);
+                        storage_1.default.setItem(actionId, action);
                         return [2 /*return*/];
                 }
             });
         });
     };
-    Recorder.prototype.getTask = function (taskId) {
+    Recorder.prototype.getActionRecord = function (actionId) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, storage_1.default.getItem(taskId)];
+                return [2 /*return*/, storage_1.default.getItem(actionId)];
             });
         });
     };
-    Recorder.prototype.getExecutionTasks = function (executionId) {
+    Recorder.prototype.getExecutionActions = function (executionId) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, storage_1.default.getItem(executionId)];
@@ -91,21 +96,32 @@ var Recorder = /** @class */ (function () {
         instance.forEach(function (executionId) {
             storage_1.default.removeItem(executionId);
             var instanceData = storage_1.default.getItem(executionId) || [];
-            instanceData.forEach(function (taskId) {
-                storage_1.default.removeItem(taskId);
+            instanceData.forEach(function (actionId) {
+                storage_1.default.removeItem(actionId);
             });
         });
         storage_1.default.removeItem(LOGICFLOW_ENGINE_INSTANCES);
     };
     Recorder.prototype.pushExecution = function (executionId) {
         var instance = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        if (instance.length >= this.maxRecorder) {
+            var removeItem = instance.shift();
+            this.popExecution(removeItem);
+        }
         instance.push(executionId);
         storage_1.default.setItem(LOGICFLOW_ENGINE_INSTANCES, instance);
     };
-    Recorder.prototype.pushTaskToExecution = function (executionId, taskId) {
-        var tasks = storage_1.default.getItem(executionId) || [];
-        tasks.push(taskId);
-        storage_1.default.setItem(executionId, tasks);
+    Recorder.prototype.popExecution = function (executionId) {
+        var instanceData = storage_1.default.getItem(executionId) || [];
+        instanceData.forEach(function (actionId) {
+            storage_1.default.removeItem(actionId);
+        });
+        storage_1.default.removeItem(executionId);
+    };
+    Recorder.prototype.pushActionToExecution = function (executionId, actionId) {
+        var actions = storage_1.default.getItem(executionId) || [];
+        actions.push(actionId);
+        storage_1.default.setItem(executionId, actions);
     };
     return Recorder;
 }());

package/cjs/util/ID.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTaskId = exports.createExecId = void 0;
+exports.createEngineId = exports.createActionId = exports.createExecId = void 0;
 var uuid_1 = require("uuid");
 exports.createExecId = function () {
     var uuid = uuid_1.v4();
     return "exec-" + uuid;
 };
-exports.createTaskId = function () {
+exports.createActionId = function () {
     var uuid = uuid_1.v4();
-    return "task-" + uuid;
+    return "action-" + uuid;
+};
+exports.createEngineId = function () {
+    var uuid = uuid_1.v4();
+    return "engine-" + uuid;
 };

package/es/FlowModel.d.ts

@@ -1,29 +1,24 @@
 import type { NodeConfig, NodeConstructor } from './nodes/BaseNode';
 import type Recorder from './recorder';
 import Scheduler from './Scheduler';
-import type { TaskParam } from './types.d';
+import type { ActionParam } from './types.d';
 export declare type FlowResult = {
     result?: Record<string, any>;
-} & TaskParam;
-export declare type TaskParams = {
+} & ActionParam;
+export declare type ActionParams = {
     executionId?: string;
-    taskId?: string;
+    actionId?: string;
     nodeId?: string;
-    data?: Record<string, any>;
 };
 export declare type ExecParams = {
     callback?: (result: FlowResult) => void;
     onError?: (error: Error) => void;
-} & TaskParams;
+} & ActionParams;
 export default class FlowModel {
     /**
      * 流程支持的节点类型
      */
     nodeModelMap: Map<string, NodeConstructor>;
-    /**
-     * 每一次执行流程都会生成一个唯一的executionId。
-     */
-    executionId: string;
     /**
      * 调度器，用于调度节点的执行。
      */
@@ -31,7 +26,7 @@ export default class FlowModel {
     /**
      * 待执行的队列，当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
      */
-    executeQueue: ExecParams[];
+    executeList: ExecParams[];
     /**
      * 当前正在执行。当监听到调度器执行完成时，出触发执行参数中的回调，告知外部执行完成。
      */
@@ -76,29 +71,74 @@ export default class FlowModel {
         startNodeType?: string;
     });
     setStartNodeType(startNodeType: any): void;
-    load(graphData: any): void;
     /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
+     * 解析LogicFlow图数据，将nodes和edges转换成节点格式。
      * 例如：
+     * graphData: {
+     *  nodes: [
+     *   { id: 'node1', type: 'StartNode', properties: {} },
+     *   { id: 'node2', type: 'TaskNode', properties: {} },
+     *  ],
+     *  edges: [
+     *    { id: 'edge1', sourceNodeId: 'node1', targetNodeId: 'node2', properties: {} },
+     *  ]
+     * }
+     * 转换成：
+     * nodeConfigMap: {
+     *  node1: {
+     *    id: 'node1',
+     *    type: 'StartNode',
+     *    properties: {},
+     *    incoming: [],
+     *    outgoing: [{ id: 'edge1', properties: {}, target: 'node2' }]
+     *  },
+     *  node2: {
+     *   id: 'node2',
+     *   type: 'TaskNode',
+     *   properties: {},
+     *   incoming: [{ id: 'edge1', properties: {}, source: 'node1' }],
+     *   outgoing: [],
+     *  }
+     * }
+     * 此格式方便后续执行时，根据节点id快速找到节点和执行初始化节点模型。
+     * 同时此方法还会找到所有的开始节点，方便后续执行时，从开始节点开始执行。
+     * @param graphData 流程图数据
+     */
+    load(graphData: any): void;
+    /**
+     * 执行流程, 每次执行都会生成一个唯一的executionId，用于区分不同的执行。
+     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行。
+     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
+     * example：
      * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
      * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
      * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
+     * TODO: 去掉此处的对列，直接使用调度器的队列。
      */
     execute(params: ExecParams): Promise<void>;
     resume(params: ExecParams): Promise<void>;
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
-    createTask(nodeId: string): import("./nodes/BaseNode").default;
+    createAction(nodeId: string): import("./nodes/BaseNode").default;
     /**
      * 更新流程全局数据
      */
     updateGlobalData(data: any): void;
-    private onTaskFinished;
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
+    private onExecuteFinished;
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
     private createExecution;
 }

package/es/FlowModel.js

@@ -68,7 +68,7 @@ var FlowModel = /** @class */ (function () {
         // 流程包含的节点类型
         this.nodeModelMap = nodeModelMap;
         // 需要执行的队列
-        this.executeQueue = [];
+        this.executeList = [];
         // 执行中的任务
         this.executingInstance = null;
         // 外部传入的上下文，最终会传递给每个节点
@@ -83,18 +83,53 @@ var FlowModel = /** @class */ (function () {
             recorder: recorder,
         });
         this.scheduler.on(EVENT_INSTANCE_COMPLETE, function (result) {
-            _this.onTaskFinished(result);
+            _this.onExecuteFinished(result);
         });
         this.scheduler.on(EVENT_INSTANCE_INTERRUPTED, function (result) {
-            _this.onTaskFinished(result);
+            _this.onExecuteFinished(result);
         });
     }
     FlowModel.prototype.setStartNodeType = function (startNodeType) {
         this.startNodeType = startNodeType;
     };
+    /**
+     * 解析LogicFlow图数据，将nodes和edges转换成节点格式。
+     * 例如：
+     * graphData: {
+     *  nodes: [
+     *   { id: 'node1', type: 'StartNode', properties: {} },
+     *   { id: 'node2', type: 'TaskNode', properties: {} },
+     *  ],
+     *  edges: [
+     *    { id: 'edge1', sourceNodeId: 'node1', targetNodeId: 'node2', properties: {} },
+     *  ]
+     * }
+     * 转换成：
+     * nodeConfigMap: {
+     *  node1: {
+     *    id: 'node1',
+     *    type: 'StartNode',
+     *    properties: {},
+     *    incoming: [],
+     *    outgoing: [{ id: 'edge1', properties: {}, target: 'node2' }]
+     *  },
+     *  node2: {
+     *   id: 'node2',
+     *   type: 'TaskNode',
+     *   properties: {},
+     *   incoming: [{ id: 'edge1', properties: {}, source: 'node1' }],
+     *   outgoing: [],
+     *  }
+     * }
+     * 此格式方便后续执行时，根据节点id快速找到节点和执行初始化节点模型。
+     * 同时此方法还会找到所有的开始节点，方便后续执行时，从开始节点开始执行。
+     * @param graphData 流程图数据
+     */
     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 = {
@@ -133,24 +168,19 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
-     * 例如：
+     * 执行流程, 每次执行都会生成一个唯一的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.executeQueue.push(params);
-                if (this.isRunning) {
-                    return [2 /*return*/];
-                }
-                this.isRunning = true;
-                this.createExecution();
+                this.createExecution(params);
                 return [2 /*return*/];
             });
         });
@@ -158,30 +188,26 @@ var FlowModel = /** @class */ (function () {
     FlowModel.prototype.resume = function (params) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                this.executeQueue.push(params);
-                if (this.isRunning) {
-                    return [2 /*return*/];
-                }
-                this.isRunning = true;
-                this.createExecution();
+                this.createExecution(params);
                 return [2 /*return*/];
             });
         });
     };
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
-    FlowModel.prototype.createTask = function (nodeId) {
+    FlowModel.prototype.createAction = function (nodeId) {
         var nodeConfig = this.nodeConfigMap.get(nodeId);
         var NodeModel = this.nodeModelMap.get(nodeConfig.type);
-        var task = new NodeModel({
+        var action = new NodeModel({
             nodeConfig: nodeConfig,
             globalData: this.globalData,
             context: this.context,
         });
-        return task;
+        return action;
     };
     /**
      * 更新流程全局数据
@@ -189,43 +215,40 @@ var FlowModel = /** @class */ (function () {
     FlowModel.prototype.updateGlobalData = function (data) {
         this.globalData = __assign(__assign({}, this.globalData), data);
     };
-    FlowModel.prototype.onTaskFinished = function (result) {
-        var executionId = result.executionId;
-        if (executionId !== this.executionId) {
-            return;
-        }
-        var callback = this.executingInstance.callback;
-        if (callback) {
-            callback(result);
-        }
-        this.executingInstance = null;
-        if (this.executeQueue.length > 0) {
-            this.createExecution();
-        }
-        else {
-            this.isRunning = false;
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
+    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);
         }
     };
-    FlowModel.prototype.createExecution = function () {
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
+    FlowModel.prototype.createExecution = function (execParams) {
         var _this = this;
-        var execParams = this.executeQueue.shift();
-        this.executingInstance = execParams;
-        if (execParams.executionId) {
-            this.executionId = execParams.executionId;
-        }
-        else {
-            this.executionId = createExecId();
-        }
+        this.executeList.push(execParams);
         // 如果有taskId，那么表示恢复执行
-        if (execParams.taskId) {
+        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
-                executionId: this.executionId,
-                taskId: execParams.taskId,
+                executionId: execParams.executionId,
+                actionId: execParams.actionId,
                 nodeId: execParams.nodeId,
                 data: execParams.data,
             });
             return;
         }
+        var executionId = createExecId();
+        execParams.executionId = executionId;
         if (execParams.nodeId) {
             var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
@@ -235,14 +258,13 @@ var FlowModel = /** @class */ (function () {
             this.startNodes = [nodeConfig];
         }
         this.startNodes.forEach(function (startNode) {
-            _this.scheduler.addTask({
-                executionId: _this.executionId,
+            _this.scheduler.addAction({
+                executionId: executionId,
                 nodeId: startNode.id,
             });
-            // 所有的开始节点都执行
         });
         this.scheduler.run({
-            executionId: this.executionId,
+            executionId: executionId,
         });
     };
     return FlowModel;