@logicflow/engine 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 0.0.2 (2023-08-10)
+
+
+### Bug Fixes
+
+* **engine:** consistent expression evaluation in browser and nodejs ([8f24045](https://github.com/didi/LogicFlow/commit/8f240451dce588b6fa21e639c79e1a0782937ff9))
+
+
+### Features
+
+* add support for specifying the start node and multiple executions ([113ad88](https://github.com/didi/LogicFlow/commit/113ad880cdb564431933eeeed3b661c50fca2a9c))
+* added expression evaluation functionality for Node.js and browser ([a7759f6](https://github.com/didi/LogicFlow/commit/a7759f69d4f7b294397c8502da654ea7c729d930))
+* create logicflow eninge ([c7d80f4](https://github.com/didi/LogicFlow/commit/c7d80f4b4c19cf82af9be49dd8fd44433327db58))
+* **engie:** support parallel execution within workflows ([8e17ea6](https://github.com/didi/LogicFlow/commit/8e17ea614c5c3567e532a67240cf8e0e9110b2bf))
+* **engine:** add comments and sync storage execution ([6fa0904](https://github.com/didi/LogicFlow/commit/6fa0904ddee88254d4af5c246ff0247c988dfdd2))
+* **engine:** add the ability to pause and resume workflows ([7c4e385](https://github.com/didi/LogicFlow/commit/7c4e3855ad0a7af4121de6552be61f690b4e0e6c))
+* **engine:** added workflow scheduling feature ([c2a7044](https://github.com/didi/LogicFlow/commit/c2a704449772445387f324924491f15e526dfc4e))
+* implemented execution record query functionality ([d73aa46](https://github.com/didi/LogicFlow/commit/d73aa46675f35bae5362e6024232d44cbfe5bcaa))

package/README.md

@@ -4,19 +4,7 @@
 
 ## 使用方式
 
-```js
-import LogicFlowEngine from '@logicflow/engine';
-
-const flowModel = new LogicFlowEngine({
-  graphData: {
-    nodes: [],
-    edges: [],
-  },
-  global: {
-    // 全局数据
-  }
-});
-
-flowModel.execute();
-
+```shell
+npm test
 ```
+

package/cjs/FlowModel.js

@@ -94,9 +94,44 @@ var FlowModel = /** @class */ (function () {
     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 = {
@@ -135,11 +170,10 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
-     * 例如：
+     * 执行流程, 每次执行都会生成一个唯一的executionId，用于区分不同的执行。
+     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行。
+     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
+     * example：
      * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
      * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
      * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
@@ -171,7 +205,8 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的taskId。
+     * 通过executionId、nodeId、taskId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
@@ -191,11 +226,11 @@ 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);
@@ -208,26 +243,28 @@ var FlowModel = /** @class */ (function () {
             this.isRunning = false;
         }
     };
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
     FlowModel.prototype.createExecution = function () {
         var _this = this;
         var execParams = this.executeQueue.shift();
         this.executingInstance = execParams;
-        if (execParams.executionId) {
-            this.executionId = execParams.executionId;
-        }
-        else {
-            this.executionId = ID_1.createExecId();
-        }
         // 如果有taskId，那么表示恢复执行
-        if (execParams.taskId) {
+        if (execParams.taskId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
-                executionId: this.executionId,
+                executionId: execParams.executionId,
                 taskId: execParams.taskId,
                 nodeId: execParams.nodeId,
                 data: execParams.data,
             });
             return;
         }
+        var executionId = execParams.executionId || ID_1.createExecId();
         if (execParams.nodeId) {
             var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
@@ -238,13 +275,12 @@ var FlowModel = /** @class */ (function () {
         }
         this.startNodes.forEach(function (startNode) {
             _this.scheduler.addTask({
-                executionId: _this.executionId,
+                executionId: executionId,
                 nodeId: startNode.id,
             });
-            // 所有的开始节点都执行
         });
         this.scheduler.run({
-            executionId: this.executionId,
+            executionId: executionId,
         });
     };
     return FlowModel;

package/cjs/Scheduler.js

@@ -75,7 +75,6 @@ var Scheduler = /** @class */ (function (_super) {
         _this.taskRunningMap = new Map();
         _this.flowModel = config.flowModel;
         _this.recorder = config.recorder;
-        _this.currentTask = null;
         return _this;
     }
     /**
@@ -143,10 +142,6 @@ var Scheduler = /** @class */ (function (_super) {
             });
         });
     };
-    // 流程执行过程中出错，停止执行
-    Scheduler.prototype.stop = function (data) {
-        console.log('stop', data);
-    };
     Scheduler.prototype.pushTaskToRunningMap = function (taskParam) {
         var executionId = taskParam.executionId, taskId = taskParam.taskId;
         if (!this.taskRunningMap.has(executionId)) {
@@ -224,53 +219,31 @@ var Scheduler = /** @class */ (function (_super) {
         });
     };
     Scheduler.prototype.next = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (data.outgoing && data.outgoing.length > 0) {
-                            data.outgoing.forEach(function (item) {
-                                _this.addTask({
-                                    executionId: data.executionId,
-                                    nodeId: item.target,
-                                });
-                            });
-                        }
-                        return [4 /*yield*/, this.saveTaskResult(data)];
-                    case 1:
-                        _a.sent();
-                        this.removeTaskFromRunningMap(data);
-                        this.run({
-                            executionId: data.executionId,
-                            nodeId: data.nodeId,
-                            taskId: data.taskId,
-                        });
-                        return [2 /*return*/];
-                }
+        var _this = this;
+        if (data.outgoing && data.outgoing.length > 0) {
+            data.outgoing.forEach(function (item) {
+                _this.addTask({
+                    executionId: data.executionId,
+                    nodeId: item.target,
+                });
             });
+        }
+        this.saveTaskResult(data);
+        this.removeTaskFromRunningMap(data);
+        this.run({
+            executionId: data.executionId,
+            nodeId: data.nodeId,
+            taskId: data.taskId,
         });
     };
-    /**
-     * 为了防止多次添加导致
-     */
     Scheduler.prototype.saveTaskResult = function (data) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.recorder.addTask({
-                            executionId: data.executionId,
-                            taskId: data.taskId,
-                            nodeId: data.nodeId,
-                            nodeType: data.nodeType,
-                            timestamp: Date.now(),
-                            properties: data.properties,
-                        })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+        this.recorder.addTask({
+            executionId: data.executionId,
+            taskId: data.taskId,
+            nodeId: data.nodeId,
+            nodeType: data.nodeType,
+            timestamp: Date.now(),
+            properties: data.properties,
         });
     };
     return Scheduler;

package/cjs/recorder/index.js

@@ -56,19 +56,14 @@ var Recorder = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var executionId, taskId, instanceData;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        executionId = task.executionId, taskId = task.taskId;
-                        return [4 /*yield*/, this.getExecutionTasks(executionId)];
-                    case 1:
-                        instanceData = _a.sent();
-                        if (!instanceData) {
-                            this.pushExecution(executionId);
-                        }
-                        this.pushTaskToExecution(executionId, taskId);
-                        storage_1.default.setItem(taskId, task);
-                        return [2 /*return*/];
+                executionId = task.executionId, taskId = task.taskId;
+                instanceData = this.getExecutionTasks(executionId);
+                if (!instanceData) {
+                    this.pushExecution(executionId);
                 }
+                this.pushTaskToExecution(executionId, taskId);
+                storage_1.default.setItem(taskId, task);
+                return [2 /*return*/];
             });
         });
     };

package/es/FlowModel.d.ts

@@ -20,10 +20,6 @@ export default class FlowModel {
      * 流程支持的节点类型
      */
     nodeModelMap: Map<string, NodeConstructor>;
-    /**
-     * 每一次执行流程都会生成一个唯一的executionId。
-     */
-    executionId: string;
     /**
      * 调度器，用于调度节点的执行。
      */
@@ -76,13 +72,45 @@ 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的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
@@ -90,7 +118,8 @@ export default class FlowModel {
     execute(params: ExecParams): Promise<void>;
     resume(params: ExecParams): Promise<void>;
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的taskId。
+     * 通过executionId、nodeId、taskId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
@@ -99,6 +128,17 @@ export default class FlowModel {
      * 更新流程全局数据
      */
     updateGlobalData(data: any): void;
+    /**
+     * 在执行完成后，通知外部此次执行完成。
+     * 如果还存在待执行的任务，那么继续执行。
+     */
     private onTaskFinished;
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
     private createExecution;
 }

package/es/FlowModel.js

@@ -92,9 +92,44 @@ var FlowModel = /** @class */ (function () {
     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,11 +168,10 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
-     * 例如：
+     * 执行流程, 每次执行都会生成一个唯一的executionId，用于区分不同的执行。
+     * 同一次执行，这次执行内部的节点执行顺序为并行。内部并行是为了避免异步节点阻塞其他节点的执行。
+     * 多次执行，多次执行之间为串行，这里选择串行的原因是避免多次执行之间的数据冲突。
+     * example：
      * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
      * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
      * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
@@ -169,7 +203,8 @@ var FlowModel = /** @class */ (function () {
         });
     };
     /**
-     * 创建节点实例
+     * 创建节点实例, 每个节点实例都会有一个唯一的taskId。
+     * 通过executionId、nodeId、taskId可以唯一确定一个节点的某一次执行。
      * @param nodeId 节点Id
      * @returns 节点示例
      */
@@ -189,11 +224,11 @@ 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);
@@ -206,26 +241,28 @@ var FlowModel = /** @class */ (function () {
             this.isRunning = false;
         }
     };
+    /**
+     * 从待执行队列中取出需要执行的内容。
+     * 会依次判断是否有taskId、nodeId、executionId。
+     * 若存在taskId，那么表示恢复执行。
+     * 若存在nodeId，那么表示从指定节点开始执行。
+     * 若都不存在，那么新建一个executionId，从开始节点开始执行。
+     */
     FlowModel.prototype.createExecution = function () {
         var _this = this;
         var execParams = this.executeQueue.shift();
         this.executingInstance = execParams;
-        if (execParams.executionId) {
-            this.executionId = execParams.executionId;
-        }
-        else {
-            this.executionId = createExecId();
-        }
         // 如果有taskId，那么表示恢复执行
-        if (execParams.taskId) {
+        if (execParams.taskId && execParams.executionId && execParams.nodeId) {
             this.scheduler.resume({
-                executionId: this.executionId,
+                executionId: execParams.executionId,
                 taskId: execParams.taskId,
                 nodeId: execParams.nodeId,
                 data: execParams.data,
             });
             return;
         }
+        var executionId = execParams.executionId || createExecId();
         if (execParams.nodeId) {
             var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
             if (!nodeConfig) {
@@ -236,13 +273,12 @@ var FlowModel = /** @class */ (function () {
         }
         this.startNodes.forEach(function (startNode) {
             _this.scheduler.addTask({
-                executionId: _this.executionId,
+                executionId: executionId,
                 nodeId: startNode.id,
             });
-            // 所有的开始节点都执行
         });
         this.scheduler.run({
-            executionId: this.executionId,
+            executionId: executionId,
         });
     };
     return FlowModel;

package/es/Scheduler.d.ts

@@ -3,16 +3,31 @@ import type { TaskParam, NodeParam, ResumeParam } from './types.d';
 import type FlowModel from './FlowModel';
 import type Recorder from './recorder';
 declare type TaskParamMap = Map<string, TaskParam>;
+declare type ExecutionId = string;
 /**
  * 调度器
  * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
  */
 export default class Scheduler extends EventEmitter {
-    nodeQueueMap: Map<string, NodeParam[]>;
-    taskRunningMap: Map<string, TaskParamMap>;
+    /**
+     * 当前需要执行的节点队列
+     */
+    nodeQueueMap: Map<ExecutionId, NodeParam[]>;
+    /**
+     * 当前正在执行的节点集合
+     * 在每个节点执行完成后，会从集合中删除。
+     * 同时会判断此集合中是否还存在和此节点相同的executionId，如果不存在，说明此流程已经执行完成。
+     */
+    taskRunningMap: Map<ExecutionId, TaskParamMap>;
+    /**
+     * 流程模型，用于创建节点模型。
+     */
     flowModel: FlowModel;
+    /**
+     * 执行记录存储器
+     * 用于存储节点执行的结果。
+     */
     recorder: Recorder;
-    currentTask: TaskParam | null;
     constructor(config: any);
     /**
      * 添加一个任务到队列中。
@@ -36,16 +51,12 @@ export default class Scheduler extends EventEmitter {
      * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
      */
     resume(resumeParam: ResumeParam): Promise<void>;
-    stop(data: any): void;
     private pushTaskToRunningMap;
     private removeTaskFromRunningMap;
     private hasRunningTask;
     private exec;
     private interrupted;
     private next;
-    /**
-     * 为了防止多次添加导致
-     */
     private saveTaskResult;
 }
 export {};