@logicflow/engine 0.0.2 → 0.0.3

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,29 +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) {
-                executionId = task.executionId, taskId = task.taskId;
-                instanceData = this.getExecutionTasks(executionId);
-                if (!instanceData) {
-                    this.pushExecution(executionId);
+                switch (_a.label) {
+                    case 0:
+                        executionId = action.executionId, actionId = action.actionId;
+                        return [4 /*yield*/, this.getExecutionActions(executionId)];
+                    case 1:
+                        instanceData = _a.sent();
+                        if (!instanceData) {
+                            this.pushExecution(executionId);
+                        }
+                        this.pushActionToExecution(executionId, actionId);
+                        storage_1.default.setItem(actionId, action);
+                        return [2 /*return*/];
                 }
-                this.pushTaskToExecution(executionId, taskId);
-                storage_1.default.setItem(taskId, task);
-                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)];
@@ -86,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,20 +1,19 @@
 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 {
     /**
      * 流程支持的节点类型
@@ -27,7 +26,7 @@ export default class FlowModel {
     /**
      * 待执行的队列，当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
      */
-    executeQueue: ExecParams[];
+    executeList: ExecParams[];
     /**
      * 当前正在执行。当监听到调度器执行完成时，出触发执行参数中的回调，告知外部执行完成。
      */
@@ -114,16 +113,17 @@ export default class FlowModel {
      * 一个流程存在着两个开始节点，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>;
     /**
-     * 创建节点实例, 每个节点实例都会有一个唯一的taskId。
-     * 通过executionId、nodeId、taskId可以唯一确定一个节点的某一次执行。
+     * 创建节点实例, 每个节点实例都会有一个唯一的actionId。
+     * 通过executionId、nodeId、actionId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
-    createTask(nodeId: string): import("./nodes/BaseNode").default;
+    createAction(nodeId: string): import("./nodes/BaseNode").default;
     /**
      * 更新流程全局数据
      */
@@ -132,7 +132,7 @@ export default class FlowModel {
      * 在执行完成后，通知外部此次执行完成。
      * 如果还存在待执行的任务，那么继续执行。
      */
-    private onTaskFinished;
+    private onExecuteFinished;
     /**
      * 从待执行队列中取出需要执行的内容。
      * 会依次判断是否有taskId、nodeId、executionId。

package/es/FlowModel.js

@@ -68,7 +68,7 @@ var FlowModel = /** @class */ (function () {
         // 流程包含的节点类型
         this.nodeModelMap = nodeModelMap;
         // 需要执行的队列
-        this.executeQueue = [];
+        this.executeList = [];
         // 执行中的任务
         this.executingInstance = null;
         // 外部传入的上下文，最终会传递给每个节点
@@ -83,10 +83,10 @@ 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) {
@@ -175,16 +175,12 @@ var FlowModel = /** @class */ (function () {
      * 一个流程存在着两个开始节点，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*/];
             });
         });
@@ -192,31 +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*/];
             });
         });
     };
     /**
-     * 创建节点实例, 每个节点实例都会有一个唯一的taskId。
-     * 通过executionId、nodeId、taskId可以唯一确定一个节点的某一次执行。
+     * 创建节点实例, 每个节点实例都会有一个唯一的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;
     };
     /**
      * 更新流程全局数据
@@ -228,17 +219,12 @@ var FlowModel = /** @class */ (function () {
      * 在执行完成后，通知外部此次执行完成。
      * 如果还存在待执行的任务，那么继续执行。
      */
-    FlowModel.prototype.onTaskFinished = function (result) {
-        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);
         }
     };
     /**
@@ -248,21 +234,21 @@ var FlowModel = /** @class */ (function () {
      * 若存在nodeId，那么表示从指定节点开始执行。
      * 若都不存在，那么新建一个executionId，从开始节点开始执行。
      */
-    FlowModel.prototype.createExecution = function () {
+    FlowModel.prototype.createExecution = function (execParams) {
         var _this = this;
-        var execParams = this.executeQueue.shift();
-        this.executingInstance = execParams;
+        this.executeList.push(execParams);
         // 如果有taskId，那么表示恢复执行
-        if (execParams.taskId && execParams.executionId && execParams.nodeId) {
+        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
                 executionId: execParams.executionId,
-                taskId: execParams.taskId,
+                actionId: execParams.actionId,
                 nodeId: execParams.nodeId,
                 data: execParams.data,
             });
             return;
         }
-        var executionId = execParams.executionId || createExecId();
+        var executionId = createExecId();
+        execParams.executionId = executionId;
         if (execParams.nodeId) {
             var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
@@ -272,7 +258,7 @@ var FlowModel = /** @class */ (function () {
             this.startNodes = [nodeConfig];
         }
         this.startNodes.forEach(function (startNode) {
-            _this.scheduler.addTask({
+            _this.scheduler.addAction({
                 executionId: executionId,
                 nodeId: startNode.id,
             });

package/es/Scheduler.d.ts

@@ -1,8 +1,8 @@
 import EventEmitter from './EventEmitter';
-import type { TaskParam, NodeParam, ResumeParam } from './types.d';
+import type { ActionParam, NodeParam, ResumeParam } from './types.d';
 import type FlowModel from './FlowModel';
 import type Recorder from './recorder';
-declare type TaskParamMap = Map<string, TaskParam>;
+declare type ActionParamMap = Map<string, ActionParam>;
 declare type ExecutionId = string;
 /**
  * 调度器
@@ -18,7 +18,7 @@ export default class Scheduler extends EventEmitter {
      * 在每个节点执行完成后，会从集合中删除。
      * 同时会判断此集合中是否还存在和此节点相同的executionId，如果不存在，说明此流程已经执行完成。
      */
-    taskRunningMap: Map<ExecutionId, TaskParamMap>;
+    actionRunningMap: Map<ExecutionId, ActionParamMap>;
     /**
      * 流程模型，用于创建节点模型。
      */
@@ -34,7 +34,7 @@ export default class Scheduler extends EventEmitter {
      * 1. 由流程模型将所有的开始节点添加到队列中。
      * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    addTask(nodeParam: NodeParam): void;
+    addAction(nodeParam: NodeParam): void;
     /**
      * 调度器执行下一个任务
      * 1. 提供给流程模型，用户开始执行第一个任务。
@@ -44,19 +44,19 @@ export default class Scheduler extends EventEmitter {
     run(runParams: {
         executionId: string;
         nodeId?: string;
-        taskId?: string;
+        actionId?: string;
     }): void;
     /**
      * 恢复某个任务的执行。
      * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
      */
     resume(resumeParam: ResumeParam): Promise<void>;
-    private pushTaskToRunningMap;
-    private removeTaskFromRunningMap;
-    private hasRunningTask;
+    private pushActionToRunningMap;
+    private removeActionFromRunningMap;
+    private hasRunningAction;
     private exec;
     private interrupted;
     private next;
-    private saveTaskResult;
+    private saveActionResult;
 }
 export {};

package/es/Scheduler.js

@@ -60,7 +60,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import EventEmitter from './EventEmitter';
 import { EVENT_INSTANCE_COMPLETE, EVENT_INSTANCE_INTERRUPTED, FlowStatus, } from './constant/constant';
-import { createTaskId } from './util/ID';
+import { createActionId } from './util/ID';
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
@@ -70,7 +70,7 @@ var Scheduler = /** @class */ (function (_super) {
     function Scheduler(config) {
         var _this = _super.call(this) || this;
         _this.nodeQueueMap = new Map();
-        _this.taskRunningMap = new Map();
+        _this.actionRunningMap = new Map();
         _this.flowModel = config.flowModel;
         _this.recorder = config.recorder;
         return _this;
@@ -80,13 +80,13 @@ var Scheduler = /** @class */ (function (_super) {
      * 1. 由流程模型将所有的开始节点添加到队列中。
      * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
      */
-    Scheduler.prototype.addTask = function (nodeParam) {
+    Scheduler.prototype.addAction = function (nodeParam) {
         var executionId = nodeParam.executionId;
         if (!this.nodeQueueMap.has(executionId)) {
             this.nodeQueueMap.set(executionId, []);
         }
-        var currentTaskQueue = this.nodeQueueMap.get(executionId);
-        currentTaskQueue.push(nodeParam);
+        var currentActionQueue = this.nodeQueueMap.get(executionId);
+        currentActionQueue.push(nodeParam);
     };
     /**
      * 调度器执行下一个任务
@@ -96,22 +96,21 @@ var Scheduler = /** @class */ (function (_super) {
      */
     Scheduler.prototype.run = function (runParams) {
         var nodeQueue = this.nodeQueueMap.get(runParams.executionId);
-        if (nodeQueue.length > 0) {
-            this.nodeQueueMap.set(runParams.executionId, []);
-            for (var i = 0; i < nodeQueue.length; i++) {
-                var currentNode = nodeQueue[i];
-                var taskId = createTaskId();
-                var taskParam = __assign(__assign({}, currentNode), { taskId: taskId });
-                this.pushTaskToRunningMap(taskParam);
-                this.exec(taskParam);
-            }
+        // 将同一个executionId当前待执行的节点一起执行
+        // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长。
+        while (nodeQueue.length) {
+            var currentNode = nodeQueue.pop();
+            var actionId = createActionId();
+            var actionParam = __assign(__assign({}, currentNode), { actionId: actionId });
+            this.pushActionToRunningMap(actionParam);
+            this.exec(actionParam);
         }
-        else if (!this.hasRunningTask(runParams.executionId)) {
-            // 当一个流程在nodeQueueMap和taskRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
+        if (!this.hasRunningAction(runParams.executionId)) {
+            // 当一个流程在nodeQueueMap和actionRunningMap中都不存在执行的节点时，说明这个流程已经执行完成。
             this.emit(EVENT_INSTANCE_COMPLETE, {
                 executionId: runParams.executionId,
                 nodeId: runParams.nodeId,
-                taskId: runParams.taskId,
+                actionId: runParams.actionId,
                 status: FlowStatus.COMPLETED,
             });
         }
@@ -126,12 +125,12 @@ var Scheduler = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this.pushTaskToRunningMap({
+                        this.pushActionToRunningMap({
                             executionId: resumeParam.executionId,
                             nodeId: resumeParam.nodeId,
-                            taskId: resumeParam.taskId,
+                            actionId: resumeParam.actionId,
                         });
-                        model = this.flowModel.createTask(resumeParam.nodeId);
+                        model = this.flowModel.createAction(resumeParam.nodeId);
                         return [4 /*yield*/, model.resume(__assign(__assign({}, resumeParam), { next: this.next.bind(this) }))];
                     case 1:
                         _a.sent();
@@ -140,44 +139,44 @@ var Scheduler = /** @class */ (function (_super) {
             });
         });
     };
-    Scheduler.prototype.pushTaskToRunningMap = function (taskParam) {
-        var executionId = taskParam.executionId, taskId = taskParam.taskId;
-        if (!this.taskRunningMap.has(executionId)) {
+    Scheduler.prototype.pushActionToRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
+        if (!this.actionRunningMap.has(executionId)) {
             var runningMap = new Map();
-            this.taskRunningMap.set(executionId, runningMap);
+            this.actionRunningMap.set(executionId, runningMap);
         }
-        this.taskRunningMap.get(executionId).set(taskId, taskParam);
+        this.actionRunningMap.get(executionId).set(actionId, actionParam);
     };
-    Scheduler.prototype.removeTaskFromRunningMap = function (taskParam) {
-        var executionId = taskParam.executionId, taskId = taskParam.taskId;
-        if (!taskId)
+    Scheduler.prototype.removeActionFromRunningMap = function (actionParam) {
+        var executionId = actionParam.executionId, actionId = actionParam.actionId;
+        if (!actionId)
             return;
-        var runningMap = this.taskRunningMap.get(executionId);
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return;
-        runningMap.delete(taskId);
+        runningMap.delete(actionId);
     };
-    Scheduler.prototype.hasRunningTask = function (executionId) {
-        var runningMap = this.taskRunningMap.get(executionId);
+    Scheduler.prototype.hasRunningAction = function (executionId) {
+        var runningMap = this.actionRunningMap.get(executionId);
         if (!runningMap)
             return false;
         if (runningMap.size === 0) {
-            this.taskRunningMap.delete(executionId);
+            this.actionRunningMap.delete(executionId);
             return false;
         }
         return true;
     };
-    Scheduler.prototype.exec = function (taskParam) {
+    Scheduler.prototype.exec = function (actionParam) {
         return __awaiter(this, void 0, void 0, function () {
             var model, execResult;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        model = this.flowModel.createTask(taskParam.nodeId);
+                        model = this.flowModel.createAction(actionParam.nodeId);
                         return [4 /*yield*/, model.execute({
-                                executionId: taskParam.executionId,
-                                taskId: taskParam.taskId,
-                                nodeId: taskParam.nodeId,
+                                executionId: actionParam.executionId,
+                                actionId: actionParam.actionId,
+                                nodeId: actionParam.nodeId,
                                 next: this.next.bind(this),
                             })];
                     case 1:
@@ -185,12 +184,12 @@ var Scheduler = /** @class */ (function (_super) {
                         if (execResult && execResult.status === FlowStatus.INTERRUPTED) {
                             this.interrupted({
                                 execResult: execResult,
-                                taskParam: taskParam,
+                                actionParam: actionParam,
                             });
-                            this.saveTaskResult({
-                                executionId: taskParam.executionId,
-                                nodeId: taskParam.nodeId,
-                                taskId: taskParam.taskId,
+                            this.saveActionResult({
+                                executionId: actionParam.executionId,
+                                nodeId: actionParam.nodeId,
+                                actionId: actionParam.actionId,
                                 nodeType: execResult.nodeType,
                                 properties: execResult.properties,
                                 outgoing: [],
@@ -199,7 +198,7 @@ var Scheduler = /** @class */ (function (_super) {
                                     detail: execResult.detail,
                                 },
                             });
-                            this.removeTaskFromRunningMap(taskParam);
+                            this.removeActionFromRunningMap(actionParam);
                         }
                         return [2 /*return*/];
                 }
@@ -207,12 +206,12 @@ var Scheduler = /** @class */ (function (_super) {
         });
     };
     Scheduler.prototype.interrupted = function (_a) {
-        var execResult = _a.execResult, taskParam = _a.taskParam;
+        var execResult = _a.execResult, actionParam = _a.actionParam;
         this.emit(EVENT_INSTANCE_INTERRUPTED, {
-            executionId: taskParam.executionId,
+            executionId: actionParam.executionId,
             status: FlowStatus.INTERRUPTED,
-            nodeId: taskParam.nodeId,
-            taskId: taskParam.taskId,
+            nodeId: actionParam.nodeId,
+            actionId: actionParam.actionId,
             detail: execResult.detail,
         });
     };
@@ -220,24 +219,24 @@ var Scheduler = /** @class */ (function (_super) {
         var _this = this;
         if (data.outgoing && data.outgoing.length > 0) {
             data.outgoing.forEach(function (item) {
-                _this.addTask({
+                _this.addAction({
                     executionId: data.executionId,
                     nodeId: item.target,
                 });
             });
         }
-        this.saveTaskResult(data);
-        this.removeTaskFromRunningMap(data);
+        this.saveActionResult(data);
+        this.removeActionFromRunningMap(data);
         this.run({
             executionId: data.executionId,
             nodeId: data.nodeId,
-            taskId: data.taskId,
+            actionId: data.actionId,
         });
     };
-    Scheduler.prototype.saveTaskResult = function (data) {
-        this.recorder.addTask({
+    Scheduler.prototype.saveActionResult = function (data) {
+        this.recorder.addActionRecord({
             executionId: data.executionId,
-            taskId: data.taskId,
+            actionId: data.actionId,
             nodeId: data.nodeId,
             nodeType: data.nodeType,
             timestamp: Date.now(),

package/es/constant/constant.d.ts

@@ -7,7 +7,7 @@ export declare enum FlowStatus {
     RUNNING = "running",
     ERROR = "error"
 }
-export declare enum TaskStatus {
+export declare enum ActionStatus {
     SUCCESS = "success",
     ERROR = "error",
     INTERRUPTED = "interrupted"

package/es/constant/constant.js

@@ -11,10 +11,10 @@ export var FlowStatus;
     FlowStatus["RUNNING"] = "running";
     FlowStatus["ERROR"] = "error";
 })(FlowStatus || (FlowStatus = {}));
-// task status
-export var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["SUCCESS"] = "success";
-    TaskStatus["ERROR"] = "error";
-    TaskStatus["INTERRUPTED"] = "interrupted";
-})(TaskStatus || (TaskStatus = {}));
+// action status
+export var ActionStatus;
+(function (ActionStatus) {
+    ActionStatus["SUCCESS"] = "success";
+    ActionStatus["ERROR"] = "error";
+    ActionStatus["INTERRUPTED"] = "interrupted";
+})(ActionStatus || (ActionStatus = {}));

package/es/expression/browserVm.d.ts

@@ -1,2 +1,4 @@
+declare const createContext: (globalData: any) => any;
+declare const runInContext: (code: any, context: any) => any;
 declare const runInBrowserContext: (code: string, globalData?: any) => Promise<any>;
-export { runInBrowserContext, };
+export { runInBrowserContext, createContext, runInContext, };