@logicflow/engine 0.0.9 → 0.0.10-beta.0

package/es/FlowModel.js

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

package/es/FlowModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowModel.js","sourceRoot":"","sources":["../src/FlowModel.ts"],"names":[],"mappings":"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"}

package/es/Scheduler.d.ts

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