@logicflow/engine 0.0.11-beta.0 → 0.0.12

package/src/recorder/index.ts

@@ -0,0 +1,137 @@
+import { Engine } from '..'
+import { storage } from '../utils'
+
+export const MAX_RECORDER = 100
+export const MAX_INSTANCE = 100
+export const LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES'
+
+export class Recorder implements Recorder.Base {
+  instanceId: Engine.Key
+  maxRecorder: number
+
+  constructor({ instanceId }) {
+    this.instanceId = instanceId
+    this.maxRecorder = MAX_RECORDER
+
+    const instances = this.getItem(LOGICFLOW_ENGINE_INSTANCES) || []
+    if (instances.indexOf(instanceId) === -1) {
+      instances.push(instanceId)
+    }
+    if (instances.length > MAX_INSTANCE) {
+      const clearInstance = instances.shift()
+      this.clearInstance(clearInstance)
+    }
+    this.setItem(LOGICFLOW_ENGINE_INSTANCES, instances)
+  }
+
+  setMaxRecorderNumber(max: number) {
+    this.maxRecorder = max
+  }
+
+  // 将存储 storage 的方法收敛到此处，并在此处做异常处理 - setItem
+  setItem(key: string | number, value: unknown) {
+    try {
+      storage.setItem(key, value)
+    } catch (error) {
+      console.error('Ops, something wrong with storage.setItem !!!')
+      storage.clear()
+      storage.setItem(key, value)
+    }
+  }
+
+  // getItem 方法
+  getItem(key: string | number) {
+    return storage.getItem(key)
+  }
+
+  async getExecutionActions(executionId: Engine.Key) {
+    return this.getItem(executionId)
+  }
+
+  async getExecutionList() {
+    return this.getItem(this.instanceId) || []
+  }
+
+  private addExecution(executionId: Engine.Key) {
+    const instanceExecutions = this.getItem(this.instanceId) || []
+    if (instanceExecutions.length >= this.maxRecorder) {
+      const toBeRemovedItem = instanceExecutions.shift()
+      this.popExecution(toBeRemovedItem)
+    }
+    instanceExecutions.push(executionId)
+    this.setItem(this.instanceId, instanceExecutions)
+  }
+
+  private popExecution(executionId: Engine.Key) {
+    const instanceData = this.getItem(executionId) || []
+    instanceData.forEach((actionId) => {
+      storage.removeItem(actionId)
+    })
+    storage.removeItem(executionId)
+  }
+
+  private pushActionToExecution(executionId: Engine.Key, actionId: Engine.Key) {
+    const actions = this.getItem(executionId) || []
+    actions.push(actionId)
+    this.setItem(executionId, actions)
+  }
+
+  /**
+   * @param {Object} action
+   * {
+   *   actionId: '',
+   *   nodeId: '',
+   *   executionId: '',
+   *   nodeType: '',
+   *   timestamp: '',
+   *   properties: {},
+   * }
+   */
+  async addActionRecord(action: Recorder.Info) {
+    const { executionId, actionId } = action
+    const instanceData = await this.getExecutionActions(executionId)
+
+    if (!instanceData) {
+      this.addExecution(executionId)
+    }
+    this.pushActionToExecution(executionId, actionId)
+    this.setItem(actionId, action)
+  }
+
+  async getActionRecord(actionId: Engine.Key): Promise<Recorder.Info> {
+    return this.getItem(actionId)
+  }
+
+  clear() {
+    this.clearInstance(this.instanceId)
+  }
+
+  clearInstance(instanceId: Engine.Key) {
+    const instanceExecutions = this.getItem(instanceId) || []
+    // TODO: 完善类型定义
+    instanceExecutions.forEach((executionId) => {
+      storage.removeItem(executionId)
+      const instanceData = this.getItem(executionId) || []
+      instanceData.forEach((actionId) => {
+        storage.removeItem(actionId)
+      })
+    })
+
+    storage.removeItem(instanceId)
+  }
+}
+
+export namespace Recorder {
+  export interface Base {
+    addActionRecord: (action: Info) => Promise<void>
+    getActionRecord: (actionId: Engine.Key) => Promise<Info>
+    getExecutionActions: (executionId: Engine.Key) => Promise<string[]>
+    clear: () => void
+  }
+
+  export type Info = {
+    timestamp: number
+  } & Engine.NextActionParam
+}
+
+export default Recorder

package/src/utils/global.ts

@@ -0,0 +1,41 @@
+// 判断当前环境是否为服务端
+// const isServer = typeof window === undefined;
+
+// const isServer = process.env.BROWSER === true;
+
+const isInBrowser = typeof window === 'object' && window.window === window
+
+const isInNodeJS = typeof global === 'object' && global.global === global
+
+const isInWebWorker =
+  !isInBrowser && typeof self === 'object' && self.constructor
+
+const globalScope: any = (() => {
+  if (isInBrowser) {
+    return window
+  }
+
+  if (typeof self === 'object' && self.self === self) {
+    return self
+  }
+
+  if (isInNodeJS) {
+    return global
+  }
+
+  if (typeof globalThis === 'object') {
+    return globalThis
+  }
+
+  return {
+    eval: () => undefined,
+  } as Record<string, unknown>
+})()
+
+export {
+  // 环境相关方法
+  globalScope,
+  isInWebWorker,
+  isInBrowser,
+  isInNodeJS,
+}

package/src/utils/id.ts

@@ -0,0 +1,16 @@
+import { v4 as uuidV4 } from 'uuid'
+
+export const createExecId = (): string => {
+  const uuid = uuidV4()
+  return `exec-${uuid}`
+}
+
+export const createActionId = (): string => {
+  const uuid = uuidV4()
+  return `action-${uuid}`
+}
+
+export const createEngineId = (): string => {
+  const uuid = uuidV4()
+  return `engine-${uuid}`
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+import storage from './storage'
+
+export * from './global'
+export * from './id'
+export { storage }

package/src/utils/storage.ts

@@ -0,0 +1,55 @@
+/**
+ * 存储执行记录
+ */
+import { globalScope } from './global'
+
+if (!globalScope.sessionStorage) {
+  const storage = {
+    data: {} as Record<string, unknown>,
+
+    setItem(key, value) {
+      storage.data[key] = value
+    },
+
+    getItem(key) {
+      return storage.data[key]
+    },
+
+    removeItem(key) {
+      delete storage.data[key]
+    },
+
+    clear() {
+      storage.data = {}
+    },
+  }
+
+  globalScope.sessionStorage = storage
+}
+
+export default {
+  setItem(key, value) {
+    if (typeof value === 'object') {
+      value = JSON.stringify(value)
+    }
+
+    globalScope.sessionStorage.setItem(key, value)
+  },
+
+  getItem(key) {
+    const value = globalScope.sessionStorage.getItem(key)
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  },
+
+  removeItem(key) {
+    globalScope.sessionStorage.removeItem(key)
+  },
+
+  clear() {
+    globalScope.sessionStorage.clear()
+  },
+}

package/cjs/EventEmitter.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var EventEmitter = /** @class */ (function () {
-    function EventEmitter() {
-        this._events = {};
-    }
-    EventEmitter.prototype.on = function (evKey, callback, once) {
-        if (once === void 0) { once = false; }
-        evKey = evKey.trim();
-        if (!this._events[evKey]) {
-            this._events[evKey] = [];
-        }
-        this._events[evKey].push({
-            callback: callback,
-            once: !!once,
-        });
-    };
-    EventEmitter.prototype.emit = function (evt, eventArgs) {
-        var _this = this;
-        var events = this._events[evt] || [];
-        // 实际的处理 emit 方法
-        var doEmit = function (es) {
-            var length = es.length;
-            for (var i = 0; i < length; i++) {
-                if (!es[i]) {
-                    // eslint-disable-next-line no-continue
-                    continue;
-                }
-                var _a = es[i], callback = _a.callback, once = _a.once;
-                if (once) {
-                    es.splice(i, 1);
-                    if (es.length === 0) {
-                        delete _this._events[evt];
-                    }
-                    length--;
-                    i--;
-                }
-                callback.apply(_this, [eventArgs]);
-            }
-        };
-        doEmit(events);
-    };
-    EventEmitter.prototype.off = function (evt, callback) {
-        if (!evt) {
-            // evt 为空全部清除
-            this._events = {};
-        }
-        if (!callback) {
-            // evt 存在，callback 为空，清除事件所有方法
-            delete this._events[evt];
-        }
-        else {
-            // evt 存在，callback 存在，清除匹配的
-            var events = this._events[evt] || [];
-            var length_1 = events.length;
-            for (var i = 0; i < length_1; i++) {
-                if (events[i].callback === callback) {
-                    events.splice(i, 1);
-                    length_1--;
-                    i--;
-                }
-            }
-            if (events.length === 0) {
-                delete this._events[evt];
-            }
-        }
-    };
-    return EventEmitter;
-}());
-exports.default = EventEmitter;

package/cjs/FlowModel.js

@@ -1,277 +0,0 @@
-"use strict";
-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 };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var constant_1 = require("./constant/constant");
-var ID_1 = require("./util/ID");
-var Scheduler_1 = require("./Scheduler");
-var LogCode_1 = require("./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;
-        /**
-         * 当前流程模型中的所有节点，边会被转换成节点的incoming和outgoing属性。
-         */
-        this.nodeConfigMap = new Map();
-        /**
-         * 当前流程中开始节点组成的数组。
-         */
-        this.startNodes = [];
-        /**
-         * 用于存储全局数据，可以在流程中共享。
-         */
-        this.globalData = {};
-        // 流程包含的节点类型
-        this.nodeModelMap = nodeModelMap;
-        // 需要执行的队列
-        this.executeList = [];
-        // 执行中的任务
-        this.executingInstance = null;
-        // 外部传入的上下文，最终会传递给每个节点
-        this.context = context;
-        // 用于存储全局数据，可以在流程中共享。
-        this.globalData = globalData;
-        // 开始节点类型，在执行流程时，会从这些节点开始执行。
-        this.startNodeType = startNodeType;
-        this.isRunning = false;
-        this.scheduler = new Scheduler_1.default({
-            flowModel: this,
-            recorder: recorder,
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_COMPLETE, function (result) {
-            _this.onExecuteFinished(result);
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_INTERRUPTED, function (result) {
-            _this.onExecuteFinished(result);
-        });
-        this.scheduler.on(constant_1.EVENT_INSTANCE_ERROR, function (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 = {
-                    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);
-                }
-            }
-            else {
-                console.warn("\u672A\u8BC6\u522B\u7684\u8282\u70B9\u7C7B\u578B: " + node.type);
-            }
-        });
-        edges.forEach(function (edge) {
-            var sourceNode = _this.nodeConfigMap.get(edge.sourceNodeId);
-            var targetNode = _this.nodeConfigMap.get(edge.targetNodeId);
-            if (sourceNode) {
-                sourceNode.outgoing.push({
-                    id: edge.id,
-                    properties: edge.properties,
-                    target: edge.targetNodeId,
-                });
-            }
-            if (targetNode && targetNode.type !== _this.startNodeType) {
-                targetNode.incoming.push({
-                    id: edge.id,
-                    properties: edge.properties,
-                    source: edge.sourceNodeId,
-                });
-            }
-        });
-    };
-    /**
-     * 执行流程, 每次执行都会生成一个唯一的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，从开始节点开始执行。
-     */
-    FlowModel.prototype.createExecution = function (execParams) {
-        var _this = this;
-        this.executeList.push(execParams);
-        // 如果有taskId，那么表示恢复执行
-        if (execParams.actionId && execParams.executionId && execParams.nodeId) {
-            this.scheduler.resume({
-                executionId: execParams.executionId,
-                actionId: execParams.actionId,
-                nodeId: execParams.nodeId,
-                data: execParams.data,
-            });
-            return;
-        }
-        var executionId = ID_1.createExecId();
-        execParams.executionId = executionId;
-        if (execParams.nodeId) {
-            var nodeConfig = this.nodeConfigMap.get(execParams.nodeId);
-            if (!nodeConfig) {
-                execParams.onError(new Error(LogCode_1.getErrorMsg(LogCode_1.ErrorCode.NONE_NODE_ID) + "(" + execParams.nodeId + ")"));
-                return;
-            }
-            this.startNodes = [nodeConfig];
-        }
-        this.startNodes.forEach(function (startNode) {
-            _this.scheduler.addAction({
-                executionId: executionId,
-                nodeId: startNode.id,
-            });
-        });
-        this.scheduler.run({
-            executionId: executionId,
-        });
-    };
-    return FlowModel;
-}());
-exports.default = FlowModel;