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

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

package/src/nodes/base.ts

@@ -0,0 +1,236 @@
+import { Engine } from '..'
+import { ActionStatus } from '../constant'
+import { getExpressionResult } from '../platform'
+
+export interface IBaseNodeProps {
+  nodeConfig: BaseNode.NodeConfig
+  context: Record<string, any>
+  globalData: Record<string, unknown>
+}
+
+export class BaseNode implements BaseNode.Base {
+  readonly baseType: string
+  static nodeTypeName = 'BaseNode'
+
+  /**
+   * 节点的入边
+   */
+  incoming: BaseNode.IncomingConfig[]
+  /**
+   * 节点的出边
+   */
+  outgoing: BaseNode.OutgoingConfig[]
+  /**
+   * 节点的属性
+   */
+  properties?: Record<string, unknown>
+  nodeId: Engine.Key
+  type: string
+  /**
+   * 节点的上下文，是调用流程时传入的上下文
+   */
+  context: Record<string, any>
+  /**
+   * 节点的全局数据，是调用流程时传入的全局数据
+   * 在计算表达式时，即基于全局数据进行计算
+   */
+  globalData: Record<string, unknown>
+
+  constructor({ nodeConfig, context, globalData }: IBaseNodeProps) {
+    const { outgoing, incoming, id, type, properties } = nodeConfig
+    this.baseType = 'base'
+    this.outgoing = outgoing
+    this.incoming = incoming
+    this.nodeId = id
+    this.type = type
+    this.properties = properties
+
+    this.context = context
+    this.globalData = globalData
+  }
+
+  /**
+   * 节点的执行逻辑
+   * @overridable 可以自定义节点重写此方法
+   * @param param.executionId 流程执行记录 ID
+   * @param param.actionId 此节点执行记录 ID
+   * @param param.nodeId 节点 ID
+   * @return 返回下一步的执行参数
+   * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
+   * 当返回时，返回格式为
+   */
+  public async action(
+    param?: Engine.ActionParam,
+  ): Promise<BaseNode.ActionResult | undefined> {
+    console.log('action param --->>>', param)
+    return undefined
+  }
+
+  /**
+   * 节点重新恢复执行的逻辑
+   * @overridable 可以自定义节点重写此方法
+   * @param params.executionId 流程执行记录 ID
+   * @param params.actionId 此节点执行记录 ID
+   * @param params.nodeId 节点 ID
+   */
+  public async onResume(params: Engine.ResumeParam): Promise<void> {
+    console.log('onResume params --->>>', params)
+    return undefined
+  }
+
+  /**
+   * 判断该节点是否满足条件
+   */
+  private async isPass(properties?: Record<string, unknown>): Promise<boolean> {
+    if (!properties) return true
+
+    const { conditionExpression } = properties
+    if (!conditionExpression) return true
+
+    try {
+      // bug：uuid 创建的 NodeId 为 xxxx-xxxx-xxxx-zzzz 格式，eval 执行时会将 - 识别为数学减号，导致执行报错
+      // 解决方案： 赋值变量直接命名为 isPassResult, 因为每次执行 getExpressionResult 时，都会重新射程一个 context
+      return await getExpressionResult(
+        `
+          const isPassResult = (${conditionExpression})
+          return isPassResult
+        `,
+        {
+          ...this.globalData,
+        },
+      )
+    } catch (error) {
+      return false
+    }
+  }
+
+  /**
+   * 获取当前节点执行的下一个节点
+   */
+  private async getOutgoing(): Promise<BaseNode.OutgoingConfig[]> {
+    const outgoing: BaseNode.OutgoingConfig[] = []
+    const expressions: any = []
+    for (const item of this.outgoing) {
+      const { properties } = item
+      expressions.push(this.isPass(properties))
+    }
+
+    const result = await Promise.all(expressions)
+    result.forEach((item, index) => {
+      const out = this.outgoing[index]
+      out.result = item
+      outgoing.push(out)
+    })
+    return outgoing
+  }
+
+  /**
+   * 节点的每一次执行都会生成一个唯一的 actionId
+   */
+  public async execute(
+    params: Engine.ExecParam,
+  ): Promise<Engine.NextActionParam> {
+    const { executionId, actionId } = params
+    const res = await this.action({
+      nodeId: this.nodeId,
+      executionId,
+      actionId,
+    })
+    const status = res ? res.status : 'success'
+
+    if (status === ActionStatus.SUCCESS) {
+      const outgoing = await this.getOutgoing()
+      const detail = res ? res.detail : {}
+      params.next({
+        status: ActionStatus.SUCCESS,
+        detail,
+        nodeId: this.nodeId,
+        nodeType: this.type,
+        properties: this.properties,
+        executionId,
+        actionId,
+        outgoing,
+      })
+    }
+
+    return {
+      status,
+      detail: res?.detail,
+      executionId,
+      actionId,
+      nodeId: this.nodeId,
+      nodeType: this.type,
+      properties: this.properties,
+      outgoing: [],
+    }
+  }
+
+  public async resume(params: Engine.ExecResumeParam): Promise<undefined> {
+    const outgoing = await this.getOutgoing()
+    await this.onResume({
+      executionId: params.executionId,
+      actionId: params.actionId,
+      nodeId: params.nodeId,
+      data: params.data,
+    })
+
+    params.next({
+      executionId: params.executionId,
+      actionId: params.actionId,
+      nodeId: this.nodeId,
+      nodeType: this.type,
+      properties: this.properties,
+      outgoing,
+      status: ActionStatus.SUCCESS,
+    })
+    return undefined
+  }
+}
+
+export namespace BaseNode {
+  export interface Base {
+    incoming: IncomingConfig[]
+    outgoing: OutgoingConfig[]
+    properties?: Record<string, unknown>
+    nodeId: Engine.Key
+    type: string
+    readonly baseType: string
+    execute(actionParam: Engine.ActionParam): Promise<Engine.NextActionParam>
+  }
+
+  export type IncomingConfig = {
+    id: Engine.Key
+    source: string
+    properties?: Record<string, unknown>
+  }
+
+  export type OutgoingConfig = {
+    id: Engine.Key
+    target: string
+    properties?: Record<string, unknown>
+    result?: string | boolean
+  }
+
+  export type NodeConfig = {
+    id: Engine.Key
+    type: string
+    properties?: Record<string, unknown>
+    incoming: IncomingConfig[]
+    outgoing: OutgoingConfig[]
+  }
+
+  export type NodeConstructor = {
+    new (config: {
+      nodeConfig: NodeConfig
+      context: Record<string, any>
+      globalData: Record<string, unknown>
+    }): BaseNode
+  }
+
+  export type ActionResult = {
+    status: ActionStatus
+    detail?: Record<string, unknown>
+  }
+}
+
+export default BaseNode

package/src/nodes/index.ts

@@ -0,0 +1,3 @@
+export * from './base'
+export * from './start'
+export * from './task'

package/src/nodes/start.ts

@@ -0,0 +1,8 @@
+import BaseNode from './base'
+
+export default class StartNode extends BaseNode {
+  readonly baseType = 'start'
+  static nodeTypeName = 'StartNode'
+}
+
+export { StartNode }

package/src/nodes/task.ts

@@ -0,0 +1,8 @@
+import BaseNode from './base'
+
+export default class TaskNode extends BaseNode {
+  readonly baseType = 'task'
+  static nodeTypeName = 'TaskNode'
+}
+
+export { TaskNode }

package/src/platform/browser/browserVm.ts

@@ -0,0 +1,68 @@
+// import {
+//   ErrorCode,
+//   getErrorMsg,
+//   getWarningMsg,
+//   WarningCode,
+// } from '../../constant/logCode'
+//
+// const createContext = (globalData: Record<string, unknown>) => {
+//   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
+//   if (iframeWindow) {
+//     // TODO: 确认是否需要该代码，parent 置为空是为了解决什么问题
+//     // @ts-ignore
+//     ;(iframeWindow!.parent as any) = null
+//     Object.keys(globalData).forEach((key) => {
+//       iframeWindow[key] = globalData[key]
+//     })
+//   }
+//   return iframeWindow
+// }
+//
+// const runInContext = (code: string, context: any) => {
+//   try {
+//     const iframeEval = context.eval
+//     iframeEval.call(context, code)
+//     console.log('context --->>> ===>>>', context)
+//     if (context.frameElement) {
+//       document.body.removeChild(context.frameElement)
+//     }
+//   } catch (e) {
+//     console.warn(getWarningMsg(WarningCode.EXPRESSION_EXEC_ERROR), {
+//       code,
+//       context,
+//       e,
+//     })
+//   }
+// }
+//
+// const runInBrowserContext = async (
+//   code: string,
+//   globalData = {},
+// ): Promise<any> => {
+//   const context = createContext(globalData)
+//   runInContext(code, context)
+//   return context
+// }
+//
+// export { createContext, runInContext, runInBrowserContext }
+
+import Sandbox from '@nyariv/sandboxjs'
+
+export const runInBrowserContext = async (
+  code: string,
+  globalData = {},
+): Promise<any> => {
+  try {
+    const sandbox = new Sandbox()
+    const exec = sandbox.compile(code)
+    return await exec(globalData).run()
+  } catch (e) {
+    console.log('runInBrowserContext error --->>>', e)
+  }
+}

package/src/platform/browser/index.ts

@@ -0,0 +1,28 @@
+import { runInBrowserContext } from './browserVm'
+
+const isInBrowser = typeof window === 'object' && window.window === window
+
+const globalScope: any = (() => {
+  if (isInBrowser) {
+    return window
+  }
+
+  if (typeof self === 'object' && self.self === self) {
+    return self
+  }
+
+  if (typeof globalThis === 'object') {
+    return globalThis
+  }
+
+  return {
+    eval: () => undefined,
+  } as Record<string, unknown>
+})()
+
+const getExpressionResult = async (code: string, context: any) => {
+  const r = await runInBrowserContext(code, context)
+  return r
+}
+
+export { isInBrowser, globalScope, getExpressionResult }

package/src/platform/index.ts

@@ -0,0 +1 @@
+export * from './node'

package/src/platform/node/index.ts

@@ -0,0 +1,28 @@
+import { runInNodeContext } from './nodeVm'
+
+const isInNodeJS = typeof global === 'object' && global.global === global
+
+const globalScope: any = (() => {
+  if (typeof self === 'object' && self.self === self) {
+    return self
+  }
+
+  if (isInNodeJS) {
+    return global
+  }
+
+  if (typeof globalThis === 'object') {
+    return globalThis
+  }
+
+  return {
+    eval: () => undefined,
+  } as Record<string, unknown>
+})()
+
+const getExpressionResult = async (code: string, context: any) => {
+  const r = await runInNodeContext(code, context)
+  return r
+}
+
+export { isInNodeJS, globalScope, getExpressionResult }

package/src/platform/node/nodeVm.ts

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