manta/gofaster/app/plugins/modules/call-chain-tracer.js

const { readFileSync, existsSync } = require('fs')
const { resolve } = require('path')
const { parse } = require('@vue/compiler-dom')
const parser = require('@babel/parser')
const traverse = require('@babel/traverse').default

/**
 * 调用链追溯器
 * 专门用于追溯method类型的触发源到最终的可视控件
 */
class CallChainTracer {
  constructor() {
  }

  /**
   * 追溯所有method类型的触发源到可视控件
   * @param {Array} apiMappings - API映射数组
   * @returns {Array} 增强的API映射数组
   */
  traceMethodTriggersToVisualComponents(apiMappings) {
    const enhancedApiMappings = apiMappings.map(module => {
      const enhancedApiMappings = module.apiMappings.map(api => {
        if (!api.triggerSources || api.triggerSources.length === 0) {
          return api
        }

        // 只处理triggerType为method的触发源
        const enhancedTriggerSources = api.triggerSources.map(trigger => {
          if (trigger.triggerType === 'method') {
            return this.traceMethodToVisualComponent(
              trigger,
              module.module,
              module.serviceName,
              api.apiMethodName
            )
          }
          return trigger
        })

        return {
          ...api,
          triggerSources: enhancedTriggerSources
        }
      })

      return {
        ...module,
        apiMappings: enhancedApiMappings
      }
    })

    return enhancedApiMappings
  }

  /**
   * 追溯单个method到可视控件
   * @param {Object} trigger - 触发源对象
   * @param {string} moduleName - 模块名称
   * @param {string} serviceName - 服务名称
   * @param {string} apiMethodName - API方法名称
   * @returns {Object} 增强的触发源对象
   */
  traceMethodToVisualComponent(trigger, moduleName, serviceName, apiMethodName) {
    try {
      // 查找组件文件
      const componentPath = this.findComponentFile(trigger.component, moduleName)
      if (!componentPath) {
        return trigger
      }

      const content = readFileSync(componentPath, 'utf-8')
      
      // 解析Vue组件
      const ast = this.parseVueComponent(content)
      if (!ast) return trigger

      // 建立函数调用关系映射
      const functionCallMap = this.buildFunctionCallMap(ast)
      
      // 追溯method到可视控件
      const visualContext = this.traceToVisualComponent(
        trigger.triggerName,
        functionCallMap,
        componentPath,
        trigger.component
      )

      if (visualContext) {
        return {
          ...trigger,
          triggerName: visualContext.triggerName,
          triggerType: visualContext.triggerType
        }
      }

      return trigger
    } catch (error) {
      return trigger
    }
  }

  /**
   * 查找组件文件
   * @param {string} componentName - 组件名称
   * @param {string} moduleName - 模块名称
   * @returns {string|null} 组件文件路径
   */
  findComponentFile(componentName, moduleName) {
    // 优先在指定模块中查找
    if (moduleName) {
      // 检查views目录
      const viewPath = resolve(__dirname, `../../src/renderer/modules/${moduleName}/views/${componentName}.vue`)
      if (existsSync(viewPath)) {
        return viewPath
      }
      
      // 检查components目录
      const componentPath = resolve(__dirname, `../../src/renderer/modules/${moduleName}/components/${componentName}.vue`)
      if (existsSync(componentPath)) {
        return componentPath
      }
    }
    
    return null
  }

  /**
   * 解析Vue组件内容
   * @param {string} content - 组件内容
   * @returns {Object|null} AST对象
   */
  parseVueComponent(content) {
    try {
      // 提取script部分
      const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/)
      if (!scriptMatch) {
        return null
      }
      
      const scriptContent = scriptMatch[1]
      
      // 使用Babel解析JavaScript
      const ast = parser.parse(scriptContent, {
        sourceType: 'module',
        plugins: ['jsx', 'typescript']
      })
      
      return ast
    } catch (error) {
      return null
    }
  }

  /**
   * 建立函数调用关系映射
   * @param {Object} ast - AST对象
   * @returns {Map} 函数调用关系映射
   */
  buildFunctionCallMap(ast) {
    const functionCallMap = new Map()
    const self = this

    traverse(ast, {
      CallExpression(path) {
        const { node } = path
        if (node.callee && node.callee.type === 'Identifier') {
          const functionName = node.callee.name
          const parentFunction = self.findParentFunction(path)
          
          if (parentFunction) {
            if (!functionCallMap.has(functionName)) {
              functionCallMap.set(functionName, { callers: [] })
            }
            const funcInfo = functionCallMap.get(functionName)
            if (!funcInfo.callers) funcInfo.callers = []
            funcInfo.callers.push(parentFunction)
          }
        }
      }
    })

    return functionCallMap
  }

  /**
   * 查找父级函数
   * @param {Object} path - Babel路径对象
   * @returns {string|null} 父级函数名
   */
  findParentFunction(path) {
    let currentPath = path.parentPath
    while (currentPath) {
      const { node } = currentPath
      
      if (node.type === 'FunctionDeclaration' && node.id) {
        return node.id.name
      }
      
      if (node.type === 'VariableDeclarator' && 
          node.id && node.id.type === 'Identifier' &&
          node.init && node.init.type === 'ArrowFunctionExpression') {
        return node.id.name
      }
      
      if (node.type === 'ObjectMethod' && node.key) {
        return node.key.name
      }
      
      currentPath = currentPath.parentPath
    }
    return null
  }

  /**
   * 追溯method到可视控件
   * @param {string} methodName - 方法名称
   * @param {Map} functionCallMap - 函数调用关系映射
   * @param {string} filePath - 组件文件路径
   * @param {string} componentName - 组件名称
   * @returns {Object|null} 可视控件上下文
   */
  traceToVisualComponent(methodName, functionCallMap, filePath, componentName) {
    try {
      // 读取组件文件内容
      const content = readFileSync(filePath, 'utf-8')
      
      // 分析模板中的事件绑定
      const visualContext = this.analyzeTemplateForMethod(content, methodName, componentName, filePath)
      if (visualContext) {
        return visualContext
      }
      
      // 如果模板中没有找到，检查是否有其他方法调用了这个方法
      const callerContext = this.findMethodCaller(methodName, functionCallMap)
      if (callerContext) {
        // 检查调用者是否是生命周期钩子
        if (this.isLifecycleHook(callerContext)) {
          return {
            triggerName: '',
            triggerType: 'page'
          }
        }
        
        // 继续递归追溯
        return this.traceToVisualComponent(callerContext, functionCallMap, filePath, componentName)
      }
      
    } catch (error) {
      // 静默处理错误
    }
    
    return null
  }

  /**
   * 分析模板中的方法调用
   * @param {string} content - 组件内容
   * @param {string} methodName - 方法名称
   * @param {string} componentName - 组件名称
   * @param {string} filePath - 组件文件路径
   * @returns {Object|null} 可视控件上下文
   */
  analyzeTemplateForMethod(content, methodName, componentName, filePath) {
    try {
      // 使用Vue编译器解析单文件组件
      const { descriptor } = parse(content)
      
      if (!descriptor.template) {
        return null
      }
      
      // 解析模板AST
      const templateAst = descriptor.template.ast
      if (!templateAst) {
        return null
      }
      
      // 遍历模板AST，查找事件绑定
      return this.findEventBindingInTemplate(templateAst, methodName, componentName, filePath)
      
    } catch (error) {
      return null
    }
  }

  /**
   * 在模板AST中查找事件绑定
   * @param {Object} node - AST节点
   * @param {string} methodName - 方法名称
   * @param {string} componentName - 组件名称
   * @param {string} filePath - 组件文件路径
   * @returns {Object|null} 可视组件上下文
   */
  findEventBindingInTemplate(node, methodName, componentName, filePath) {
    if (!node) return null
    
    // 检查当前节点是否有事件绑定
    if (node.props) {
      for (const prop of node.props) {
        if (prop.type === 7) { // DIRECTIVE类型
          const eventName = prop.name
          if (eventName === 'on' && prop.arg) {
            const eventType = prop.arg.content
            if (['click', 'submit', 'change', 'input'].includes(eventType)) {
              // 检查事件处理函数
              if (prop.exp && this.isMethodCall(prop.exp, methodName)) {
                const context = this.createVisualContext(node, eventType, componentName, methodName, filePath)
                
                // 如果找到的是form，需要查找其中的submit按钮
                if (context.triggerType === 'form') {
                  const submitButton = this.findSubmitButtonInForm(node, componentName, methodName, filePath)
                  if (submitButton) {
                    return submitButton
                  }
                }
                
                return context
              }
            }
          }
        }
      }
    }
    
    // 递归检查子节点
    if (node.children) {
      for (const child of node.children) {
        if (child.type === 1) { // ELEMENT类型
          const result = this.findEventBindingInTemplate(child, methodName, componentName, filePath)
          if (result) return result
        }
      }
    }
    
    return null
  }

  /**
   * 在form中查找submit按钮
   * @param {Object} formNode - form AST节点
   * @param {string} componentName - 组件名称
   * @param {string} methodName - 方法名称
   * @param {string} filePath - 组件文件路径
   * @returns {Object|null} submit按钮上下文
   */
  findSubmitButtonInForm(formNode, componentName, methodName, filePath) {
    if (!formNode || !formNode.children) return null
    
    // 递归查找submit按钮
    for (const child of formNode.children) {
      if (child.type === 1) { // ELEMENT类型
        if (child.tag === 'button') {
          // 检查是否是submit按钮
          const props = child.props || []
          const attributes = {}
          props.forEach(prop => {
            if (prop.type === 6) { // ATTRIBUTE
              attributes[prop.name] = prop.value ? prop.value.content : ''
            }
          })
          
          if (attributes.type === 'submit') {
            let triggerName = attributes.name
            if (!triggerName) {
              // 生成唯一的name属性：组件名+唯一尾缀
              triggerName = `${componentName.toLowerCase()}-submit-${this.generateUniqueSuffix()}`
            }
            return {
              triggerName: triggerName,
              triggerType: 'button'
            }
          }
        }
        
        // 递归查找子元素
        const result = this.findSubmitButtonInForm(child, componentName, methodName, filePath)
        if (result) return result
      }
    }
    
    return null
  }

  /**
   * 检查表达式是否是方法调用
   * @param {Object} exp - 表达式节点
   * @param {string} methodName - 方法名称
   * @returns {boolean} 是否是方法调用
   */
  isMethodCall(exp, methodName) {
    if (!exp) return false
    
    // 简单的方法调用：methodName
    if (exp.type === 4 && exp.content === methodName) { // SIMPLE_EXPRESSION
      return true
    }
    
    // 带参数的方法调用：methodName(...) - 检查content是否以methodName开头
    if (exp.type === 4 && exp.content && exp.content.startsWith(methodName + '(')) {
      return true
    }
    
    // 带参数的方法调用：methodName(...)
    if (exp.type === 8) { // COMPOUND_EXPRESSION
      const children = exp.children
      if (children && children.length >= 1) {
        const firstChild = children[0]
        if (firstChild.type === 4 && firstChild.content === methodName) {
          return true
        }
      }
    }
    
    // 检查AST中的方法调用
    if (exp.ast) {
      return this.checkAstMethodCall(exp.ast, methodName)
    }
    
    return false
  }

  /**
   * 检查AST中的方法调用
   * @param {Object} ast - AST节点
   * @param {string} methodName - 方法名称
   * @returns {boolean} 是否是方法调用
   */
  checkAstMethodCall(ast, methodName) {
    if (!ast) return false
    
    // 简单标识符：methodName
    if (ast.type === 'Identifier' && ast.name === methodName) {
      return true
    }
    
    // 方法调用：methodName(...)
    if (ast.type === 'CallExpression') {
      if (ast.callee && ast.callee.type === 'Identifier' && ast.callee.name === methodName) {
        return true
      }
    }
    
    return false
  }

  /**
   * 创建可视组件上下文
   * @param {Object} node - AST节点
   * @param {string} eventType - 事件类型
   * @param {string} componentName - 组件名称
   * @param {string} methodName - 方法名称
   * @param {string} filePath - 组件文件路径
   * @returns {Object} 可视组件上下文
   */
  createVisualContext(node, eventType, componentName, methodName, filePath) {
    const tag = node.tag
    const props = node.props || []
    
    // 提取元素属性
    const attributes = {}
    props.forEach(prop => {
      if (prop.type === 6) { // ATTRIBUTE
        attributes[prop.name] = prop.value ? prop.value.content : ''
      }
    })
    
    let triggerName = attributes.name || attributes.id || ''
    let triggerType = 'button' // 默认类型
    
    // 根据标签类型确定触发源类型
    if (tag === 'form') {
      triggerType = 'form'
    } else if (tag === 'button') {
      triggerType = 'button'
    } else if (tag === 'input') {
      triggerType = 'input'
    } else if (tag === 'select') {
      triggerType = 'select'
    } else if (tag === 'textarea') {
      triggerType = 'textarea'
    } else {
      // 其他元素类型
      triggerType = 'element'
    }
    
    // 如果没有名称，生成一个
    if (!triggerName) {
      triggerName = `${componentName.toLowerCase()}-${tag}-${this.generateUniqueSuffix()}`
    }
    
    return {
      triggerName: triggerName,
      triggerType: triggerType
    }
  }

  /**
   * 查找方法的调用者
   * @param {string} methodName - 方法名称
   * @param {Map} functionCallMap - 函数调用关系映射
   * @returns {string|null} 调用者方法名
   */
  findMethodCaller(methodName, functionCallMap) {
    const funcInfo = functionCallMap.get(methodName)
    if (funcInfo && funcInfo.callers && funcInfo.callers.length > 0) {
      // 返回第一个调用者
      return funcInfo.callers[0]
    }
    return null
  }

  /**
   * 检查方法名是否是生命周期钩子
   * @param {string} methodName - 方法名称
   * @returns {boolean} 是否是生命周期钩子
   */
  isLifecycleHook(methodName) {
    const lifecycleHooks = [
      'onMounted', 'onCreated', 'onBeforeMount', 'onBeforeCreate',
      'onUpdated', 'onBeforeUpdate', 'onUnmounted', 'onBeforeUnmount',
      'mounted', 'created', 'beforeMount', 'beforeCreate',
      'updated', 'beforeUpdate', 'unmounted', 'beforeUnmount',
      'setup'
    ]
    return lifecycleHooks.includes(methodName)
  }

  /**
   * 生成唯一后缀
   * @returns {string} 唯一后缀
   */
  generateUniqueSuffix() {
    return Math.random().toString(36).substr(2, 6)
  }
}

module.exports = CallChainTracer