wwjcloud-nest-v1/wwjcloud-nest-v1/tools/java-to-nestjs-migration/generators/method-stub-generator.js

const fs = require('fs');
const path = require('path');

/**
 * 方法存根生成器
 * 自动为Controller调用但Service中缺失的方法生成存根
 */
class MethodStubGenerator {
  constructor() {
    this.missingMethods = new Map(); // serviceFile -> [methods]
  }

  /**
   * 扫描Controller，找出所有Service调用
   */
  scanControllerServiceCalls(controllersDir) {
    console.log('🔍 扫描Controller的Service调用...');
    const serviceCalls = new Map();

    this.walkDirectory(controllersDir, (filePath) => {
      if (!filePath.endsWith('.controller.ts')) return;

      const content = fs.readFileSync(filePath, 'utf-8');
      
      // 提取Service属性注入
      const serviceProps = this.extractServiceProperties(content);
      
      // 提取每个Service的方法调用
      serviceProps.forEach(serviceProp => {
        const methods = this.extractServiceMethodCalls(content, serviceProp);
        if (methods.length > 0) {
          const key = serviceProp.className;
          if (!serviceCalls.has(key)) {
            serviceCalls.set(key, { className: serviceProp.className, methods: new Set() });
          }
          methods.forEach(m => serviceCalls.get(key).methods.add(m));
        }
      });
    });

    return serviceCalls;
  }

  /**
   * 提取Service属性
   */
  extractServiceProperties(content) {
    const services = [];
    const propPattern = /private\s+readonly\s+(\w+(?:Service|Mapper)):\s+(\w+)/g;
    let match;

    while ((match = propPattern.exec(content)) !== null) {
      const propName = match[1];
      const className = match[2];
      services.push({ propName, className, isMapper: propName.includes('Mapper') });
    }

    return services;
  }

  /**
   * 提取Service方法调用
   */
  extractServiceMethodCalls(content, serviceProp) {
    const methods = new Set();
    const pattern = new RegExp(`this\\.${serviceProp.propName}\\.(\\w+)\\(`, 'g');
    let match;

    while ((match = pattern.exec(content)) !== null) {
      methods.add(match[1]);
    }

    return Array.from(methods);
  }

  /**
   * 检查Service文件中缺失的方法
   */
  checkMissingMethods(servicesDir, serviceCalls) {
    console.log('🔍 检查缺失的Service方法...');
    const missingMethods = new Map();

    serviceCalls.forEach((serviceInfo, className) => {
      // 查找Service文件
      const serviceFile = this.findServiceFile(servicesDir, className);
      if (!serviceFile) {
        console.warn(`⚠️  未找到Service文件: ${className}`);
        return;
      }

      const content = fs.readFileSync(serviceFile, 'utf-8');
      const missing = [];

      serviceInfo.methods.forEach(method => {
        if (!content.includes(`async ${method}(`)) {
          missing.push(method);
        }
      });

      if (missing.length > 0) {
        missingMethods.set(serviceFile, missing);
      }
    });

    return missingMethods;
  }

  /**
   * 添加缺失的方法存根
   */
  addMissingMethodStubs(missingMethods) {
    console.log('✨ 添加缺失的方法存根...');
    let totalAdded = 0;

    missingMethods.forEach((methods, serviceFile) => {
      let content = fs.readFileSync(serviceFile, 'utf-8');
      let modified = false;

      methods.forEach(methodName => {
        const stub = this.generateMethodStub(methodName);
        const lastBraceIndex = content.lastIndexOf('}');
        
        if (lastBraceIndex !== -1) {
          content = content.substring(0, lastBraceIndex) + stub + '\n' + content.substring(lastBraceIndex);
          console.log(`  ✅ ${path.basename(serviceFile)}: ${methodName}`);
          totalAdded++;
          modified = true;
        }
      });

      if (modified) {
        fs.writeFileSync(serviceFile, content, 'utf-8');
      }
    });

    return totalAdded;
  }

  /**
   * 生成方法存根
   */
  generateMethodStub(methodName) {
    return `
  /**
   * ${methodName}
   * 自动生成的方法存根
   */
  async ${methodName}(...args: any[]): Promise<any> {
    // TODO: 实现业务逻辑
    return null;
  }
`;
  }

  /**
   * 查找Service文件
   */
  findServiceFile(servicesDir, className) {
    let found = null;
    
    this.walkDirectory(servicesDir, (filePath) => {
      if (found) return;
      
      if (filePath.endsWith('.service.ts')) {
        const content = fs.readFileSync(filePath, 'utf-8');
        if (content.includes(`export class ${className}`)) {
          found = filePath;
        }
      }
    });

    return found;
  }

  /**
   * 遍历目录
   */
  walkDirectory(dir, callback) {
    if (!fs.existsSync(dir)) return;

    const files = fs.readdirSync(dir);
    files.forEach(file => {
      const filePath = path.join(dir, file);
      const stat = fs.statSync(filePath);

      if (stat.isDirectory()) {
        this.walkDirectory(filePath, callback);
      } else {
        callback(filePath);
      }
    });
  }

  /**
   * 主流程
   */
  process(coreDir) {
    const controllersDir = path.join(coreDir, 'controllers');
    const servicesDir = path.join(coreDir, 'services');

    // 1. 修复Controller中的Mapper调用
    console.log('🔧 修复Controller中的Mapper调用...');
    const mapperFixed = this.fixMapperCalls(controllersDir);
    if (mapperFixed > 0) {
      console.log(`  ✅ 修复了 ${mapperFixed} 处Mapper调用`);
    }

    // 2. 扫描Controller调用
    const serviceCalls = this.scanControllerServiceCalls(controllersDir);
    console.log(`📊 发现 ${serviceCalls.size} 个Service被调用`);

    // 3. 检查缺失方法
    const missingMethods = this.checkMissingMethods(servicesDir, serviceCalls);
    console.log(`📊 发现 ${missingMethods.size} 个Service有缺失方法`);

    // 4. 添加存根
    if (missingMethods.size > 0) {
      const totalAdded = this.addMissingMethodStubs(missingMethods);
      console.log(`\n✅ 共添加 ${totalAdded} 个方法存根`);
    } else {
      console.log('\n✅ 所有Service方法都已存在！');
    }
  }

  /**
   * 修复Controller中的Mapper调用
   */
  fixMapperCalls(controllersDir) {
    let totalFixed = 0;

    this.walkDirectory(controllersDir, (filePath) => {
      if (!filePath.endsWith('.controller.ts')) return;

      let content = fs.readFileSync(filePath, 'utf-8');
      let modified = false;

      // 替换 this.xxxMapperService.method(args) 为 TODO
      const mapperPattern = /const result = await this\.(\w+MapperService)\.(\w+)\(([^)]*)\);/g;
      const newContent = content.replace(mapperPattern, (match, mapperName, methodName, args) => {
        modified = true;
        totalFixed++;
        return `const result = await 0; // TODO: 实现${mapperName}.${methodName}`;
      });

      if (modified) {
        fs.writeFileSync(filePath, newContent, 'utf-8');
      }
    });

    return totalFixed;
  }
}

module.exports = MethodStubGenerator;