@logicflow/engine 0.0.1

package/types/Scheduler.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from './EventEmitter';
+import type { TaskParam, NodeParam, ResumeParam } from './types.d';
+import type FlowModel from './FlowModel';
+import type Recorder from './recorder';
+declare type TaskParamMap = Map<string, TaskParam>;
+/**
+ * 调度器
+ * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
+ */
+export default class Scheduler extends EventEmitter {
+    nodeQueueMap: Map<string, NodeParam[]>;
+    taskRunningMap: Map<string, TaskParamMap>;
+    flowModel: FlowModel;
+    recorder: Recorder;
+    currentTask: TaskParam | null;
+    constructor(config: any);
+    /**
+     * 添加一个任务到队列中。
+     * 1. 由流程模型将所有的开始节点添加到队列中。
+     * 2. 当一个节点执行完成后，将后续的节点添加到队列中。
+     */
+    addTask(nodeParam: NodeParam): void;
+    /**
+     * 调度器执行下一个任务
+     * 1. 提供给流程模型，用户开始执行第一个任务。
+     * 2. 内部任务执行完成后，调用此方法继续执行下一个任务。
+     * 3. 当判断没有可以继续执行的任务后，触发流程结束事件。
+     */
+    run(runParams: {
+        executionId: string;
+        nodeId?: string;
+        taskId?: string;
+    }): void;
+    /**
+     * 恢复某个任务的执行。
+     * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行。
+     */
+    resume(resumeParam: ResumeParam): Promise<void>;
+    stop(data: any): void;
+    private pushTaskToRunningMap;
+    private removeTaskFromRunningMap;
+    private hasRunningTask;
+    private exec;
+    private interrupted;
+    private next;
+    /**
+     * 为了防止多次添加导致
+     */
+    private saveTaskResult;
+}
+export {};

package/types/constant/LogCode.d.ts

@@ -0,0 +1,12 @@
+export declare enum ErrorCode {
+    NONE_START_NODE = 1000,
+    NONE_NODE_ID = 1001,
+    NO_DOCUMENT_BODY = 2001
+}
+export declare enum WarningCode {
+    NONE_START_NODE_IN_DATA = 2000,
+    START_NODE_INCOMING = 2001,
+    EXPRESSION_EXEC_ERROR = 3000
+}
+export declare const getErrorMsg: (code: ErrorCode) => string;
+export declare const getWarningMsg: (code: WarningCode) => string;

package/types/constant/constant.d.ts

@@ -0,0 +1,14 @@
+export declare const BASE_START_NODE = "start";
+export declare const EVENT_INSTANCE_COMPLETE = "instance:complete";
+export declare const EVENT_INSTANCE_INTERRUPTED = "instance:interrupted";
+export declare enum FlowStatus {
+    COMPLETED = "completed",
+    INTERRUPTED = "interrupted",
+    RUNNING = "running",
+    ERROR = "error"
+}
+export declare enum TaskStatus {
+    SUCCESS = "success",
+    ERROR = "error",
+    INTERRUPTED = "interrupted"
+}

package/types/expression/browserVm.d.ts

@@ -0,0 +1,2 @@
+declare const runInBrowserContext: (code: string, globalData?: any) => Promise<any>;
+export { runInBrowserContext, };

package/types/expression/index.d.ts

@@ -0,0 +1,2 @@
+declare const getExpressionResult: (code: string, context: any) => Promise<any>;
+export { getExpressionResult, };

package/types/expression/nodeVm.d.ts

@@ -0,0 +1,2 @@
+declare const runInNewContext: (code: string, globalData?: any) => Promise<any>;
+export { runInNewContext, };

package/types/index.d.ts

@@ -0,0 +1,47 @@
+import type { ResumeParams, GraphConfigData } from './types.d';
+import FlowModel, { TaskParams } from './FlowModel';
+import StartNode from './nodes/StartNode';
+import TaskNode from './nodes/TaskNode';
+import Recorder from './recorder';
+export default class Engine {
+    global: Record<string, any>;
+    graphData: GraphConfigData;
+    nodeModelMap: Map<string, any>;
+    flowModel: FlowModel;
+    recorder: Recorder;
+    constructor();
+    /**
+     * 注册节点
+     * @param nodeConfig { type: 'custom-node', model: Class }
+     */
+    register(nodeConfig: any): void;
+    /**
+     * 自定义执行记录的存储，默认浏览器使用 sessionStorage，nodejs 使用内存存储。
+     * 注意：由于执行记录不会主动删除，所以需要自行清理。
+     * nodejs环境建议自定义为持久化存储。
+     * engine.setCustomRecorder({
+     *   async addTask(task) {}
+     *   async getTask(taskId) {}
+     *   async getExecutionTasks(executionId) {}
+     *   clear() {}
+     * });
+     */
+    setCustomRecorder(recorder: Recorder): void;
+    /**
+     * 加载流程图数据
+     */
+    load({ graphData, startNodeType, globalData, context, }: {
+        graphData: any;
+        startNodeType?: string;
+        globalData?: {};
+        context?: {};
+    }): FlowModel;
+    /**
+     * 执行流程，允许多次调用。
+     */
+    execute(execParam?: TaskParams): Promise<unknown>;
+    resume(resumeParam: ResumeParams): Promise<unknown>;
+    getExecutionRecord(executionId: any): Promise<any[]>;
+}
+export { Engine, TaskNode, StartNode, };
+export type { TaskParams, };

package/types/nodes/BaseNode.d.ts

@@ -0,0 +1,109 @@
+import type { ActionResult, NodeExecResult, ExecResumeParams, ExecParams } from '../types.d';
+export interface BaseNodeInterface {
+    outgoing: Record<string, any>[];
+    incoming: Record<string, any>[];
+    nodeId: string;
+    type: string;
+    readonly baseType: string;
+    execute(taskParam: any): Promise<NodeExecResult>;
+}
+export declare type NodeConstructor = {
+    new (config: {
+        nodeConfig: NodeConfig;
+        context: Record<string, any>;
+        globalData: Record<string, any>;
+    }): BaseNode;
+};
+export declare type IncomingConfig = {
+    id: string;
+    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;
+    properties?: Record<string, any>;
+    incoming: IncomingConfig[];
+    outgoing: OutgoingConfig[];
+};
+export declare type NextTaskParam = {
+    executionId: string;
+    nodeId: string;
+    taskId: string;
+    nodeType: string;
+    outgoing: OutgoingConfig[];
+    properties?: Record<string, any>;
+};
+export default class BaseNode implements BaseNodeInterface {
+    static nodeTypeName: string;
+    /**
+     * 节点的出边
+     */
+    outgoing: OutgoingConfig[];
+    /**
+     * 节点的入边
+     */
+    incoming: IncomingConfig[];
+    /**
+     * 节点的属性
+     */
+    properties?: Record<string, any>;
+    nodeId: string;
+    type: string;
+    /**
+     * 节点的上下文，是调用流程时传入的上下文
+     */
+    context: Record<string, any>;
+    /**
+     * 节点的全局数据，是调用流程时传入的全局数据。
+     * 在计算表达式时，即基于全局数据进行计算。
+     */
+    globalData: Record<string, any>;
+    readonly baseType: string;
+    constructor({ nodeConfig, context, globalData }: {
+        nodeConfig: any;
+        context: any;
+        globalData: any;
+    });
+    /**
+     * 节点的每一次执行都会生成一个唯一的taskId
+     */
+    execute(params: ExecParams): Promise<NodeExecResult>;
+    /**
+     * 节点在执行中断后，可以通过resume方法恢复执行。
+     * 自定义节点时不建议重写此方法
+     */
+    resume(params: ExecResumeParams): Promise<undefined>;
+    private getOutgoing;
+    private isPass;
+    /**
+     * 节点的执行逻辑
+     * @overridable 可以自定义节点重写此方法。
+     * @param params.executionId 流程执行记录ID
+     * @param params.taskId 此节点执行记录ID
+     * @param params.nodeId 节点ID
+     */
+    action(params: {
+        executionId: string;
+        taskId: string;
+        nodeId: string;
+    }): Promise<ActionResult>;
+    /**
+     * 节点的重新恢复执行逻辑
+     * @overridable 可以自定义节点重写此方法。
+     * @param params.executionId 流程执行记录ID
+     * @param params.taskId 此节点执行记录ID
+     * @param params.nodeId 节点ID
+     */
+    onResume(params: {
+        executionId: string;
+        taskId: string;
+        nodeId: string;
+        data?: Record<string, any>;
+    }): Promise<void>;
+}

package/types/nodes/StartNode.d.ts

@@ -0,0 +1,5 @@
+import BaseNode from './BaseNode';
+export default class StartNode extends BaseNode {
+    static nodeTypeName: string;
+    readonly baseType = "start";
+}

package/types/nodes/TaskNode.d.ts

@@ -0,0 +1,5 @@
+import BaseNode from './BaseNode';
+export default class TaskNode extends BaseNode {
+    static nodeTypeName: string;
+    readonly baseType = "task";
+}

package/types/recorder/index.d.ts

@@ -0,0 +1,9 @@
+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>;
+    clear(): void;
+    private pushExecution;
+    private pushTaskToExecution;
+}

package/types/util/ID.d.ts

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

package/types/util/global.d.ts

@@ -0,0 +1,5 @@
+declare const isInBrowser: boolean;
+declare const isInNodeJS: boolean;
+declare const isInWebWorker: Function;
+declare const globalScope: Record<string, any>;
+export { globalScope, isInBrowser, isInWebWorker, isInNodeJS, };

package/types/util/storage.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    setItem(key: any, value: any): void;
+    getItem(key: any): any;
+    removeItem(key: any): void;
+};
+export default _default;