@logicflow/engine 0.0.1 → 0.0.2

package/types/EventEmitter.d.ts

@@ -1,7 +0,0 @@
-export default class EventEmitter {
-    _events: Record<string, any>;
-    constructor();
-    on(evKey: any, callback: any, once?: boolean): void;
-    emit(evt: any, eventArgs: any): void;
-    off(evt: any, callback: any): void;
-}

package/types/FlowModel.d.ts

@@ -1,104 +0,0 @@
-import type { NodeConfig, NodeConstructor } from './nodes/BaseNode';
-import type Recorder from './recorder';
-import Scheduler from './Scheduler';
-import type { TaskParam } from './types.d';
-export declare type FlowResult = {
-    result?: Record<string, any>;
-} & TaskParam;
-export declare type TaskParams = {
-    executionId?: string;
-    taskId?: string;
-    nodeId?: string;
-    data?: Record<string, any>;
-};
-export declare type ExecParams = {
-    callback?: (result: FlowResult) => void;
-    onError?: (error: Error) => void;
-} & TaskParams;
-export default class FlowModel {
-    /**
-     * 流程支持的节点类型
-     */
-    nodeModelMap: Map<string, NodeConstructor>;
-    /**
-     * 每一次执行流程都会生成一个唯一的executionId。
-     */
-    executionId: string;
-    /**
-     * 调度器，用于调度节点的执行。
-     */
-    scheduler: Scheduler;
-    /**
-     * 待执行的队列，当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
-     */
-    executeQueue: ExecParams[];
-    /**
-     * 当前正在执行。当监听到调度器执行完成时，出触发执行参数中的回调，告知外部执行完成。
-     */
-    executingInstance: ExecParams;
-    /**
-     * 当前流程模型中的所有节点，边会被转换成节点的incoming和outgoing属性。
-     */
-    nodeConfigMap: Map<string, NodeConfig>;
-    /**
-     * 当流程正在执行时，如果再次触发执行。那么会将执行参数放入到队列中，等待上一次执行完成后再执行。
-     */
-    isRunning: boolean;
-    /**
-     * 开始节点类型，在执行流程时，会从这些节点开始执行。
-     */
-    startNodeType: string;
-    /**
-     * 当前流程中开始节点组成的数组。
-     */
-    startNodes: NodeConfig[];
-    /**
-     * 用于存储全局数据，可以在流程中共享。
-     */
-    globalData: Record<string, any>;
-    /**
-     * 外部传入的上下文，最终会传递给每个节点
-     * 例如：
-     * const context = {
-     *  request: {
-     *   get: (url) => {
-     *    return fetch(url);
-     *  }
-     * }
-     * 在节点内部可以通过 this.context.request.get(url) 来调用。
-     */
-    context: Record<string, any>;
-    constructor({ nodeModelMap, recorder, context, globalData, startNodeType, }: {
-        nodeModelMap: Map<string, NodeConstructor>;
-        recorder: Recorder;
-        context?: Record<string, any>;
-        globalData?: Record<string, any>;
-        startNodeType?: string;
-    });
-    setStartNodeType(startNodeType: any): void;
-    load(graphData: any): void;
-    /**
-     * 执行流程
-     * 同一次执行，这次执行内部的节点执行顺序为并行。
-     * 多次执行，多次执行之间为串行。
-     * 允许一个流程多次执行，效率更高。
-     * 例如：
-     * 一个流程存在着两个开始节点，A和B，A和B的下一个节点都是C，C的下两个节点是D和E。
-     * 外部分别触发了A和B的执行，那么A和B的执行是串行的（也就是需要A执行完成后再执行B），但是D和E的执行是并行的。
-     * 如果希望A和B的执行是并行的，就不能使用同一个流程模型执行，应该初始化两个。
-     */
-    execute(params: ExecParams): Promise<void>;
-    resume(params: ExecParams): Promise<void>;
-    /**
-     * 创建节点实例
-     * @param nodeId 节点Id
-     * @returns 节点示例
-     */
-    createTask(nodeId: string): import("./nodes/BaseNode").default;
-    /**
-     * 更新流程全局数据
-     */
-    updateGlobalData(data: any): void;
-    private onTaskFinished;
-    private createExecution;
-}

package/types/Scheduler.d.ts

@@ -1,51 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/types/expression/index.d.ts

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

package/types/expression/nodeVm.d.ts

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

package/types/index.d.ts

@@ -1,47 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

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

package/types/nodes/TaskNode.d.ts

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

package/types/recorder/index.d.ts

@@ -1,9 +0,0 @@
-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

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

package/types/util/global.d.ts

@@ -1,5 +0,0 @@
-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

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