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

package/src/nodes/base.ts

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

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

package/src/nodes/start.ts

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

package/src/nodes/task.ts

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

package/src/platform/browser/browserVm.ts

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

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

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

package/src/platform/node/index.ts

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

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

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

@@ -1,41 +0,0 @@
-// 判断当前环境是否为服务端
-// 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

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

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

package/src/utils/storage.ts

@@ -1,55 +0,0 @@
-/**
- * 存储执行记录
- */
-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()
-  },
-}