@logicflow/engine 0.0.4 → 0.0.6

package/es/nodes/BaseNode.d.ts

@@ -1,11 +1,11 @@
-import type { ActionResult, NodeExecResult, ExecResumeParams, ExecParams } from '../types.d';
+import type { NextActionParam, ActionResult, ExecResumeParams, ExecParams, OutgoingConfig } from '../types.d';
 export interface BaseNodeInterface {
     outgoing: Record<string, any>[];
     incoming: Record<string, any>[];
     nodeId: string;
     type: string;
     readonly baseType: string;
-    execute(actionParam: any): Promise<NodeExecResult>;
+    execute(actionParam: any): Promise<NextActionParam>;
 }
 export declare type NodeConstructor = {
     new (config: {
@@ -17,7 +17,7 @@ export declare type NodeConstructor = {
         executionId: string;
         actionId: string;
         nodeId: string;
-    }): Promise<ActionResult>;
+    }): Promise<NextActionParam>;
     onResume(params: {
         executionId: string;
         actionId: string;
@@ -30,11 +30,6 @@ export declare type IncomingConfig = {
     properties?: Record<string, any>;
     source: string;
 };
-export declare type OutgoingConfig = {
-    id: string;
-    target: string;
-    properties?: Record<string, any>;
-};
 export declare type NodeConfig = {
     id: string;
     type: string;
@@ -42,14 +37,6 @@ export declare type NodeConfig = {
     incoming: IncomingConfig[];
     outgoing: OutgoingConfig[];
 };
-export declare type NextActionParam = {
-    executionId: string;
-    nodeId: string;
-    actionId: string;
-    nodeType: string;
-    outgoing: OutgoingConfig[];
-    properties?: Record<string, any>;
-};
 export default class BaseNode implements BaseNodeInterface {
     static nodeTypeName: string;
     /**
@@ -84,7 +71,7 @@ export default class BaseNode implements BaseNodeInterface {
     /**
      * 节点的每一次执行都会生成一个唯一的actionId
      */
-    execute(params: ExecParams): Promise<NodeExecResult>;
+    execute(params: ExecParams): Promise<NextActionParam>;
     /**
      * 节点在执行中断后，可以通过resume方法恢复执行。
      * 自定义节点时不建议重写此方法
@@ -98,6 +85,9 @@ export default class BaseNode implements BaseNodeInterface {
      * @param params.executionId 流程执行记录ID
      * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
+     * @returns 返回下一步的执行参数
+     * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
+     * 当返回时，返回格式
      */
     action(params: {
         executionId: string;

package/es/nodes/BaseNode.js

@@ -75,7 +75,7 @@ var BaseNode = /** @class */ (function () {
      */
     BaseNode.prototype.execute = function (params) {
         return __awaiter(this, void 0, void 0, function () {
-            var r, outgoing;
+            var r, status, outgoing, detail;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.action({
@@ -85,11 +85,15 @@ var BaseNode = /** @class */ (function () {
                         })];
                     case 1:
                         r = _a.sent();
-                        if (!(!r || r.status === ActionStatus.SUCCESS)) return [3 /*break*/, 3];
+                        status = r ? r.status : 'success';
+                        if (!(status === ActionStatus.SUCCESS)) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.getOutgoing()];
                     case 2:
                         outgoing = _a.sent();
+                        detail = r ? r.detail : {};
                         params.next({
+                            status: ActionStatus.SUCCESS,
+                            detail: detail,
                             executionId: params.executionId,
                             actionId: params.actionId,
                             nodeId: this.nodeId,
@@ -99,13 +103,14 @@ var BaseNode = /** @class */ (function () {
                         });
                         _a.label = 3;
                     case 3: return [2 /*return*/, {
-                            status: r && r.status,
+                            status: status,
                             detail: r && r.detail,
                             executionId: params.executionId,
                             actionId: params.actionId,
                             nodeId: this.nodeId,
                             nodeType: this.type,
                             properties: this.properties,
+                            outgoing: [],
                         }];
                 }
             });
@@ -138,6 +143,7 @@ var BaseNode = /** @class */ (function () {
                             nodeType: this.type,
                             properties: this.properties,
                             outgoing: outgoing,
+                            status: ActionStatus.SUCCESS,
                         });
                         return [2 /*return*/, undefined];
                 }
@@ -172,9 +178,9 @@ var BaseNode = /** @class */ (function () {
                     case 1:
                         result = _d.sent();
                         result.forEach(function (item, index) {
-                            if (item) {
-                                outgoing.push(_this.outgoing[index]);
-                            }
+                            var out = _this.outgoing[index];
+                            out.result = item;
+                            outgoing.push(out);
                         });
                         return [2 /*return*/, outgoing];
                 }
@@ -213,11 +219,14 @@ var BaseNode = /** @class */ (function () {
      * @param params.executionId 流程执行记录ID
      * @param params.actionId 此节点执行记录ID
      * @param params.nodeId 节点ID
+     * @returns 返回下一步的执行参数
+     * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
+     * 当返回时，返回格式
      */
     BaseNode.prototype.action = function (params) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, undefined];
+                return [2 /*return*/, null];
             });
         });
     };

package/es/recorder/index.d.ts

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

package/es/recorder/index.js

@@ -37,9 +37,21 @@ 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 MAX_INSTANCE = 100;
 var Recorder = /** @class */ (function () {
-    function Recorder() {
+    function Recorder(_a) {
+        var instanceId = _a.instanceId;
         this.maxRecorder = MAX_RECORDER;
+        this.instanceId = instanceId;
+        var instances = storage.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+        if (instances.indexOf(instanceId) === -1) {
+            instances.push(instanceId);
+        }
+        if (instances.length > MAX_INSTANCE) {
+            var clearInstance = instances.shift();
+            this.clearInstance(clearInstance);
+        }
+        storage.setItem(LOGICFLOW_ENGINE_INSTANCES, instances);
     }
     Recorder.prototype.setMaxRecorderNumber = function (maxRecorder) {
         this.maxRecorder = maxRecorder;
@@ -93,30 +105,33 @@ var Recorder = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             var instances;
             return __generator(this, function (_a) {
-                instances = storage.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
+                instances = storage.getItem(this.instanceId) || [];
                 return [2 /*return*/, instances];
             });
         });
     };
     Recorder.prototype.clear = function () {
-        var instances = storage.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
-        instances.forEach(function (executionId) {
+        this.clearInstance(this.instanceId);
+    };
+    Recorder.prototype.clearInstance = function (instanceId) {
+        var instanceExecutions = storage.getItem(instanceId) || [];
+        instanceExecutions.forEach(function (executionId) {
             storage.removeItem(executionId);
             var instanceData = storage.getItem(executionId) || [];
             instanceData.forEach(function (actionId) {
                 storage.removeItem(actionId);
             });
         });
-        storage.removeItem(LOGICFLOW_ENGINE_INSTANCES);
+        storage.removeItem(instanceId);
     };
     Recorder.prototype.pushExecution = function (executionId) {
-        var instance = storage.getItem(LOGICFLOW_ENGINE_INSTANCES) || [];
-        if (instance.length >= this.maxRecorder) {
-            var removeItem = instance.shift();
+        var instanceExecutions = storage.getItem(this.instanceId) || [];
+        if (instanceExecutions.length >= this.maxRecorder) {
+            var removeItem = instanceExecutions.shift();
             this.popExecution(removeItem);
         }
-        instance.push(executionId);
-        storage.setItem(LOGICFLOW_ENGINE_INSTANCES, instance);
+        instanceExecutions.push(executionId);
+        storage.setItem(this.instanceId, instanceExecutions);
     };
     Recorder.prototype.popExecution = function (executionId) {
         var instanceData = storage.getItem(executionId) || [];