@logicflow/engine 0.0.2 → 0.0.3

package/es/expression/browserVm.js

@@ -35,32 +35,38 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { ErrorCode, WarningCode, getErrorMsg, getWarningMsg, } from '../constant/LogCode';
+var createContext = function (globalData) {
+    var iframe = document.createElement('iframe');
+    iframe.style.display = 'none';
+    if (!document || !document.body) {
+        console.error(getErrorMsg(ErrorCode.NO_DOCUMENT_BODY));
+    }
+    var iframeWindow = iframe.contentWindow;
+    iframeWindow.parent = null;
+    Object.keys(globalData).forEach(function (key) {
+        iframeWindow[key] = globalData[key];
+    });
+    return iframeWindow;
+};
+var runInContext = function (code, context) {
+    try {
+        var iframeEval = context.eval;
+        iframeEval.call(context, code);
+    }
+    catch (e) {
+        console.warn(getWarningMsg(WarningCode.EXPRESSION_EXEC_ERROR), { code: code, context: context, e: e });
+    }
+    return context;
+};
 var runInBrowserContext = function (code, globalData) {
     if (globalData === void 0) { globalData = {}; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var iframe, iframeWindow, iframeEval, res;
+        var context;
         return __generator(this, function (_a) {
-            iframe = document.createElement('iframe');
-            iframe.style.display = 'none';
-            if (!document || !document.body) {
-                console.error(getErrorMsg(ErrorCode.NO_DOCUMENT_BODY));
-            }
-            document.body.appendChild(iframe);
-            iframeWindow = iframe.contentWindow;
-            iframeEval = iframeWindow.eval;
-            Object.keys(globalData).forEach(function (key) {
-                iframeWindow[key] = globalData[key];
-            });
-            res = null;
-            try {
-                res = iframeEval.call(iframeWindow, code);
-            }
-            catch (e) {
-                console.warn(getWarningMsg(WarningCode.EXPRESSION_EXEC_ERROR), { code: code, globalData: globalData, e: e });
-            }
-            document.body.removeChild(iframe);
-            return [2 /*return*/, res];
+            context = createContext(globalData);
+            runInContext(code, context);
+            return [2 /*return*/, context];
         });
     });
 };
-export { runInBrowserContext, };
+export { runInBrowserContext, createContext, runInContext, };

package/es/expression/nodeVm.js

@@ -34,7 +34,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-// import vm from 'node:vm';
+/* eslint-disable global-require */
 var vm = require('vm');
 var runInNewContext = function (code, globalData) {
     if (globalData === void 0) { globalData = {}; }

package/es/index.d.ts

@@ -1,18 +1,21 @@
-import type { ResumeParams, GraphConfigData } from './types.d';
-import FlowModel, { TaskParams } from './FlowModel';
+import type { ResumeParams, GraphConfigData, EngineConstructorOptions } from './types.d';
+import FlowModel, { ActionParams } from './FlowModel';
 import StartNode from './nodes/StartNode';
 import TaskNode from './nodes/TaskNode';
 import Recorder from './recorder';
+import { NodeConstructor } from './nodes/BaseNode';
 export default class Engine {
+    id: string;
     global: Record<string, any>;
     graphData: GraphConfigData;
-    nodeModelMap: Map<string, any>;
+    nodeModelMap: Map<string, NodeConstructor>;
     flowModel: FlowModel;
     recorder: Recorder;
-    constructor();
+    context: Record<string, any>;
+    constructor(options?: EngineConstructorOptions);
     /**
      * 注册节点
-     * @param nodeConfig { type: 'custom-node', model: Class }
+     * @param nodeConfig { type: 'custom-node', model: NodeClass }
      */
     register(nodeConfig: any): void;
     /**
@@ -20,8 +23,8 @@ export default class Engine {
      * 注意：由于执行记录不会主动删除，所以需要自行清理。
      * nodejs环境建议自定义为持久化存储。
      * engine.setCustomRecorder({
-     *   async addTask(task) {}
-     *   async getTask(taskId) {}
+     *   async addActionRecord(task) {}
+     *   async getTask(actionId) {}
      *   async getExecutionTasks(executionId) {}
      *   clear() {}
      * });
@@ -30,18 +33,26 @@ export default class Engine {
     /**
      * 加载流程图数据
      */
-    load({ graphData, startNodeType, globalData, context, }: {
+    load({ graphData, startNodeType, globalData, }: {
         graphData: any;
         startNodeType?: string;
         globalData?: {};
-        context?: {};
     }): FlowModel;
     /**
      * 执行流程，允许多次调用。
      */
-    execute(execParam?: TaskParams): Promise<unknown>;
+    execute(execParam?: ActionParams): Promise<unknown>;
+    /**
+     * 恢复执行
+     * 注意此方法只能恢复节点后面的执行，不能恢复流程其他分支的执行。
+     * 同理，中断执行也只能中断节点后面的执行，不会中断其他分支的执行。
+     * 在实际项目中，如果存在中断节点，建议流程所有的节点都是排他网关，这样可以保证执行的过程不存在分支。
+     */
     resume(resumeParam: ResumeParams): Promise<unknown>;
     getExecutionRecord(executionId: any): Promise<any[]>;
+    getGlobalData(): Record<string, any>;
+    setGlobalData(data: any): void;
+    updateGlobalData(data: any): void;
 }
 export { Engine, TaskNode, StartNode, };
-export type { TaskParams, };
+export type { ActionParams, };

package/es/index.js

@@ -49,11 +49,12 @@ import FlowModel from './FlowModel';
 import StartNode from './nodes/StartNode';
 import TaskNode from './nodes/TaskNode';
 import Recorder from './recorder';
+import { createEngineId } from './util/ID';
 var Engine = /** @class */ (function () {
-    function Engine() {
+    function Engine(options) {
         this.nodeModelMap = new Map();
+        this.id = createEngineId();
         this.recorder = new Recorder();
-        // register node
         this.register({
             type: StartNode.nodeTypeName,
             model: StartNode,
@@ -62,10 +63,11 @@ var Engine = /** @class */ (function () {
             type: TaskNode.nodeTypeName,
             model: TaskNode,
         });
+        this.context = (options === null || options === void 0 ? void 0 : options.context) || {};
     }
     /**
      * 注册节点
-     * @param nodeConfig { type: 'custom-node', model: Class }
+     * @param nodeConfig { type: 'custom-node', model: NodeClass }
      */
     Engine.prototype.register = function (nodeConfig) {
         this.nodeModelMap.set(nodeConfig.type, nodeConfig.model);
@@ -75,8 +77,8 @@ var Engine = /** @class */ (function () {
      * 注意：由于执行记录不会主动删除，所以需要自行清理。
      * nodejs环境建议自定义为持久化存储。
      * engine.setCustomRecorder({
-     *   async addTask(task) {}
-     *   async getTask(taskId) {}
+     *   async addActionRecord(task) {}
+     *   async getTask(actionId) {}
      *   async getExecutionTasks(executionId) {}
      *   clear() {}
      * });
@@ -88,11 +90,11 @@ var Engine = /** @class */ (function () {
      * 加载流程图数据
      */
     Engine.prototype.load = function (_a) {
-        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c, _d = _a.context, context = _d === void 0 ? {} : _d;
+        var graphData = _a.graphData, _b = _a.startNodeType, startNodeType = _b === void 0 ? 'StartNode' : _b, _c = _a.globalData, globalData = _c === void 0 ? {} : _c;
         this.flowModel = new FlowModel({
             nodeModelMap: this.nodeModelMap,
             recorder: this.recorder,
-            context: context,
+            context: this.context,
             globalData: globalData,
             startNodeType: startNodeType,
         });
@@ -119,6 +121,12 @@ var Engine = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 恢复执行
+     * 注意此方法只能恢复节点后面的执行，不能恢复流程其他分支的执行。
+     * 同理，中断执行也只能中断节点后面的执行，不会中断其他分支的执行。
+     * 在实际项目中，如果存在中断节点，建议流程所有的节点都是排他网关，这样可以保证执行的过程不存在分支。
+     */
     Engine.prototype.resume = function (resumeParam) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
@@ -138,18 +146,35 @@ var Engine = /** @class */ (function () {
             var tasks, records, i;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.recorder.getExecutionTasks(executionId)];
+                    case 0: return [4 /*yield*/, this.recorder.getExecutionActions(executionId)];
                     case 1:
                         tasks = _a.sent();
+                        if (!tasks) {
+                            return [2 /*return*/, null];
+                        }
                         records = [];
                         for (i = 0; i < tasks.length; i++) {
-                            records.push(this.recorder.getTask(tasks[i]));
+                            records.push(this.recorder.getActionRecord(tasks[i]));
                         }
                         return [2 /*return*/, Promise.all(records)];
                 }
             });
         });
     };
+    Engine.prototype.getGlobalData = function () {
+        var _a;
+        return (_a = this.flowModel) === null || _a === void 0 ? void 0 : _a.globalData;
+    };
+    Engine.prototype.setGlobalData = function (data) {
+        if (this.flowModel) {
+            this.flowModel.globalData = data;
+        }
+    };
+    Engine.prototype.updateGlobalData = function (data) {
+        if (this.flowModel) {
+            Object.assign(this.flowModel.globalData, data);
+        }
+    };
     return Engine;
 }());
 export default Engine;

package/es/nodes/BaseNode.d.ts

@@ -5,7 +5,7 @@ export interface BaseNodeInterface {
     nodeId: string;
     type: string;
     readonly baseType: string;
-    execute(taskParam: any): Promise<NodeExecResult>;
+    execute(actionParam: any): Promise<NodeExecResult>;
 }
 export declare type NodeConstructor = {
     new (config: {
@@ -13,6 +13,17 @@ export declare type NodeConstructor = {
         context: Record<string, any>;
         globalData: Record<string, any>;
     }): BaseNode;
+    action(params: {
+        executionId: string;
+        actionId: string;
+        nodeId: string;
+    }): Promise<ActionResult>;
+    onResume(params: {
+        executionId: string;
+        actionId: string;
+        nodeId: string;
+        data?: Record<string, any>;
+    }): Promise<void>;
 };
 export declare type IncomingConfig = {
     id: string;
@@ -31,10 +42,10 @@ export declare type NodeConfig = {
     incoming: IncomingConfig[];
     outgoing: OutgoingConfig[];
 };
-export declare type NextTaskParam = {
+export declare type NextActionParam = {
     executionId: string;
     nodeId: string;
-    taskId: string;
+    actionId: string;
     nodeType: string;
     outgoing: OutgoingConfig[];
     properties?: Record<string, any>;
@@ -71,7 +82,7 @@ export default class BaseNode implements BaseNodeInterface {
         globalData: any;
     });
     /**
-     * 节点的每一次执行都会生成一个唯一的taskId
+     * 节点的每一次执行都会生成一个唯一的actionId
      */
     execute(params: ExecParams): Promise<NodeExecResult>;
     /**
@@ -85,24 +96,24 @@ export default class BaseNode implements BaseNodeInterface {
      * 节点的执行逻辑
      * @overridable 可以自定义节点重写此方法。
      * @param params.executionId 流程执行记录ID
-     * @param params.taskId 此节点执行记录ID
+     * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
      */
     action(params: {
         executionId: string;
-        taskId: string;
+        actionId: string;
         nodeId: string;
     }): Promise<ActionResult>;
     /**
      * 节点的重新恢复执行逻辑
      * @overridable 可以自定义节点重写此方法。
      * @param params.executionId 流程执行记录ID
-     * @param params.taskId 此节点执行记录ID
+     * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
      */
     onResume(params: {
         executionId: string;
-        taskId: string;
+        actionId: string;
         nodeId: string;
         data?: Record<string, any>;
     }): Promise<void>;

package/es/nodes/BaseNode.js

@@ -56,7 +56,7 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { TaskStatus } from '../constant/constant';
+import { ActionStatus } from '../constant/constant';
 import { getExpressionResult } from '../expression';
 var BaseNode = /** @class */ (function () {
     function BaseNode(_a) {
@@ -65,13 +65,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 () {
@@ -80,18 +80,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 === TaskStatus.SUCCESS)) return [3 /*break*/, 3];
+                        if (!(!r || r.status === 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,
@@ -102,7 +102,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,
@@ -126,14 +126,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,
@@ -211,7 +211,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) {
@@ -225,7 +225,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/es/recorder/index.d.ts

@@ -1,9 +1,13 @@
 import type { RecorderData, RecorderInterface } from '../types.d';
 export default class Recorder implements RecorderInterface {
-    addTask(task: RecorderData): Promise<void>;
-    getTask(taskId: string): Promise<RecorderData>;
-    getExecutionTasks(executionId: any): Promise<any>;
+    maxRecorder: number;
+    constructor();
+    setMaxRecorderNumber(maxRecorder: number): void;
+    addActionRecord(action: RecorderData): Promise<void>;
+    getActionRecord(actionId: string): Promise<RecorderData>;
+    getExecutionActions(executionId: any): Promise<any>;
     clear(): void;
     private pushExecution;
-    private pushTaskToExecution;
+    private popExecution;
+    private pushActionToExecution;
 }

package/es/recorder/index.js

@@ -36,13 +36,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import storage from '../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: '',
@@ -50,29 +55,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.setItem(actionId, action);
+                        return [2 /*return*/];
                 }
-                this.pushTaskToExecution(executionId, taskId);
-                storage.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.getItem(taskId)];
+                return [2 /*return*/, storage.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.getItem(executionId)];
@@ -84,21 +94,32 @@ var Recorder = /** @class */ (function () {
         instance.forEach(function (executionId) {
             storage.removeItem(executionId);
             var instanceData = storage.getItem(executionId) || [];
-            instanceData.forEach(function (taskId) {
-                storage.removeItem(taskId);
+            instanceData.forEach(function (actionId) {
+                storage.removeItem(actionId);
             });
         });
         storage.removeItem(LOGICFLOW_ENGINE_INSTANCES);
     };
     Recorder.prototype.pushExecution = function (executionId) {
         var instance = storage.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        if (instance.length >= this.maxRecorder) {
+            var removeItem = instance.shift();
+            this.popExecution(removeItem);
+        }
         instance.push(executionId);
         storage.setItem(LOGICFLOW_ENGINE_INSTANCES, instance);
     };
-    Recorder.prototype.pushTaskToExecution = function (executionId, taskId) {
-        var tasks = storage.getItem(executionId) || [];
-        tasks.push(taskId);
-        storage.setItem(executionId, tasks);
+    Recorder.prototype.popExecution = function (executionId) {
+        var instanceData = storage.getItem(executionId) || [];
+        instanceData.forEach(function (actionId) {
+            storage.removeItem(actionId);
+        });
+        storage.removeItem(executionId);
+    };
+    Recorder.prototype.pushActionToExecution = function (executionId, actionId) {
+        var actions = storage.getItem(executionId) || [];
+        actions.push(actionId);
+        storage.setItem(executionId, actions);
     };
     return Recorder;
 }());

package/es/util/ID.d.ts

@@ -1,2 +1,3 @@
 export declare const createExecId: () => string;
-export declare const createTaskId: () => string;
+export declare const createActionId: () => string;
+export declare const createEngineId: () => string;

package/es/util/ID.js

@@ -3,7 +3,11 @@ export var createExecId = function () {
     var uuid = uuidv4();
     return "exec-" + uuid;
 };
-export var createTaskId = function () {
+export var createActionId = function () {
     var uuid = uuidv4();
-    return "task-" + uuid;
+    return "action-" + uuid;
+};
+export var createEngineId = function () {
+    var uuid = uuidv4();
+    return "engine-" + uuid;
 };