699680c93a
- 将preset.ts移动到config目录，符合架构规范 - 迁移php-tools到java-tools，参考Java架构而非PHP - 清理AI层文档，整合为单一README - 删除core层，专注boot和ai层 - 集成AI层与Boot层，实现100%组件集成 - 清理废弃js文件和临时报告文件 - 更新导入路径，保持代码一致性
555 lines
16 KiB
JavaScript
555 lines
16 KiB
JavaScript
const fs = require('fs');
|
||
const path = require('path');
|
||
|
||
/**
|
||
* NestJS模块生成器 (参考Java架构)
|
||
* 为每个模块创建对应的.module.ts文件并正确引用所有组件
|
||
*/
|
||
class ModuleGenerator {
|
||
constructor() {
|
||
this.config = {
|
||
javaBasePath: '/Users/wanwu/Documents/wwjcloud/wwjcloud-nsetjs/niucloud-java/niucloud-core/src/main/java',
|
||
nestjsBasePath: '/Users/wanwu/Documents/wwjcloud/wwjcloud-nsetjs/wwjcloud-nest-v1/libs/wwjcloud-core/src',
|
||
discoveryResultPath: './java-discovery-result.json',
|
||
whitelistModules: [], // 空数组=全部业务模块，结合黑名单过滤
|
||
blacklistModules: ['job','queue','workerman','lang','menu','system'],
|
||
includeTypeOrmFeature: true
|
||
};
|
||
|
||
this.discoveryData = null;
|
||
this.stats = {
|
||
createdModules: 0,
|
||
updatedModules: 0,
|
||
errors: 0
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 运行模块生成
|
||
*/
|
||
async run() {
|
||
try {
|
||
console.log('🚀 启动NestJS模块生成器...');
|
||
console.log('目标：为每个模块创建.module.ts文件并正确引用所有组件\n');
|
||
|
||
// 第1阶段：加载Java架构发现结果（含PHP业务逻辑）
|
||
console.log('📊 第1阶段：加载Java架构发现结果（含PHP业务逻辑）...');
|
||
await this.loadDiscoveryData();
|
||
console.log(' ✅ 成功加载Java架构发现结果（含PHP业务逻辑）');
|
||
|
||
// 第2阶段：扫描现有文件结构
|
||
console.log('\n📊 第2阶段：扫描现有文件结构...');
|
||
const moduleStructure = await this.scanModuleStructure();
|
||
console.log(` ✅ 扫描了 ${Object.keys(moduleStructure).length} 个模块`);
|
||
|
||
// 第3阶段：生成模块文件
|
||
console.log('\n📊 第3阶段：生成模块文件...');
|
||
await this.generateModules(moduleStructure);
|
||
console.log(` ✅ 生成了 ${this.stats.createdModules} 个模块文件`);
|
||
|
||
// 第4阶段：生成统计报告
|
||
console.log('\n📊 第4阶段：生成统计报告...');
|
||
this.generateStatsReport();
|
||
|
||
} catch (error) {
|
||
console.error('❌ 生成过程中发生错误:', error.message);
|
||
this.stats.errors++;
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 加载Java架构发现结果（含PHP业务逻辑）
|
||
*/
|
||
async loadDiscoveryData() {
|
||
try {
|
||
const data = fs.readFileSync(this.config.discoveryResultPath, 'utf8');
|
||
this.discoveryData = JSON.parse(data);
|
||
} catch (error) {
|
||
console.log(` ⚠️ 未找到发现结果文件，跳过加载: ${error.message}`);
|
||
this.discoveryData = {};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 扫描模块结构
|
||
*/
|
||
async scanModuleStructure() {
|
||
const moduleStructure = {};
|
||
const commonPath = this.config.nestjsBasePath;
|
||
|
||
if (!fs.existsSync(commonPath)) {
|
||
console.log(' ⚠️ common目录不存在');
|
||
return moduleStructure;
|
||
}
|
||
|
||
const modules = fs.readdirSync(commonPath, { withFileTypes: true })
|
||
.filter(dirent => dirent.isDirectory())
|
||
.map(dirent => dirent.name);
|
||
|
||
for (const moduleName of modules) {
|
||
if (this.shouldSkipModule(moduleName)) {
|
||
console.log(` ⏭️ 跳过非业务模块: ${moduleName}`);
|
||
continue;
|
||
}
|
||
const modulePath = path.join(commonPath, moduleName);
|
||
moduleStructure[moduleName] = {
|
||
controllers: this.scanControllers(modulePath),
|
||
services: this.scanServices(modulePath),
|
||
entities: this.scanEntities(modulePath),
|
||
validators: this.scanValidators(modulePath),
|
||
middlewares: this.scanMiddlewares(modulePath),
|
||
jobs: this.scanJobs(modulePath),
|
||
listeners: this.scanListeners(modulePath),
|
||
commands: this.scanCommands(modulePath),
|
||
dicts: this.scanDicts(modulePath)
|
||
};
|
||
}
|
||
|
||
return moduleStructure;
|
||
}
|
||
|
||
/**
|
||
* 读取实际文件中的类名
|
||
*/
|
||
getActualClassName(filePath) {
|
||
try {
|
||
if (!fs.existsSync(filePath)) {
|
||
return null;
|
||
}
|
||
|
||
const content = fs.readFileSync(filePath, 'utf8');
|
||
const match = content.match(/export\s+(?:class|interface|enum)\s+(\w+)/);
|
||
return match ? match[1] : null;
|
||
} catch (error) {
|
||
console.error(`读取文件 ${filePath} 时出错:`, error.message);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 扫描控制器
|
||
*/
|
||
scanControllers(modulePath) {
|
||
const controllers = [];
|
||
const controllersPath = path.join(modulePath, 'controllers');
|
||
|
||
if (fs.existsSync(controllersPath)) {
|
||
const layers = ['adminapi', 'api'];
|
||
for (const layer of layers) {
|
||
const layerPath = path.join(controllersPath, layer);
|
||
if (fs.existsSync(layerPath)) {
|
||
const allFiles = fs.readdirSync(layerPath);
|
||
const controllerFiles = allFiles.filter(file => file.endsWith('.controller.ts'));
|
||
|
||
if (controllerFiles.length > 0) {
|
||
console.log(` 发现 ${layer} 层控制器: ${controllerFiles.join(', ')}`);
|
||
}
|
||
|
||
const files = controllerFiles.map(file => {
|
||
const filePath = path.join(layerPath, file);
|
||
const actualClassName = this.getActualClassName(filePath);
|
||
return {
|
||
name: actualClassName || this.guessControllerClassName(file),
|
||
path: `./controllers/${layer}/${file}`,
|
||
layer: layer
|
||
};
|
||
});
|
||
controllers.push(...files);
|
||
}
|
||
}
|
||
}
|
||
|
||
return controllers;
|
||
}
|
||
|
||
/**
|
||
* 扫描服务
|
||
*/
|
||
scanServices(modulePath) {
|
||
const services = [];
|
||
const servicesPath = path.join(modulePath, 'services');
|
||
|
||
if (fs.existsSync(servicesPath)) {
|
||
const layers = ['admin', 'api', 'core'];
|
||
for (const layer of layers) {
|
||
const layerPath = path.join(servicesPath, layer);
|
||
if (fs.existsSync(layerPath)) {
|
||
const files = fs.readdirSync(layerPath)
|
||
.filter(file => file.endsWith('.service.ts'))
|
||
.map(file => {
|
||
const filePath = path.join(layerPath, file);
|
||
const actualClassName = this.getActualClassName(filePath);
|
||
return {
|
||
name: actualClassName || this.guessServiceClassName(file, layer),
|
||
path: `./services/${layer}/${file}`,
|
||
layer: layer
|
||
};
|
||
});
|
||
services.push(...files);
|
||
}
|
||
}
|
||
}
|
||
|
||
return services;
|
||
}
|
||
|
||
/**
|
||
* 扫描实体
|
||
*/
|
||
scanEntities(modulePath) {
|
||
const entities = [];
|
||
const entitiesPath = path.join(modulePath, 'entity');
|
||
|
||
if (fs.existsSync(entitiesPath)) {
|
||
const files = fs.readdirSync(entitiesPath)
|
||
.filter(file => file.endsWith('.entity.ts'))
|
||
.map(file => ({
|
||
name: this.getActualClassName(path.join(entitiesPath, file)) || this.guessEntityClassName(file),
|
||
path: `./entity/${file}`
|
||
}));
|
||
entities.push(...files);
|
||
}
|
||
|
||
return entities;
|
||
}
|
||
|
||
/**
|
||
* 扫描验证器
|
||
*/
|
||
scanValidators(modulePath) {
|
||
const validators = [];
|
||
const validatorsPath = path.join(modulePath, 'dto');
|
||
|
||
if (fs.existsSync(validatorsPath)) {
|
||
const files = fs.readdirSync(validatorsPath, { recursive: true })
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./dto/${file}`
|
||
}));
|
||
validators.push(...files);
|
||
}
|
||
|
||
return validators;
|
||
}
|
||
|
||
/**
|
||
* 扫描中间件
|
||
*/
|
||
scanMiddlewares(modulePath) {
|
||
const middlewares = [];
|
||
const middlewaresPath = path.join(modulePath, 'guards');
|
||
|
||
if (fs.existsSync(middlewaresPath)) {
|
||
const files = fs.readdirSync(middlewaresPath)
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./guards/${file}`
|
||
}));
|
||
middlewares.push(...files);
|
||
}
|
||
|
||
return middlewares;
|
||
}
|
||
|
||
/**
|
||
* 扫描任务
|
||
*/
|
||
scanJobs(modulePath) {
|
||
const jobs = [];
|
||
const jobsPath = path.join(modulePath, 'jobs');
|
||
|
||
if (fs.existsSync(jobsPath)) {
|
||
const files = fs.readdirSync(jobsPath)
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./jobs/${file}`
|
||
}));
|
||
jobs.push(...files);
|
||
}
|
||
|
||
return jobs;
|
||
}
|
||
|
||
/**
|
||
* 扫描监听器
|
||
*/
|
||
scanListeners(modulePath) {
|
||
const listeners = [];
|
||
const listenersPath = path.join(modulePath, 'listeners');
|
||
|
||
if (fs.existsSync(listenersPath)) {
|
||
const files = fs.readdirSync(listenersPath)
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./listeners/${file}`
|
||
}));
|
||
listeners.push(...files);
|
||
}
|
||
|
||
return listeners;
|
||
}
|
||
|
||
/**
|
||
* 扫描命令
|
||
*/
|
||
scanCommands(modulePath) {
|
||
const commands = [];
|
||
const commandsPath = path.join(modulePath, 'commands');
|
||
|
||
if (fs.existsSync(commandsPath)) {
|
||
const files = fs.readdirSync(commandsPath)
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./commands/${file}`
|
||
}));
|
||
commands.push(...files);
|
||
}
|
||
|
||
return commands;
|
||
}
|
||
|
||
/**
|
||
* 扫描字典
|
||
*/
|
||
scanDicts(modulePath) {
|
||
const dicts = [];
|
||
const dictsPath = path.join(modulePath, 'dicts');
|
||
|
||
if (fs.existsSync(dictsPath)) {
|
||
const files = fs.readdirSync(dictsPath)
|
||
.filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'))
|
||
.map(file => ({
|
||
name: file.replace('.ts', ''),
|
||
path: `./dicts/${file}`
|
||
}));
|
||
dicts.push(...files);
|
||
}
|
||
|
||
return dicts;
|
||
}
|
||
|
||
/**
|
||
* 生成模块文件
|
||
*/
|
||
async generateModules(moduleStructure) {
|
||
console.log(' 🔨 生成模块文件...');
|
||
|
||
for (const [moduleName, components] of Object.entries(moduleStructure)) {
|
||
try {
|
||
await this.generateModuleFile(moduleName, components);
|
||
this.stats.createdModules++;
|
||
} catch (error) {
|
||
console.error(` ❌ 生成模块 ${moduleName} 失败:`, error.message);
|
||
this.stats.errors++;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成单个模块文件
|
||
*/
|
||
async generateModuleFile(moduleName, components) {
|
||
const modulePath = path.join(this.config.nestjsBasePath, moduleName, `${moduleName}.module.ts`);
|
||
|
||
// 生成模块内容
|
||
const moduleContent = this.generateModuleContent(moduleName, components);
|
||
|
||
// 确保目录存在
|
||
this.ensureDir(path.dirname(modulePath));
|
||
|
||
// 写入文件
|
||
fs.writeFileSync(modulePath, moduleContent);
|
||
console.log(` ✅ 创建模块: ${moduleName}/${moduleName}.module.ts`);
|
||
}
|
||
|
||
/**
|
||
* 生成模块内容
|
||
*/
|
||
generateModuleContent(moduleName, components) {
|
||
const className = this.toPascalCase(moduleName) + 'Module';
|
||
|
||
let imports = [];
|
||
let controllers = [];
|
||
let providers = [];
|
||
let exports = [];
|
||
let importSet = new Set(); // 用于去重
|
||
|
||
// TypeORM feature (可选)
|
||
const entityClassNames = components.entities.map(e => e.name).filter(Boolean);
|
||
if (this.config.includeTypeOrmFeature && entityClassNames.length > 0) {
|
||
importSet.add(`import { TypeOrmModule } from '@nestjs/typeorm';`);
|
||
imports.push(`TypeOrmModule.forFeature([${entityClassNames.join(', ')}])`);
|
||
}
|
||
|
||
// 导入控制器并注册
|
||
for (const controller of components.controllers) {
|
||
importSet.add(`import { ${controller.name} } from '${controller.path}';`);
|
||
controllers.push(controller.name);
|
||
}
|
||
|
||
// 导入服务并注册
|
||
for (const service of components.services) {
|
||
if (!importSet.has(`import { ${service.name} } from '${service.path}';`)) {
|
||
importSet.add(`import { ${service.name} } from '${service.path}';`);
|
||
providers.push(`${service.name}`);
|
||
}
|
||
}
|
||
|
||
// 导入实体（如果需要）
|
||
for (const entity of components.entities) {
|
||
if (!importSet.has(`import { ${entity.name} } from '${entity.path}';`)) {
|
||
importSet.add(`import { ${entity.name} } from '${entity.path}';`);
|
||
}
|
||
}
|
||
|
||
// 组合最终内容
|
||
const moduleContent = `${Array.from(importSet).join('\n')}
|
||
|
||
import { Module } from '@nestjs/common';
|
||
|
||
@Module({
|
||
imports: [${imports.join(', ')}],
|
||
controllers: [${controllers.join(', ')}],
|
||
providers: [${providers.join(', ')}],
|
||
exports: [${exports.join(', ')}],
|
||
})
|
||
export class ${className} {}
|
||
`;
|
||
|
||
return moduleContent;
|
||
}
|
||
|
||
/**
|
||
* 从文件内容获取导出的类名
|
||
*/
|
||
getActualClassName(filePath) {
|
||
try {
|
||
if (!fs.existsSync(filePath)) return null;
|
||
const content = fs.readFileSync(filePath, 'utf8');
|
||
const match = content.match(/export\s+class\s+(\w+)/);
|
||
return match ? match[1] : null;
|
||
} catch (error) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 由 kebab-case 实体文件名推测类名
|
||
* 例如: member.entity.ts -> MemberEntity
|
||
*/
|
||
guessEntityClassName(fileName) {
|
||
const base = fileName.replace(/\.entity\.ts$/i, '');
|
||
return this.kebabToPascal(base) + 'Entity';
|
||
}
|
||
|
||
/**
|
||
* 由 kebab-case 控制器文件名推测类名
|
||
* 例如: member-level.controller.ts -> MemberLevelController
|
||
*/
|
||
guessControllerClassName(fileName) {
|
||
const base = fileName.replace(/\.controller\.ts$/i, '');
|
||
return this.kebabToPascal(base) + 'Controller';
|
||
}
|
||
|
||
/**
|
||
* 由 kebab-case 服务文件名推测类名
|
||
* 例如: member-level.service.ts -> MemberLevelService
|
||
*/
|
||
guessServiceClassName(fileName, layer) {
|
||
const base = fileName.replace(/\.service\.ts$/i, '');
|
||
return this.kebabToPascal(base) + 'Service';
|
||
}
|
||
|
||
/**
|
||
* 确保目录存在
|
||
*/
|
||
ensureDir(dirPath) {
|
||
if (!fs.existsSync(dirPath)) {
|
||
fs.mkdirSync(dirPath, { recursive: true });
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 转换为PascalCase
|
||
*/
|
||
toPascalCase(str) {
|
||
return str.replace(/(^|_)([a-z])/g, (match, p1, p2) => p2.toUpperCase());
|
||
}
|
||
|
||
/**
|
||
* kebab-case 转 PascalCase
|
||
*/
|
||
kebabToPascal(str) {
|
||
return str
|
||
.split('-')
|
||
.filter(Boolean)
|
||
.map(s => s.charAt(0).toUpperCase() + s.slice(1))
|
||
.join('');
|
||
}
|
||
|
||
shouldSkipModule(moduleName) {
|
||
if (this.config.whitelistModules && this.config.whitelistModules.length > 0) {
|
||
if (!this.config.whitelistModules.includes(moduleName)) return true;
|
||
}
|
||
if (this.config.blacklistModules && this.config.blacklistModules.includes(moduleName)) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 获取层前缀
|
||
*/
|
||
getLayerPrefix(layer, serviceName) {
|
||
// 如果服务名已经包含Core前缀，则不需要再添加
|
||
if (layer === 'core' && serviceName.toLowerCase().startsWith('core')) {
|
||
return '';
|
||
}
|
||
|
||
const layerMap = {
|
||
'admin': 'Admin',
|
||
'api': 'Api',
|
||
'core': 'Core'
|
||
};
|
||
return layerMap[layer] || '';
|
||
}
|
||
|
||
/**
|
||
* 检查是否需要别名
|
||
*/
|
||
needsAlias(layer, serviceName) {
|
||
// 如果服务名已经包含层前缀，则不需要别名
|
||
if (layer === 'core' && serviceName.toLowerCase().startsWith('core')) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 生成统计报告
|
||
*/
|
||
generateStatsReport() {
|
||
console.log('\n📊 NestJS模块生成统计报告:');
|
||
console.log('============================================================');
|
||
console.log(` 📁 创建模块: ${this.stats.createdModules} 个`);
|
||
console.log(` 🔄 更新模块: ${this.stats.updatedModules} 个`);
|
||
console.log(` ❌ 错误数量: ${this.stats.errors} 个`);
|
||
console.log('============================================================');
|
||
console.log('\n✅ 🎉 NestJS模块生成完成！');
|
||
}
|
||
}
|
||
|
||
// 运行模块生成器
|
||
if (require.main === module) {
|
||
const generator = new ModuleGenerator();
|
||
generator.run().catch(console.error);
|
||
}
|
||
|
||
module.exports = ModuleGenerator;
|