|
|
import { resolve } from 'path' |
|
|
import fs from 'fs' |
|
|
import * as parser from '@babel/parser' |
|
|
import traverse from '@babel/traverse' |
|
|
import { parse } from '@vue/compiler-sfc' |
|
|
|
|
|
// 路由映射插件 - 基于AST解析获取实际存在的路由关系，不进行规则推断 |
|
|
export function routeMappingPlugin() { |
|
|
return { |
|
|
name: 'route-mapping', |
|
|
|
|
|
// 在构建开始时执行 |
|
|
buildStart() { |
|
|
console.log('🔧 开始分析AST和Vite编译时关系...') |
|
|
this.analyzeASTAndViteRelations() |
|
|
}, |
|
|
|
|
|
// 在开发模式下也执行 |
|
|
configureServer(server) { |
|
|
console.log('🔧 开发模式下分析AST和Vite编译时关系...') |
|
|
this.analyzeASTAndViteRelations() |
|
|
}, |
|
|
|
|
|
// 利用AST解析获取实际存在的路由关系 |
|
|
analyzeASTAndViteRelations() { |
|
|
try { |
|
|
// 1. 分析路由配置的AST |
|
|
const routerAST = this.analyzeRouterAST() |
|
|
|
|
|
// 2. 分析组件文件的AST |
|
|
const componentASTs = this.analyzeComponentASTs() |
|
|
|
|
|
// 3. 分析服务文件的AST |
|
|
const serviceASTs = this.analyzeServiceASTs() |
|
|
|
|
|
// 4. 建立真实的调用关系（只基于AST分析） |
|
|
const callRelations = this.buildCallRelations(routerAST, componentASTs, serviceASTs) |
|
|
|
|
|
// 5. 生成基于实际关系的路由映射 |
|
|
const routeMappings = this.generateRealRouteMappings(callRelations) |
|
|
|
|
|
// 6. 生成映射文件 |
|
|
this.generateRouteMappingFile(routeMappings) |
|
|
|
|
|
console.log('✅ 基于AST的实际路由关系分析完成') |
|
|
} catch (error) { |
|
|
console.error('❌ AST路由关系分析失败:', error) |
|
|
// AST分析失败时直接记录错误，不进行回退分析 |
|
|
console.error('❌ 路由映射生成失败，请检查代码结构和依赖') |
|
|
throw error |
|
|
} |
|
|
}, |
|
|
|
|
|
// 分析路由AST |
|
|
analyzeRouterAST() { |
|
|
const routerPath = resolve(__dirname, '../src/renderer/router/index.js') |
|
|
if (!fs.existsSync(routerPath)) { |
|
|
throw new Error('Router file not found') |
|
|
} |
|
|
|
|
|
const routerContent = fs.readFileSync(routerPath, 'utf-8') |
|
|
const ast = parser.parse(routerContent, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const routes = [] |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找路由配置对象 |
|
|
ObjectExpression(path) { |
|
|
const properties = path.node.properties |
|
|
let route = {} |
|
|
|
|
|
properties.forEach(prop => { |
|
|
if (prop.key && prop.key.name === 'path' && prop.value && prop.value.value) { |
|
|
route.path = prop.value.value |
|
|
} |
|
|
if (prop.key && prop.key.name === 'name' && prop.value && prop.value.value) { |
|
|
route.name = prop.value.value |
|
|
} |
|
|
if (prop.key && prop.key.name === 'component' && prop.value) { |
|
|
route.component = this.extractComponentName(prop.value) |
|
|
} |
|
|
}) |
|
|
|
|
|
if (route.path) { |
|
|
route.module = this.extractModuleFromPath(route.path) |
|
|
routes.push(route) |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return { routes, ast } |
|
|
}, |
|
|
|
|
|
// 分析组件AST |
|
|
analyzeComponentASTs() { |
|
|
const componentASTs = new Map() |
|
|
const componentFiles = this.findComponentFiles() |
|
|
|
|
|
componentFiles.forEach(componentFile => { |
|
|
try { |
|
|
const content = fs.readFileSync(componentFile.path, 'utf-8') |
|
|
|
|
|
if (componentFile.path.endsWith('.vue')) { |
|
|
// 解析Vue文件 |
|
|
const { descriptor } = parse(content) |
|
|
const scriptContent = descriptor.script?.content || '' |
|
|
|
|
|
if (scriptContent) { |
|
|
const scriptAST = parser.parse(scriptContent, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeVueComponentAST(scriptAST, componentFile.name) |
|
|
componentASTs.set(componentFile.name, { |
|
|
...analysis, |
|
|
file: componentFile, |
|
|
template: descriptor.template?.content || '' |
|
|
}) |
|
|
} |
|
|
} else { |
|
|
// 解析JS文件 |
|
|
const ast = parser.parse(content, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeJavaScriptComponentAST(ast, componentFile.name) |
|
|
componentASTs.set(componentFile.name, { |
|
|
...analysis, |
|
|
file: componentFile |
|
|
}) |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn(`⚠️ 解析组件文件失败: ${componentFile.path}`, error.message) |
|
|
} |
|
|
}) |
|
|
|
|
|
return componentASTs |
|
|
}, |
|
|
|
|
|
// 分析服务AST |
|
|
analyzeServiceASTs() { |
|
|
const serviceASTs = new Map() |
|
|
const serviceFiles = this.findServiceFiles() |
|
|
|
|
|
serviceFiles.forEach(serviceFile => { |
|
|
try { |
|
|
const content = fs.readFileSync(serviceFile.path, 'utf-8') |
|
|
const ast = parser.parse(content, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeServiceAST(ast, serviceFile.name) |
|
|
serviceASTs.set(serviceFile.name, { |
|
|
...analysis, |
|
|
file: serviceFile |
|
|
}) |
|
|
} catch (error) { |
|
|
console.warn(`⚠️ 解析服务文件失败: ${serviceFile.path}`, error.message) |
|
|
} |
|
|
}) |
|
|
|
|
|
return serviceASTs |
|
|
}, |
|
|
|
|
|
// 分析Vue组件AST |
|
|
analyzeVueComponentAST(ast, componentName) { |
|
|
const analysis = { |
|
|
imports: [], |
|
|
exports: [], |
|
|
methods: [], |
|
|
serviceCalls: [], |
|
|
events: [] |
|
|
} |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找import语句 |
|
|
ImportDeclaration(path) { |
|
|
const importSpecifiers = path.node.specifiers |
|
|
importSpecifiers.forEach(specifier => { |
|
|
if (specifier.type === 'ImportSpecifier') { |
|
|
analysis.imports.push({ |
|
|
name: specifier.imported.name, |
|
|
local: specifier.local.name, |
|
|
source: path.node.source.value |
|
|
}) |
|
|
} |
|
|
}) |
|
|
}, |
|
|
|
|
|
// 查找方法定义 |
|
|
FunctionDeclaration(path) { |
|
|
if (path.node.id) { |
|
|
analysis.methods.push(path.node.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找箭头函数 |
|
|
ArrowFunctionExpression(path) { |
|
|
if (path.parent && path.parent.type === 'VariableDeclarator' && path.parent.id) { |
|
|
analysis.methods.push(path.parent.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找服务调用 |
|
|
CallExpression(path) { |
|
|
if (path.node.callee && path.node.callee.type === 'MemberExpression') { |
|
|
const object = path.node.callee.object |
|
|
const property = path.node.callee.property |
|
|
|
|
|
if (object && property && object.name && property.name) { |
|
|
// 检查是否是服务调用 |
|
|
const serviceName = object.name |
|
|
const methodName = property.name |
|
|
|
|
|
if (serviceName.endsWith('Service')) { |
|
|
analysis.serviceCalls.push({ |
|
|
service: serviceName, |
|
|
method: methodName, |
|
|
arguments: path.node.arguments.map(arg => this.extractArgumentValue(arg)) |
|
|
}) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return analysis |
|
|
}, |
|
|
|
|
|
// 分析JavaScript组件AST |
|
|
analyzeJavaScriptComponentAST(ast, componentName) { |
|
|
return this.analyzeVueComponentAST(ast, componentName) |
|
|
}, |
|
|
|
|
|
// 分析服务AST |
|
|
analyzeServiceAST(ast, serviceName) { |
|
|
const analysis = { |
|
|
exports: [], |
|
|
methods: [], |
|
|
apiCalls: [], |
|
|
imports: [] |
|
|
} |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找export语句 |
|
|
ExportNamedDeclaration(path) { |
|
|
if (path.node.declaration && path.node.declaration.type === 'VariableDeclarator') { |
|
|
analysis.exports.push(path.node.declaration.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找方法定义 |
|
|
FunctionDeclaration(path) { |
|
|
if (path.node.id) { |
|
|
analysis.methods.push(path.node.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找API调用 |
|
|
CallExpression(path) { |
|
|
if (path.node.callee && path.node.callee.type === 'MemberExpression') { |
|
|
const object = path.node.callee.object |
|
|
const property = path.node.callee.property |
|
|
|
|
|
if (object && property) { |
|
|
// 检查是否是API调用 |
|
|
if (object.name === 'api' || object.name === 'axios' || object.name === 'http') { |
|
|
const method = property.name |
|
|
const args = path.node.arguments |
|
|
|
|
|
if (args.length > 0 && args[0].type === 'StringLiteral') { |
|
|
analysis.apiCalls.push({ |
|
|
method: method.toUpperCase(), |
|
|
path: args[0].value, |
|
|
arguments: args.slice(1).map(arg => this.extractArgumentValue(arg)) |
|
|
}) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return analysis |
|
|
}, |
|
|
|
|
|
// 建立调用关系 |
|
|
buildCallRelations(routerAST, componentASTs, serviceASTs) { |
|
|
const relations = { |
|
|
routes: routerAST.routes, |
|
|
components: new Map(), |
|
|
services: new Map(), |
|
|
callGraph: new Map(), |
|
|
imports: new Map() |
|
|
} |
|
|
|
|
|
// 建立组件关系 |
|
|
componentASTs.forEach((analysis, componentName) => { |
|
|
relations.components.set(componentName, { |
|
|
...analysis, |
|
|
serviceDependencies: analysis.serviceCalls.map(call => call.service) |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 建立服务关系 |
|
|
serviceASTs.forEach((analysis, serviceName) => { |
|
|
relations.services.set(serviceName, { |
|
|
...analysis, |
|
|
apiEndpoints: analysis.apiCalls |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 建立调用图 |
|
|
componentASTs.forEach((componentAnalysis, componentName) => { |
|
|
const calls = [] |
|
|
|
|
|
componentAnalysis.serviceCalls.forEach(call => { |
|
|
calls.push({ |
|
|
type: 'service', |
|
|
target: call.service, |
|
|
method: call.method, |
|
|
component: componentName |
|
|
}) |
|
|
}) |
|
|
|
|
|
relations.callGraph.set(componentName, calls) |
|
|
}) |
|
|
|
|
|
return relations |
|
|
}, |
|
|
|
|
|
// 生成基于实际关系的路由映射（不进行规则推断） |
|
|
generateRealRouteMappings(callRelations) { |
|
|
const mappings = { |
|
|
mainRoutes: [], |
|
|
moduleApiMappings: {}, |
|
|
subRouteMappings: {}, |
|
|
callRelations: callRelations |
|
|
} |
|
|
|
|
|
// 生成主路由（基于实际路由配置） |
|
|
callRelations.routes.forEach(route => { |
|
|
mappings.mainRoutes.push({ |
|
|
path: route.path, |
|
|
name: route.name, |
|
|
module: route.module, |
|
|
description: this.generateDescription(route.name, route.module), |
|
|
type: this.determineRouteType(route.path, route.module), |
|
|
component: route.component |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 生成API映射（基于实际API调用） |
|
|
callRelations.services.forEach((serviceAnalysis, serviceName) => { |
|
|
const moduleName = this.extractModuleFromService(serviceName) |
|
|
if (moduleName && serviceAnalysis.apiCalls.length > 0) { |
|
|
const apiMapping = this.buildApiMappingFromRealCalls(serviceAnalysis.apiCalls, moduleName) |
|
|
mappings.moduleApiMappings[moduleName] = apiMapping |
|
|
} |
|
|
}) |
|
|
|
|
|
// 生成子路由映射（基于实际调用关系） |
|
|
mappings.subRouteMappings = this.generateSubRouteMappingsFromRelations(callRelations) |
|
|
|
|
|
return mappings |
|
|
}, |
|
|
|
|
|
// 从实际API调用构建API映射（不进行操作推断） |
|
|
buildApiMappingFromRealCalls(apiCalls, moduleName) { |
|
|
const operations = {} |
|
|
const paths = [] |
|
|
|
|
|
apiCalls.forEach(call => { |
|
|
// 使用实际的API路径作为操作名，不进行推断 |
|
|
const operationKey = `${call.method}_${call.path.replace(/[^a-zA-Z0-9]/g, '_')}` |
|
|
operations[operationKey] = { |
|
|
path: call.path, |
|
|
method: call.method |
|
|
} |
|
|
paths.push(call.path) |
|
|
}) |
|
|
|
|
|
const basePath = this.extractBasePath(paths) |
|
|
|
|
|
return { |
|
|
basePath: basePath, |
|
|
operations: operations |
|
|
} |
|
|
}, |
|
|
|
|
|
// 从API调用获取实际操作（不进行推断） |
|
|
inferOperationFromApiCall(path, method) { |
|
|
// 只返回实际存在的路径，不进行规则推断 |
|
|
return path |
|
|
}, |
|
|
|
|
|
// 从关系生成子路由映射（只基于实际存在的调用关系） |
|
|
generateSubRouteMappingsFromRelations(callRelations) { |
|
|
const subRouteMappings = {} |
|
|
|
|
|
callRelations.callGraph.forEach((calls, componentName) => { |
|
|
calls.forEach(call => { |
|
|
if (call.type === 'service') { |
|
|
// 只记录实际存在的服务调用，不生成预估的子路由 |
|
|
const serviceName = call.target |
|
|
const methodName = call.method |
|
|
|
|
|
// 检查服务是否真实存在 |
|
|
if (callRelations.services.has(serviceName)) { |
|
|
const serviceAnalysis = callRelations.services.get(serviceName) |
|
|
|
|
|
// 只记录实际存在的API调用 |
|
|
serviceAnalysis.apiCalls.forEach(apiCall => { |
|
|
const key = `${componentName}_${serviceName}_${methodName}` |
|
|
subRouteMappings[key] = { |
|
|
component: componentName, |
|
|
service: serviceName, |
|
|
method: methodName, |
|
|
apiPath: apiCall.path, |
|
|
apiMethod: apiCall.method |
|
|
} |
|
|
}) |
|
|
} |
|
|
} |
|
|
}) |
|
|
}) |
|
|
|
|
|
return subRouteMappings |
|
|
}, |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 查找组件文件 |
|
|
findComponentFiles() { |
|
|
const componentFiles = [] |
|
|
const moduleDirs = ['user-management', 'role-management', 'system-settings'] |
|
|
|
|
|
moduleDirs.forEach(moduleName => { |
|
|
const viewsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/views`) |
|
|
const componentsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/components`) |
|
|
|
|
|
if (fs.existsSync(viewsPath)) { |
|
|
const files = fs.readdirSync(viewsPath).filter(f => f.endsWith('.vue')) |
|
|
files.forEach(file => { |
|
|
componentFiles.push({ |
|
|
name: file.replace('.vue', ''), |
|
|
path: resolve(viewsPath, file), |
|
|
module: moduleName, |
|
|
type: 'view' |
|
|
}) |
|
|
}) |
|
|
} |
|
|
|
|
|
if (fs.existsSync(componentsPath)) { |
|
|
const files = fs.readdirSync(componentsPath).filter(f => f.endsWith('.vue')) |
|
|
files.forEach(file => { |
|
|
componentFiles.push({ |
|
|
name: file.replace('.vue', ''), |
|
|
path: resolve(componentsPath, file), |
|
|
module: moduleName, |
|
|
type: 'component' |
|
|
}) |
|
|
}) |
|
|
} |
|
|
}) |
|
|
|
|
|
return componentFiles |
|
|
}, |
|
|
|
|
|
// 查找服务文件 |
|
|
findServiceFiles() { |
|
|
const serviceFiles = [] |
|
|
const moduleDirs = ['user-management', 'role-management', 'system-settings'] |
|
|
|
|
|
moduleDirs.forEach(moduleName => { |
|
|
const servicesPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/services`) |
|
|
if (fs.existsSync(servicesPath)) { |
|
|
const files = fs.readdirSync(servicesPath).filter(f => f.endsWith('.js')) |
|
|
files.forEach(file => { |
|
|
serviceFiles.push({ |
|
|
name: file.replace('.js', ''), |
|
|
path: resolve(servicesPath, file), |
|
|
module: moduleName |
|
|
}) |
|
|
}) |
|
|
} |
|
|
}) |
|
|
|
|
|
return serviceFiles |
|
|
}, |
|
|
|
|
|
// 提取组件名称 |
|
|
extractComponentName(node) { |
|
|
if (node.type === 'Identifier') { |
|
|
return node.name |
|
|
} else if (node.type === 'StringLiteral') { |
|
|
return node.value |
|
|
} |
|
|
return null |
|
|
}, |
|
|
|
|
|
// 提取参数值 |
|
|
extractArgumentValue(node) { |
|
|
if (node.type === 'StringLiteral') { |
|
|
return node.value |
|
|
} else if (node.type === 'NumericLiteral') { |
|
|
return node.value |
|
|
} else if (node.type === 'Identifier') { |
|
|
return node.name |
|
|
} |
|
|
return null |
|
|
}, |
|
|
|
|
|
// 从服务方法获取实际操作（不进行推断） |
|
|
inferOperationFromServiceMethod(methodName) { |
|
|
// 只返回实际存在的方法名，不进行硬编码映射 |
|
|
return methodName |
|
|
}, |
|
|
|
|
|
// 从服务名提取模块名（基于实际文件路径） |
|
|
extractModuleFromService(serviceName) { |
|
|
// 通过实际文件路径来确定模块，而不是硬编码映射 |
|
|
const serviceFiles = this.findServiceFiles() |
|
|
const serviceFile = serviceFiles.find(file => file.name === serviceName) |
|
|
|
|
|
if (serviceFile) { |
|
|
return serviceFile.module |
|
|
} |
|
|
|
|
|
return null |
|
|
}, |
|
|
|
|
|
// 提取basePath |
|
|
extractBasePath(paths) { |
|
|
if (paths.length === 0) return '' |
|
|
|
|
|
// 找到所有路径的共同前缀 |
|
|
const firstPath = paths[0] |
|
|
let commonPrefix = '' |
|
|
|
|
|
for (let i = 0; i < firstPath.length; i++) { |
|
|
const char = firstPath[i] |
|
|
if (paths.every(path => path[i] === char)) { |
|
|
commonPrefix += char |
|
|
} else { |
|
|
break |
|
|
} |
|
|
} |
|
|
|
|
|
// 如果找到了完整的前缀，返回它 |
|
|
if (commonPrefix && !commonPrefix.endsWith('/')) { |
|
|
// 找到最后一个斜杠的位置 |
|
|
const lastSlashIndex = commonPrefix.lastIndexOf('/') |
|
|
if (lastSlashIndex > 0) { |
|
|
return commonPrefix.substring(0, lastSlashIndex + 1) |
|
|
} |
|
|
} |
|
|
|
|
|
return commonPrefix |
|
|
}, |
|
|
|
|
|
// 从路径提取模块名（基于实际路由配置） |
|
|
extractModuleFromPath(path) { |
|
|
if (path === '/' || path === '') return 'home' |
|
|
|
|
|
const segments = path.split('/').filter(Boolean) |
|
|
if (segments.length === 0) return 'home' |
|
|
|
|
|
// 获取第一个段作为模块名，不进行硬编码映射 |
|
|
return segments[0] |
|
|
}, |
|
|
|
|
|
// 生成路由描述（基于实际名称） |
|
|
generateDescription(name, module) { |
|
|
// 只使用实际的路由名称，不进行硬编码描述 |
|
|
return `${name}页面` |
|
|
}, |
|
|
|
|
|
// 确定路由类型（基于实际路径） |
|
|
determineRouteType(path, module) { |
|
|
if (path === '/' || path === '') return 'home' |
|
|
|
|
|
// 基于实际路径结构确定类型，不进行硬编码映射 |
|
|
if (path.includes('/:') || path.includes('/{')) { |
|
|
return 'detail' |
|
|
} |
|
|
|
|
|
return 'list' |
|
|
}, |
|
|
|
|
|
// 生成路由映射文件 |
|
|
generateRouteMappingFile(routeMappings) { |
|
|
const mappingContent = `// 自动生成的路由映射文件 |
|
|
// 此文件由 route-mapping-plugin 在构建时生成 |
|
|
// 基于AST解析获取实际存在的路由关系，不进行规则推断 |
|
|
// 请勿手动修改 |
|
|
|
|
|
export const mainRoutes = ${JSON.stringify(routeMappings.mainRoutes, null, 2)} |
|
|
|
|
|
// 模块到API映射配置（从AST解析提取） |
|
|
export const moduleApiMappings = ${JSON.stringify(routeMappings.moduleApiMappings, null, 2)} |
|
|
|
|
|
// 子路由到主路由的映射（从调用关系提取） |
|
|
export const subRouteMappings = ${JSON.stringify(routeMappings.subRouteMappings, null, 2)} |
|
|
|
|
|
// 分析方法和结果 |
|
|
export const analysisInfo = ${JSON.stringify({ |
|
|
method: routeMappings.method || 'ast-analysis', |
|
|
timestamp: new Date().toISOString(), |
|
|
hasCallRelations: !!routeMappings.callRelations, |
|
|
componentCount: routeMappings.callRelations?.components?.size || 0, |
|
|
serviceCount: routeMappings.callRelations?.services?.size || 0 |
|
|
}, null, 2)} |
|
|
|
|
|
export default { |
|
|
mainRoutes, |
|
|
moduleApiMappings, |
|
|
subRouteMappings, |
|
|
analysisInfo |
|
|
} |
|
|
` |
|
|
|
|
|
const outputPath = resolve(__dirname, '../src/renderer/modules/route-sync/generated-route-mapping.js') |
|
|
fs.writeFileSync(outputPath, mappingContent, 'utf-8') |
|
|
|
|
|
console.log(`✅ 基于AST实际路由关系的映射文件已生成: ${outputPath}`) |
|
|
} |
|
|
} |
|
|
}
|
|
|
|
