@logicflow/engine 0.0.9 → 0.0.10-beta.0

package/src/nodes/base.ts

@@ -0,0 +1,234 @@
+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
+      const result = await getExpressionResult(
+        `isPassResult = (${conditionExpression})`,
+        {
+          ...this.globalData,
+        },
+      )
+      return result.isPassResult
+    } 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,52 @@
+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) => {
+  try {
+    const iframeEval = context.eval
+    iframeEval.call(context, code)
+    if (context.iframeElement) {
+      document.body.removeChild(context.iframeElement)
+    }
+  } 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 }

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
+}

package/src/recorder/index.ts

@@ -0,0 +1,137 @@
+import { Engine } from '..'
+import { storage } from '../utils'
+
+export const MAX_RECORDER = 100
+export const MAX_INSTANCE = 100
+export const LOGICFLOW_ENGINE_INSTANCES = 'LOGICFLOW_ENGINE_INSTANCES'
+
+export class Recorder implements Recorder.Base {
+  instanceId: Engine.Key
+  maxRecorder: number
+
+  constructor({ instanceId }) {
+    this.instanceId = instanceId
+    this.maxRecorder = MAX_RECORDER
+
+    const instances = this.getItem(LOGICFLOW_ENGINE_INSTANCES) || []
+    if (instances.indexOf(instanceId) === -1) {
+      instances.push(instanceId)
+    }
+    if (instances.length > MAX_INSTANCE) {
+      const clearInstance = instances.shift()
+      this.clearInstance(clearInstance)
+    }
+    this.setItem(LOGICFLOW_ENGINE_INSTANCES, instances)
+  }
+
+  setMaxRecorderNumber(max: number) {
+    this.maxRecorder = max
+  }
+
+  // 将存储 storage 的方法收敛到此处，并在此处做异常处理 - setItem
+  setItem(key: string | number, value: unknown) {
+    try {
+      storage.setItem(key, value)
+    } catch (error) {
+      console.error('Ops, something wrong with storage.setItem !!!')
+      storage.clear()
+      storage.setItem(key, value)
+    }
+  }
+
+  // getItem 方法
+  getItem(key: string | number) {
+    return storage.getItem(key)
+  }
+
+  async getExecutionActions(executionId: Engine.Key) {
+    return this.getItem(executionId)
+  }
+
+  async getExecutionList() {
+    return this.getItem(this.instanceId) || []
+  }
+
+  private addExecution(executionId: Engine.Key) {
+    const instanceExecutions = this.getItem(this.instanceId) || []
+    if (instanceExecutions.length >= this.maxRecorder) {
+      const toBeRemovedItem = instanceExecutions.shift()
+      this.popExecution(toBeRemovedItem)
+    }
+    instanceExecutions.push(executionId)
+    this.setItem(this.instanceId, instanceExecutions)
+  }
+
+  private popExecution(executionId: Engine.Key) {
+    const instanceData = this.getItem(executionId) || []
+    instanceData.forEach((actionId) => {
+      storage.removeItem(actionId)
+    })
+    storage.removeItem(executionId)
+  }
+
+  private pushActionToExecution(executionId: Engine.Key, actionId: Engine.Key) {
+    const actions = this.getItem(executionId) || []
+    actions.push(actionId)
+    this.setItem(executionId, actions)
+  }
+
+  /**
+   * @param {Object} action
+   * {
+   *   actionId: '',
+   *   nodeId: '',
+   *   executionId: '',
+   *   nodeType: '',
+   *   timestamp: '',
+   *   properties: {},
+   * }
+   */
+  async addActionRecord(action: Recorder.Info) {
+    const { executionId, actionId } = action
+    const instanceData = await this.getExecutionActions(executionId)
+
+    if (!instanceData) {
+      this.addExecution(executionId)
+    }
+    this.pushActionToExecution(executionId, actionId)
+    this.setItem(actionId, action)
+  }
+
+  async getActionRecord(actionId: Engine.Key): Promise<Recorder.Info> {
+    return this.getItem(actionId)
+  }
+
+  clear() {
+    this.clearInstance(this.instanceId)
+  }
+
+  clearInstance(instanceId: Engine.Key) {
+    const instanceExecutions = this.getItem(instanceId) || []
+    // TODO: 完善类型定义
+    instanceExecutions.forEach((executionId) => {
+      storage.removeItem(executionId)
+      const instanceData = this.getItem(executionId) || []
+      instanceData.forEach((actionId) => {
+        storage.removeItem(actionId)
+      })
+    })
+
+    storage.removeItem(instanceId)
+  }
+}
+
+export namespace Recorder {
+  export interface Base {
+    addActionRecord: (action: Info) => Promise<void>
+    getActionRecord: (actionId: Engine.Key) => Promise<Info>
+    getExecutionActions: (executionId: Engine.Key) => Promise<string[]>
+    clear: () => void
+  }
+
+  export type Info = {
+    timestamp: number
+  } & Engine.NextActionParam
+}
+
+export default Recorder

package/src/utils/global.ts

@@ -0,0 +1,41 @@
+// 判断当前环境是否为服务端
+// const isServer = typeof window === undefined;
+
+// const isServer = process.env.BROWSER === true;
+
+const isInBrowser = typeof window === 'object' && window.window === window
+
+const isInNodeJS = typeof global === 'object' && global.global === global
+
+const isInWebWorker =
+  !isInBrowser && typeof self === 'object' && self.constructor
+
+const globalScope: any = (() => {
+  if (isInBrowser) {
+    return window
+  }
+
+  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>
+})()
+
+export {
+  // 环境相关方法
+  globalScope,
+  isInWebWorker,
+  isInBrowser,
+  isInNodeJS,
+}

package/src/utils/id.ts

@@ -0,0 +1,16 @@
+import { v4 as uuidV4 } from 'uuid'
+
+export const createExecId = (): string => {
+  const uuid = uuidV4()
+  return `exec-${uuid}`
+}
+
+export const createActionId = (): string => {
+  const uuid = uuidV4()
+  return `action-${uuid}`
+}
+
+export const createEngineId = (): string => {
+  const uuid = uuidV4()
+  return `engine-${uuid}`
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+import storage from './storage'
+
+export * from './global'
+export * from './id'
+export { storage }

package/src/utils/storage.ts

@@ -0,0 +1,55 @@
+/**
+ * 存储执行记录
+ */
+import { globalScope } from './global'
+
+if (!globalScope.sessionStorage) {
+  const storage = {
+    data: {} as Record<string, unknown>,
+
+    setItem(key, value) {
+      storage.data[key] = value
+    },
+
+    getItem(key) {
+      return storage.data[key]
+    },
+
+    removeItem(key) {
+      delete storage.data[key]
+    },
+
+    clear() {
+      storage.data = {}
+    },
+  }
+
+  globalScope.sessionStorage = storage
+}
+
+export default {
+  setItem(key, value) {
+    if (typeof value === 'object') {
+      value = JSON.stringify(value)
+    }
+
+    globalScope.sessionStorage.setItem(key, value)
+  },
+
+  getItem(key) {
+    const value = globalScope.sessionStorage.getItem(key)
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  },
+
+  removeItem(key) {
+    globalScope.sessionStorage.removeItem(key)
+  },
+
+  clear() {
+    globalScope.sessionStorage.clear()
+  },
+}