@logicflow/engine 0.0.2 → 0.0.4

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,55 +57,80 @@ 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)];
             });
         });
     };
+    Recorder.prototype.getExecutionList = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var instances;
+            return __generator(this, function (_a) {
+                instances = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+                return [2 /*return*/, instances];
+            });
+        });
+    };
     Recorder.prototype.clear = function () {
-        var instance = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
-        instance.forEach(function (executionId) {
+        var instances = storage_1.default.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        instances.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 {};