@logicflow/engine 0.0.10-beta.0 → 0.0.11-beta.0

package/src/Scheduler.ts

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

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

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

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

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

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

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