@logicflow/engine 0.0.9 → 0.0.10-beta.0

package/src/Scheduler.ts

@@ -0,0 +1,244 @@
+import { Engine } from '.'
+import Recorder from './recorder'
+import FlowModel from './FlowModel'
+import EventEmitter from './EventEmitter'
+import { createActionId } from './utils'
+import {
+  EVENT_INSTANCE_ERROR,
+  EVENT_INSTANCE_COMPLETE,
+  EVENT_INSTANCE_INTERRUPTED,
+  FlowStatus,
+} from './constant'
+
+/**
+ * 调度器
+ * 通过一个队列维护需要执行的节点，一个集合维护正在执行的节点
+ */
+export class Scheduler extends EventEmitter {
+  /**
+   * 当前需要执行的节点队列
+   */
+  nodeQueueMap: Map<Engine.Key, Engine.NodeParam[]>
+  /**
+   * 当前正在执行的节点集合
+   * 在每个节点执行完成后，会从集合中删除
+   * 同时会判断次集合中是否还存在和此节点相同的 executionId，如果不存在，说明该流程已经执行完成
+   */
+  actionRunningMap: Map<Engine.Key, Scheduler.ActionParamMap>
+  /**
+   * 流程模型，用于创建节点模型
+   */
+  flowModel: FlowModel
+  /**
+   * 执行记录存储器
+   * 用于存储节点执行的结果
+   */
+  recorder?: Recorder
+
+  constructor(config: Scheduler.ISchedulerProps) {
+    super()
+    this.nodeQueueMap = new Map()
+    this.actionRunningMap = new Map()
+    this.flowModel = config.flowModel
+    this.recorder = config.recorder
+  }
+
+  /**
+   * 添加一个任务到队列中。
+   * 1. 由流程模型将所有的开始及诶带你添加到队列中
+   * 2. 当一个节点执行完成后，将后续的节点添加到队列中
+   * @param nodeParam
+   */
+  public addAction(nodeParam: Engine.NodeParam) {
+    const { executionId } = nodeParam
+    if (!this.nodeQueueMap.has(executionId)) {
+      this.nodeQueueMap.set(executionId, [])
+    }
+
+    const currentActionQueue: Engine.NodeParam[] | undefined =
+      this.nodeQueueMap.get(executionId)
+    if (currentActionQueue) {
+      currentActionQueue.push(nodeParam)
+    }
+    console.log('this.nodeQueueMap--->>>', this.nodeQueueMap)
+  }
+
+  private pushActionToRunningMap(actionParam: Scheduler.ActionParam) {
+    const { executionId, actionId } = actionParam
+    if (!this.actionRunningMap.has(executionId)) {
+      const runningMap: Scheduler.ActionParamMap = new Map()
+      this.actionRunningMap.set(executionId, runningMap)
+    }
+    if (actionId) {
+      this.actionRunningMap.get(executionId)?.set(actionId, actionParam)
+    }
+  }
+
+  private removeActionFromRunningMap(actionParam: Engine.ActionParam) {
+    const { executionId, actionId } = actionParam
+    if (!actionId) return
+
+    const runningMap = this.actionRunningMap.get(executionId)
+    if (!runningMap) return
+
+    runningMap.delete(actionId)
+  }
+
+  /**
+   * 为了防止多次添加导致
+   * @param actionParam
+   */
+  private saveActionResult(actionParam: Engine.NextActionParam) {
+    this.recorder?.addActionRecord({
+      timestamp: Date.now(),
+      ...actionParam,
+    })
+  }
+
+  private hasRunningAction(executionId: Engine.Key): boolean {
+    const runningMap = this.actionRunningMap.get(executionId)
+    if (!runningMap) return false
+    if (runningMap.size === 0) {
+      this.actionRunningMap.delete(executionId)
+      return false
+    }
+    return true
+  }
+
+  /**
+   * 调度器执行下一个任务
+   * 1. 提供给流程模型，用户开始执行第一个任务
+   * 2. 内部任务执行完成后，调用此方法继续执行下一个任务
+   * 3. 当判断没有可以继续执行的任务后，触发流程结束事件
+   * @param runParam
+   */
+  public run(runParam: Scheduler.ActionParam) {
+    const nodeQueue: Engine.NodeParam[] | undefined = this.nodeQueueMap.get(
+      runParam.executionId,
+    )
+
+    // 将同一个 executionId 当前待执行的节点一起执行
+    // 避免出现某一个节点执行时间过长，导致其他节点等待时间过长
+    while (nodeQueue?.length) {
+      const currentNode = nodeQueue.pop()
+      const actionId = createActionId()
+      const actionParam: Engine.ActionParam = {
+        ...(currentNode as Engine.NodeParam),
+        actionId,
+      }
+      this.pushActionToRunningMap(actionParam)
+      this.exec(actionParam)
+    }
+
+    if (!this.hasRunningAction(runParam.executionId)) {
+      // 当一个流程在 nodeQueueMap 和 actionRunningMap 中都不存在执行的节点时，说明这个流程已经执行完成。
+      this.emit(EVENT_INSTANCE_COMPLETE, {
+        ...runParam,
+        status: FlowStatus.COMPLETED,
+      })
+    }
+  }
+
+  private next(data: Engine.NextActionParam) {
+    if (data.outgoing && data.outgoing.length > 0) {
+      data.outgoing.forEach((item) => {
+        if (item.result) {
+          this.addAction({
+            executionId: data.executionId,
+            nodeId: item.target,
+          })
+        }
+      })
+    }
+
+    this.saveActionResult(data)
+    this.removeActionFromRunningMap(data)
+    this.run(data)
+  }
+
+  /**
+   * 恢复某个任务的执行
+   * 可以自定义节点手动实现流程中断，然后通过此方法恢复流程的执行
+   * @param resumeParam
+   */
+  public async resume(resumeParam: Engine.ResumeParam) {
+    const { executionId, actionId, nodeId } = resumeParam
+    this.pushActionToRunningMap({
+      executionId,
+      actionId,
+      nodeId,
+    })
+
+    const model = this.flowModel.createAction(nodeId)
+    await model?.resume({
+      ...resumeParam,
+      next: this.next.bind(this),
+    })
+  }
+
+  // 中断时，触发事件
+  private interrupted(execResult: Engine.NextActionParam) {
+    this.emit(EVENT_INSTANCE_INTERRUPTED, execResult)
+  }
+  // 报错时，触发事件
+  private error(execResult: Engine.NextActionParam) {
+    this.emit(EVENT_INSTANCE_ERROR, execResult)
+  }
+
+  private async exec(actionParam: Engine.ActionParam) {
+    const { executionId, actionId, nodeId } = actionParam
+    const model = this.flowModel.createAction(nodeId)
+    const execResult = await model?.execute({
+      executionId,
+      actionId,
+      nodeId,
+      next: this.next.bind(this),
+    })
+
+    if (execResult) {
+      const { nodeType, properties, outgoing, status, detail } = execResult
+      const actionResult: Engine.NextActionParam = {
+        // actionParam
+        executionId,
+        actionId,
+        nodeId,
+        // execResult
+        nodeType,
+        properties,
+        outgoing,
+        status,
+        detail,
+      }
+      if (execResult?.status === FlowStatus.INTERRUPTED) {
+        this.interrupted(execResult)
+        this.saveActionResult(actionResult)
+        this.removeActionFromRunningMap(actionParam)
+      }
+
+      if (execResult?.status === FlowStatus.ERROR) {
+        this.error(execResult)
+        this.saveActionResult(actionResult)
+        this.removeActionFromRunningMap(actionParam)
+      }
+    }
+    // TODO: 考虑停下所有的任务
+  }
+}
+
+export namespace Scheduler {
+  export type ActionParam = {
+    executionId: Engine.Key
+    actionId?: Engine.Key
+    nodeId?: Engine.Key
+    data?: Record<string, unknown>
+    [key: string]: unknown
+  }
+  export type ActionParamMap = Map<Engine.Key, ActionParam>
+
+  export interface ISchedulerProps {
+    flowModel: FlowModel
+    recorder?: Recorder
+  }
+}
+
+export default Scheduler

package/src/constant/index.ts

@@ -0,0 +1,23 @@
+// baseType
+export const BASE_START_NODE = 'start'
+
+// eventType
+export const EVENT_INSTANCE_COMPLETE = 'instance:complete'
+export const EVENT_INSTANCE_INTERRUPTED = 'instance:interrupted'
+export const EVENT_INSTANCE_ERROR = 'instance:error'
+
+// flowStatus
+export enum FlowStatus {
+  COMPLETED = 'completed',
+  INTERRUPTED = 'interrupted',
+  RUNNING = 'running',
+  PENDING = 'pending',
+  ERROR = 'error',
+}
+
+// actionStatus
+export enum ActionStatus {
+  SUCCESS = 'success',
+  ERROR = 'error',
+  INTERRUPTED = 'interrupted',
+}

package/src/constant/logCode.ts

@@ -0,0 +1,34 @@
+export enum ErrorCode {
+  // 模型数据错误
+  NONE_START_NODE = 1000,
+  NONE_NODE_ID = 1001,
+
+  // 表达式错误
+  NO_DOCUMENT_BODY = 2001,
+}
+
+export enum WarningCode {
+  NONE_START_NODE_IN_DATA = 2000,
+  START_NODE_INCOMING = 2001,
+
+  // 表达式判断异常
+  EXPRESSION_EXEC_ERROR = 3000,
+}
+
+// TODO: 感觉这块可以用个国际化插件，这样配置不同语言加文件就可以了。
+const errorMsgMapCn = {
+  [ErrorCode.NONE_START_NODE]: '未找到入度为0的节点',
+  [ErrorCode.NONE_NODE_ID]: '流程数据中存在没有此节点',
+  [ErrorCode.NO_DOCUMENT_BODY]: '找不到document.body, 请在DOM加载完成后再执行',
+}
+
+const warningMsgMapCn = {
+  [WarningCode.NONE_START_NODE_IN_DATA]: '初始化数据中未找到入度为0的节点',
+  [WarningCode.START_NODE_INCOMING]: '开始节点不允许被连入',
+  [WarningCode.EXPRESSION_EXEC_ERROR]: '表达式执行异常',
+}
+
+export const getErrorMsg = (code: ErrorCode) =>
+  `error[${code}]: ${errorMsgMapCn[code]}`
+export const getWarningMsg = (code: WarningCode) =>
+  `warning[${code}]: ${warningMsgMapCn[code]}`

package/src/expression/brewserVm.ts

@@ -0,0 +1,36 @@
+import {
+  ErrorCode,
+  WarningCode,
+  getErrorMsg,
+  getWarningMsg,
+} from '../constant/logCode'
+
+const runInBrowserContext = async (code: string, globalData = {}) => {
+  const iframe = document.createElement('iframe')
+  iframe.style.display = 'none'
+  if (!document || !document.body) {
+    console.error(getErrorMsg(ErrorCode.NO_DOCUMENT_BODY))
+  }
+  document.body.appendChild(iframe)
+
+  const iframeWindow = iframe.contentWindow as any
+  const iframeEval = iframeWindow.eval
+  Object.keys(globalData).forEach((key: string) => {
+    iframeWindow[key] = globalData[key]
+  })
+
+  let res = null
+  try {
+    res = iframeEval.call(iframeWindow, code)
+  } catch (e) {
+    console.warn(getWarningMsg(WarningCode.EXPRESSION_EXEC_ERROR), {
+      code,
+      globalData,
+      e,
+    })
+  }
+  document.body.removeChild(iframe)
+  return res
+}
+
+export { runInBrowserContext }

package/src/expression/index.ts

@@ -0,0 +1,17 @@
+import { runInNodeContext } from './nodeVm'
+import { runInBrowserContext } from './brewserVm'
+import { isInNodeJS, isInBrowser, globalScope } from '../utils'
+
+const getExpressionResult = async (code: string, context: any) => {
+  if (isInNodeJS) {
+    const r = await runInNodeContext(code, context)
+    return r
+  }
+  if (isInBrowser) {
+    const r = await runInBrowserContext(code, context)
+    return r
+  }
+  return globalScope.eval(code)
+}
+
+export { getExpressionResult }

package/src/expression/nodeVm.ts

@@ -0,0 +1,14 @@
+import vm from 'node:vm'
+// const vm = require('node:vm');
+
+const runInNodeContext = async (
+  code: string,
+  globalData: Record<string, unknown> = {},
+) => {
+  const context = vm.createContext(globalData)
+  vm.runInContext(code, context)
+
+  return context
+}
+
+export { runInNodeContext }

package/src/index.ts

@@ -0,0 +1,300 @@
+// import { LogicFlow } from '@logicflow/core';
+import { BaseNode, StartNode, TaskNode } from './nodes'
+import { FlowModel } from './FlowModel'
+import { Recorder } from './recorder'
+import { createEngineId } from './utils'
+
+export class Engine {
+  readonly instanceId: string
+  graphData?: Engine.GraphConfigData
+
+  flowModel?: FlowModel
+  recorder?: Recorder
+  context?: Record<string, unknown>
+  nodeModelMap: Map<string, BaseNode.NodeConstructor>
+
+  constructor(options?: Engine.Options) {
+    this.nodeModelMap = new Map()
+    this.instanceId = createEngineId()
+    if (options?.debug) {
+      this.recorder = new Recorder({
+        instanceId: this.instanceId,
+      })
+    }
+    // 默认注册节点 register default nodes
+    this.register({
+      type: StartNode.nodeTypeName,
+      model: StartNode,
+    })
+    this.register({
+      type: TaskNode.nodeTypeName,
+      model: TaskNode,
+    })
+    this.context = options?.context || {}
+  }
+
+  /**
+   * 注册节点
+   * @param nodeConfig { type: 'custom-node', model: NodeClass }
+   */
+  register(nodeConfig: Engine.NodeConfig) {
+    this.nodeModelMap.set(nodeConfig.type, nodeConfig.model)
+  }
+
+  /**
+   * 自定义执行记录的存储，默认浏览器使用 sessionStorage, nodejs 使用内存存储
+   * 注意：由于执行记录不全会主动删除，所以需要自行清理。
+   * nodejs 环境建议自定义为持久化存储。
+   * engine.setCustomRecorder({{
+   *   async addActionRecord(task) {}
+   *   async getTask(actionId) {}
+   *   async getExecutionTasks(executionId) {}
+   *   clear(instanceId) {}
+   * }}
+   * @param recorder
+   */
+  setCustomRecorder(recorder: Recorder) {
+    this.recorder = recorder
+  }
+
+  /**
+   * 加载流程图数据
+   */
+  load({
+    graphData,
+    startNodeType = 'StartNode',
+    globalData = {},
+  }: Engine.LoadGraphParam): FlowModel {
+    this.graphData = graphData
+    const flowModel = new FlowModel({
+      nodeModelMap: this.nodeModelMap,
+      recorder: this.recorder,
+      context: this.context,
+      globalData,
+      startNodeType,
+    })
+
+    flowModel.load(graphData)
+    this.flowModel = flowModel
+    return flowModel
+  }
+
+  /**
+   * 执行流程，允许多次调用
+   */
+  async execute(
+    param?: Partial<Engine.ActionParam>,
+  ): Promise<Engine.NextActionParam> {
+    return new Promise((resolve, reject) => {
+      let execParam = param
+      if (!param) {
+        execParam = {}
+      }
+
+      this.flowModel?.execute({
+        ...execParam,
+        callback: (result) => {
+          resolve(result)
+        },
+        onError: (error) => {
+          reject(error)
+        },
+      })
+    })
+  }
+
+  /**
+   * 中断流程恢复
+   * @param resumeParam
+   * @returns
+   */
+  async resume(
+    resumeParam: Engine.ResumeParam,
+  ): Promise<Engine.NextActionParam | undefined> {
+    return new Promise((resolve, reject) => {
+      this.flowModel?.resume({
+        ...resumeParam,
+        callback: (result) => {
+          resolve(result)
+        },
+        onError: (error) => {
+          reject(error)
+        },
+      })
+    })
+  }
+
+  async getExecutionList() {
+    return await this.recorder?.getExecutionList()
+  }
+
+  /**
+   * 获取执行任务记录
+   * @param executionId
+   * @returns
+   */
+  async getExecutionRecord(
+    executionId: Engine.Key,
+  ): Promise<Recorder.Info[] | null> {
+    const actions = await this.recorder?.getExecutionActions(executionId)
+
+    if (!actions) {
+      return null
+    }
+
+    // DONE: 确认 records 的类型
+    const records: Promise<Recorder.Info>[] = []
+    for (let i = 0; i < actions?.length; i++) {
+      const action = actions[i]
+      if (this.recorder) {
+        records.push(this.recorder?.getActionRecord(action))
+      }
+    }
+
+    return Promise.all(records)
+  }
+
+  destroy() {
+    this.recorder?.clear()
+  }
+
+  getGlobalData() {
+    return this.flowModel?.globalData
+  }
+
+  setGlobalData(data: Record<string, unknown>) {
+    if (this.flowModel) {
+      this.flowModel.globalData = data
+    }
+  }
+
+  updateGlobalData(data: Record<string, unknown>) {
+    if (this.flowModel) {
+      Object.assign(this.flowModel.globalData, data)
+    }
+  }
+}
+
+export namespace Engine {
+  export type Point = {
+    id?: string
+    x: number
+    y: number
+    [key: string]: unknown
+  }
+
+  export type TextConfig = {
+    value: string
+  } & Point
+
+  export type NodeData = {
+    id: string
+    type: string
+    x?: number
+    y?: number
+    text?: TextConfig | string
+    zIndex?: number
+    properties?: Record<string, unknown>
+  }
+
+  export type EdgeData = {
+    id: string
+    /**
+     * 边的类型，不传默认为lf.setDefaultEdgeType(type)传入的类型。
+     * LogicFlow内部默认为polyline
+     */
+    type?: string
+    sourceNodeId: string
+    sourceAnchorId?: string
+    targetNodeId: string
+    targetAnchorId?: string
+    startPoint?: {
+      x: number
+      y: number
+    }
+    endPoint?: {
+      x: number
+      y: number
+    }
+    text?:
+      | {
+          x: number
+          y: number
+          value: string
+        }
+      | string
+    pointsList?: Point[]
+    zIndex?: number
+    properties?: Record<string, unknown>
+  }
+
+  export type GraphConfigData = {
+    nodes: NodeData[]
+    edges: EdgeData[]
+  }
+
+  export type LoadGraphParam = {
+    graphData: GraphConfigData
+    startNodeType?: string
+    globalData?: Record<string, unknown>
+  }
+
+  export type Options = {
+    context?: Record<string, unknown>
+    debug?: boolean
+  }
+  export type Key = string | number
+  export type NodeConfig = {
+    type: string
+    model: any // TODO: NodeModel 可能有多个，类型该如何定义呢？？？
+  }
+
+  export type NodeParam = {
+    executionId: Key
+    nodeId: Key
+  }
+
+  export type CommonActionInfo = {
+    actionId: Key
+  } & NodeParam
+
+  export type ActionParam = CommonActionInfo
+
+  export type ResumeParam = {
+    data?: Record<string, unknown>
+  } & CommonActionInfo
+
+  export type ExecParam = {
+    next: (data: NextActionParam) => void
+  } & ActionParam
+
+  export type ExecResumeParam = {
+    next: (data: NextActionParam) => void
+  } & ResumeParam
+
+  export type ActionStatus = 'success' | 'error' | 'interrupted' | '' // ??? Question: '' 状态是什么状态
+
+  export type NextActionParam = {
+    executionId: Key
+    nodeId: Key
+    actionId: Key
+    nodeType: string
+    outgoing: BaseNode.OutgoingConfig[]
+    properties?: Record<string, unknown>
+    detail?: Record<string, unknown>
+    status?: ActionStatus
+  }
+
+  export type ActionResult = NextActionParam
+
+  export type NodeExecResult = {
+    nodeType: string
+    properties?: Record<string, unknown>
+  } & CommonActionInfo &
+    ActionResult
+}
+
+export * from './constant'
+export { BaseNode, StartNode, TaskNode, Recorder }
+
+export default Engine