wwjcloud-nest-v1/wwjcloud-nest-v1/tools/auto-inject-dependencies.js

#!/usr/bin/env node

/**
 * 自动添加依赖注入工具
 * 分析Service方法中使用的依赖，自动生成构造函数
 */

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

class DependencyInjector {
  constructor() {
    this.fixedCount = 0;
    this.stats = {
      repositories: 0,
      services: 0,
      requestContext: 0,
      cacheService: 0,
      jwtService: 0,
      logger: 0
    };
  }

  processDirectory(dir) {
    const files = fs.readdirSync(dir);
    
    for (const file of files) {
      const fullPath = path.join(dir, file);
      const stat = fs.statSync(fullPath);
      
      if (stat.isDirectory()) {
        this.processDirectory(fullPath);
      } else if (file.endsWith('.service.ts') && !file.includes('addon-')) {
        this.processFile(fullPath);
      }
    }
  }

  processFile(filePath) {
    let content = fs.readFileSync(filePath, 'utf-8');
    const originalContent = content;

    // 跳过已经有完整构造函数的文件
    if (!this.hasEmptyConstructor(content)) {
      return;
    }

    // 分析依赖
    const deps = this.analyzeDependencies(content);
    
    if (deps.length === 0) {
      return; // 没有依赖，保持空构造函数
    }

    // 生成构造函数
    const newConstructor = this.generateConstructor(deps);
    
    // 添加必需的imports
    content = this.addImports(content, deps);
    
    // 替换构造函数
    content = content.replace(
      /constructor\s*\(\s*\)\s*\{\s*\}/,
      newConstructor
    );

    // 移除@ts-nocheck（如果依赖完整）
    if (this.isDependenciesComplete(deps)) {
      content = content.replace(/\/\/ @ts-nocheck\n?/, '');
    }

    if (content !== originalContent) {
      fs.writeFileSync(filePath, content, 'utf-8');
      this.fixedCount++;
      console.log(`   ✅ ${path.basename(filePath)} - 添加了 ${deps.length} 个依赖`);
    }
  }

  hasEmptyConstructor(content) {
    return /constructor\s*\(\s*\)\s*\{\s*\}/.test(content);
  }

  analyzeDependencies(content) {
    const deps = [];
    const addedDeps = new Set();

    // 1. 检查 this.xxxRepository 使用
    const repoMatches = content.matchAll(/this\.(\w+Repository)\b/g);
    for (const match of repoMatches) {
      const repoName = match[1];
      if (!addedDeps.has(repoName)) {
        // 尝试推断Entity名称
        const entityName = this.inferEntityName(repoName, content);
        if (entityName) {
          deps.push({
            type: 'repository',
            name: repoName,
            entity: entityName
          });
          addedDeps.add(repoName);
          this.stats.repositories++;
        }
      }
    }

    // 2. 检查 this.requestContext 使用
    if (/this\.requestContext\b/.test(content) && !addedDeps.has('requestContext')) {
      deps.push({
        type: 'requestContext',
        name: 'requestContext'
      });
      addedDeps.add('requestContext');
      this.stats.requestContext++;
    }

    // 3. 检查 this.cacheService 使用
    if (/this\.cacheService\b/.test(content) && !addedDeps.has('cacheService')) {
      deps.push({
        type: 'cacheService',
        name: 'cacheService'
      });
      addedDeps.add('cacheService');
      this.stats.cacheService++;
    }

    // 4. 检查 this.jwtService 使用
    if (/this\.jwtService\b/.test(content) && !addedDeps.has('jwtService')) {
      deps.push({
        type: 'jwtService',
        name: 'jwtService'
      });
      addedDeps.add('jwtService');
      this.stats.jwtService++;
    }

    // 5. 检查 this.xxxService 使用（其他Service依赖）
    const serviceMatches = content.matchAll(/this\.(\w+Service)\b/g);
    for (const match of serviceMatches) {
      const serviceName = match[1];
      // 排除特殊的service
      if (serviceName !== 'cacheService' && serviceName !== 'jwtService' && !addedDeps.has(serviceName)) {
        deps.push({
          type: 'service',
          name: serviceName,
          className: this.toClassName(serviceName)
        });
        addedDeps.add(serviceName);
        this.stats.services++;
      }
    }

    return deps;
  }

  inferEntityName(repoName, content) {
    // 尝试从 @InjectRepository 注释中推断
    const commentMatch = content.match(new RegExp(`@InjectRepository\\((\\w+)\\)\\s*private\\s+readonly\\s+${repoName}`));
    if (commentMatch) {
      return commentMatch[1];
    }

    // 从Repository名称推断（移除Repository后缀，转为PascalCase）
    const baseName = repoName.replace(/Repository$/, '');
    return this.toClassName(baseName);
  }

  toClassName(name) {
    // camelCase转PascalCase
    return name.charAt(0).toUpperCase() + name.slice(1);
  }

  generateConstructor(deps) {
    const params = [];
    
    for (const dep of deps) {
      switch (dep.type) {
        case 'repository':
          params.push(`@InjectRepository(${dep.entity}) private readonly ${dep.name}: Repository<${dep.entity}>`);
          break;
        case 'requestContext':
          params.push('private readonly requestContext: RequestContextService');
          break;
        case 'cacheService':
          params.push('private readonly cacheService: CacheService');
          break;
        case 'jwtService':
          params.push('private readonly jwtService: JwtService');
          break;
        case 'service':
          params.push(`private readonly ${dep.name}: ${dep.className}`);
          break;
      }
    }

    if (params.length === 0) {
      return 'constructor() {}';
    }

    return `constructor(\n    ${params.join(',\n    ')}\n  ) {}`;
  }

  addImports(content, deps) {
    const imports = new Set();
    let hasRepository = false;
    let hasInjectRepository = false;

    for (const dep of deps) {
      switch (dep.type) {
        case 'repository':
          hasRepository = true;
          hasInjectRepository = true;
          break;
        case 'requestContext':
          if (!content.includes('RequestContextService')) {
            imports.add("import { RequestContextService } from '@wwjCommon/http';");
          }
          break;
        case 'cacheService':
          if (!content.includes('CacheService')) {
            imports.add("import { CacheService } from '@wwjCommon/cache';");
          }
          break;
        case 'jwtService':
          if (!content.includes('JwtService')) {
            imports.add("import { JwtService } from '@nestjs/jwt';");
          }
          break;
      }
    }

    // 添加Repository相关imports
    if (hasInjectRepository && !content.includes('InjectRepository')) {
      imports.add("import { InjectRepository } from '@nestjs/typeorm';");
    }
    if (hasRepository && !content.includes('import { Repository }')) {
      imports.add("import { Repository } from 'typeorm';");
    }

    if (imports.size > 0) {
      // 在第一个import后面添加
      const firstImportIndex = content.indexOf('import');
      if (firstImportIndex !== -1) {
        const importsStr = Array.from(imports).join('\n');
        content = content.slice(0, firstImportIndex) + importsStr + '\n' + content.slice(firstImportIndex);
      }
    }

    return content;
  }

  isDependenciesComplete(deps) {
    // 如果有Repository依赖，认为依赖是完整的
    return deps.some(d => d.type === 'repository');
  }
}

console.log('╔══════════════════════════════════════════════════════════════╗');
console.log('║         🔧 自动添加依赖注入                                   ║');
console.log('║            方案A - 阶段1                                      ║');
console.log('╚══════════════════════════════════════════════════════════════╝\n');

const injector = new DependencyInjector();
const servicesDir = '/Users/wanwu/Documents/wanwujie/wwjcloud-nsetjs/wwjcloud-nest-v1/wwjcloud/libs/wwjcloud-core/src/services';

console.log('🔄 开始处理Service文件...\n');
injector.processDirectory(servicesDir);

console.log('\n╔══════════════════════════════════════════════════════════════╗');
console.log('║                      📊 处理统计                              ║');
console.log('╚══════════════════════════════════════════════════════════════╝');
console.log(`✅ 修复文件数: ${injector.fixedCount} 个`);
console.log(`\n📦 添加的依赖类型统计:`);
console.log(`   - Repository: ${injector.stats.repositories} 个`);
console.log(`   - RequestContext: ${injector.stats.requestContext} 个`);
console.log(`   - CacheService: ${injector.stats.cacheService} 个`);
console.log(`   - JwtService: ${injector.stats.jwtService} 个`);
console.log(`   - 其他Service: ${injector.stats.services} 个`);
console.log('');