create-dp-koa 1.1.1 → 1.1.3

package/template/src/framework/utils/DtoValidator.ts

@@ -1,164 +0,0 @@
-import { ValidationError, validate } from 'class-validator';
-import { plainToClass } from 'class-transformer';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 验证结果接口
- */
-export interface ValidationResult {
-    isValid: boolean;
-    errors: string[];
-    data?: any;
-}
-
-/**
- * DTO验证器
- * 提供企业级数据验证功能
- */
-export class DtoValidator {
-    /**
-     * 验证DTO对象
-     * @param dtoClass DTO类
-     * @param data 要验证的数据
-     * @param skipMissingProperties 是否跳过缺失属性
-     */
-    static async validate<T>(
-        dtoClass: new () => T,
-        data: any,
-        skipMissingProperties: boolean = false
-    ): Promise<ValidationResult> {
-        try {
-            // 将普通对象转换为DTO类实例
-            const dto = plainToClass(dtoClass, data);
-            
-            // 执行验证
-            const errors = await validate(dto as any, {
-                skipMissingProperties,
-                whitelist: true, // 只允许白名单中的属性
-                forbidNonWhitelisted: true, // 禁止非白名单属性
-                transform: true, // 自动转换类型
-            });
-
-            if (errors.length === 0) {
-                return {
-                    isValid: true,
-                    errors: [],
-                    data: dto
-                };
-            }
-
-            // 提取错误信息
-            const errorMessages = this.extractErrorMessages(errors);
-            
-            logger.warn('DTO验证失败:', {
-                dtoClass: dtoClass.name,
-                errors: errorMessages,
-                data: data
-            });
-
-            return {
-                isValid: false,
-                errors: errorMessages,
-                data: null
-            };
-        } catch (error) {
-            logger.error('DTO验证过程中发生错误:', error as Error);
-            return {
-                isValid: false,
-                errors: ['验证过程中发生内部错误'],
-                data: null
-            };
-        }
-    }
-
-    /**
-     * 提取验证错误信息
-     * @param errors 验证错误数组
-     */
-    private static extractErrorMessages(errors: ValidationError[]): string[] {
-        const messages: string[] = [];
-
-        for (const error of errors) {
-            if (error.constraints) {
-                // 添加约束错误信息
-                messages.push(...Object.values(error.constraints));
-            }
-
-            if (error.children && error.children.length > 0) {
-                // 递归处理嵌套错误
-                messages.push(...this.extractErrorMessages(error.children));
-            }
-        }
-
-        return messages;
-    }
-
-    /**
-     * 验证并转换DTO
-     * @param dtoClass DTO类
-     * @param data 要验证的数据
-     */
-    static async validateAndTransform<T>(
-        dtoClass: new () => T,
-        data: any
-    ): Promise<ValidationResult> {
-        return await this.validate(dtoClass, data, false);
-    }
-
-    /**
-     * 验证部分DTO（允许缺失属性）
-     * @param dtoClass DTO类
-     * @param data 要验证的数据
-     */
-    static async validatePartial<T>(
-        dtoClass: new () => T,
-        data: any
-    ): Promise<ValidationResult> {
-        return await this.validate(dtoClass, data, true);
-    }
-
-    /**
-     * 批量验证DTO
-     * @param validations 验证配置数组
-     */
-    static async validateBatch(
-        validations: Array<{
-            dtoClass: new () => any;
-            data: any;
-            skipMissingProperties?: boolean;
-        }>
-    ): Promise<ValidationResult[]> {
-        const results: ValidationResult[] = [];
-
-        for (const validation of validations) {
-            const result = await this.validate(
-                validation.dtoClass,
-                validation.data,
-                validation.skipMissingProperties || false
-            );
-            results.push(result);
-        }
-
-        return results;
-    }
-
-    /**
-     * 检查验证结果是否全部通过
-     * @param results 验证结果数组
-     */
-    static allValid(results: ValidationResult[]): boolean {
-        return results.every(result => result.isValid);
-    }
-
-    /**
-     * 获取所有验证错误
-     * @param results 验证结果数组
-     */
-    static getAllErrors(results: ValidationResult[]): string[] {
-        const allErrors: string[] = [];
-        for (const result of results) {
-            allErrors.push(...result.errors);
-        }
-        return allErrors;
-    }
-}

package/template/src/framework/utils/MigrationHelper.ts

@@ -1,179 +0,0 @@
-import { ProcessorManager } from '@src/framework/decorator/processor/ProcessorManager';
-import { logger } from '@src/framework/utils/logger';
-import { getRuntimeEnvironmentLabel } from '@src/framework/utils/function';
-
-/**
- * 迁移工具类
- * 用于帮助从旧注解系统迁移到新注解处理器系统
- */
-export class MigrationHelper {
-    private static initialized = false;
-
-    /**
-     * 检查控制器是否使用了新注解系统
-     */
-    static isUsingNewAnnotationSystem(controller: any): boolean {
-        return !!(controller.$_Annotations);
-    }
-
-    /**
-     * 检查控制器是否使用了旧注解系统
-     */
-    static isUsingLegacyAnnotationSystem(controller: any): boolean {
-        return !!(controller.$_MethdosParamInfo || 
-                 controller.$_ResponseValidator || 
-                 controller.$_ControllerCache ||
-                 controller.$_ResponseCode ||
-                 controller.$_ResponseHeader);
-    }
-
-    /**
-     * 检查控制器是否使用了混合注解系统
-     */
-    static isUsingMixedAnnotationSystem(controller: any): boolean {
-        return this.isUsingNewAnnotationSystem(controller) && 
-               this.isUsingLegacyAnnotationSystem(controller);
-    }
-
-    /**
-     * 初始化新注解系统
-     */
-    static initializeNewSystem(): void {
-        if (!this.initialized) {
-            ProcessorManager.initialize();
-            this.initialized = true;
-            logger.info('新注解处理器系统已初始化');
-        }
-    }
-
-    /**
-     * 获取系统状态信息
-     */
-    static getSystemStatus(): {
-        newSystemEnabled: boolean;
-        newSystemInitialized: boolean;
-        environment: string;
-    } {
-        return {
-            newSystemEnabled: process.env.USE_NEW_ANNOTATION_SYSTEM === '1',
-            newSystemInitialized: this.initialized,
-            environment: getRuntimeEnvironmentLabel()
-        };
-    }
-
-    /**
-     * 检查控制器兼容性
-     */
-    static checkControllerCompatibility(controller: any): {
-        compatible: boolean;
-        issues: string[];
-        recommendations: string[];
-    } {
-        const issues: string[] = [];
-        const recommendations: string[] = [];
-
-        if (this.isUsingMixedAnnotationSystem(controller)) {
-            issues.push('控制器同时使用了新旧注解系统');
-            recommendations.push('建议完全迁移到新注解系统，移除旧注解');
-        }
-
-        if (this.isUsingLegacyAnnotationSystem(controller) && !this.isUsingNewAnnotationSystem(controller)) {
-            recommendations.push('建议迁移到新注解系统以获得更好的功能和性能');
-        }
-
-        return {
-            compatible: issues.length === 0,
-            issues,
-            recommendations
-        };
-    }
-
-    /**
-     * 生成迁移报告
-     */
-    static generateMigrationReport(controllers: any[]): {
-        total: number;
-        legacy: number;
-        new: number;
-        mixed: number;
-        compatible: number;
-        incompatible: number;
-        recommendations: string[];
-    } {
-        let legacy = 0;
-        let newSystem = 0;
-        let mixed = 0;
-        let compatible = 0;
-        let incompatible = 0;
-        const allRecommendations: string[] = [];
-
-        controllers.forEach(controller => {
-            const compatibility = this.checkControllerCompatibility(controller);
-            
-            if (this.isUsingLegacyAnnotationSystem(controller) && !this.isUsingNewAnnotationSystem(controller)) {
-                legacy++;
-            } else if (this.isUsingNewAnnotationSystem(controller) && !this.isUsingLegacyAnnotationSystem(controller)) {
-                newSystem++;
-            } else if (this.isUsingMixedAnnotationSystem(controller)) {
-                mixed++;
-            }
-
-            if (compatibility.compatible) {
-                compatible++;
-            } else {
-                incompatible++;
-            }
-
-            allRecommendations.push(...compatibility.recommendations);
-        });
-
-        return {
-            total: controllers.length,
-            legacy,
-            new: newSystem,
-            mixed,
-            compatible,
-            incompatible,
-            recommendations: [...new Set(allRecommendations)] // 去重
-        };
-    }
-
-    /**
-     * 启用新注解系统
-     */
-    static enableNewSystem(): void {
-        process.env.USE_NEW_ANNOTATION_SYSTEM = '1';
-        this.initializeNewSystem();
-        logger.info('新注解系统已启用');
-    }
-
-    /**
-     * 禁用新注解系统
-     */
-    static disableNewSystem(): void {
-        process.env.USE_NEW_ANNOTATION_SYSTEM = '0';
-        logger.info('新注解系统已禁用，使用旧系统');
-    }
-
-    /**
-     * 切换注解系统
-     */
-    static toggleSystem(): boolean {
-        const currentState = process.env.USE_NEW_ANNOTATION_SYSTEM === '1';
-        if (currentState) {
-            this.disableNewSystem();
-            return false;
-        } else {
-            this.enableNewSystem();
-            return true;
-        }
-    }
-
-    /**
-     * 获取当前系统状态
-     */
-    static getCurrentSystem(): 'legacy' | 'new' | 'mixed' {
-        const newSystemEnabled = process.env.USE_NEW_ANNOTATION_SYSTEM === '1';
-        return newSystemEnabled ? 'new' : 'legacy';
-    }
-}

package/template/src/framework/utils/MigrationManager.ts

@@ -1,256 +0,0 @@
-import { DataSource, DataSourceOptions } from 'typeorm';
-import { logger } from '@src/framework/utils/logger';
-import { isDebug } from '@src/framework/utils/function';
-import dbEntities from '@src/entity';
-
-/**
- * 数据库迁移管理器
- * 提供企业级数据库迁移功能
- */
-export class MigrationManager {
-    private static instance: MigrationManager;
-    private dataSource: DataSource | null = null;
-
-    private constructor() {}
-
-    static getInstance(): MigrationManager {
-        if (!MigrationManager.instance) {
-            MigrationManager.instance = new MigrationManager();
-        }
-        return MigrationManager.instance;
-    }
-
-    /**
-     * 设置数据源
-     */
-    setDataSource(dataSource: DataSource): void {
-        this.dataSource = dataSource;
-    }
-
-    /**
-     * 获取生产环境数据库配置
-     * 关闭synchronize，启用迁移
-     */
-    getProductionConfig(): DataSourceOptions {
-        return {
-            type: "mysql",
-            host: process.env.db_host || '127.0.0.1',
-            port: parseInt(process.env.db_port || "3306"),
-            username: process.env.db_username || 'root',
-            password: process.env.db_password || '',
-            database: process.env.db_database || 'production_db',
-            entities: dbEntities,
-            synchronize: false, // 生产环境关闭自动同步
-            logging: false,
-            migrations: ['src/migrations/*.ts'],
-            migrationsRun: false, // 手动控制迁移执行
-            migrationsTableName: 'migrations',
-            // 连接池配置
-            extra: {
-                connectionLimit: 20,
-                acquireTimeout: 60000,
-                timeout: 60000,
-                reconnect: true,
-            }
-        };
-    }
-
-    /**
-     * 获取开发环境数据库配置
-     * 启用synchronize用于快速开发
-     */
-    getDevelopmentConfig(): DataSourceOptions {
-        return {
-            type: "mysql",
-            host: process.env.db_host || '127.0.0.1',
-            port: parseInt(process.env.db_port || "3306"),
-            username: process.env.db_username || 'test',
-            password: process.env.db_password || 'test',
-            database: process.env.db_database || 'test',
-            entities: dbEntities,
-            synchronize: true, // 开发环境启用自动同步
-            logging: true,
-            migrations: ['src/migrations/*.ts'],
-            migrationsRun: false,
-        };
-    }
-
-    /**
-     * 获取测试环境数据库配置
-     */
-    getTestConfig(): DataSourceOptions {
-        return {
-            type: "mysql",
-            host: process.env.db_host || '127.0.0.1',
-            port: parseInt(process.env.db_port || "3306"),
-            username: process.env.db_username || 'test',
-            password: process.env.db_password || 'test',
-            database: process.env.db_database || 'test',
-            entities: dbEntities,
-            synchronize: true, // 测试环境启用自动同步
-            logging: false,
-            dropSchema: true, // 每次测试重新创建表结构
-        };
-    }
-
-    /**
-     * 根据环境获取数据库配置
-     */
-    getConfigByEnvironment(): DataSourceOptions {
-        // Jest 等测试仍用 NODE_ENV=test，避免与「非 debug=生产」冲突
-        if (process.env.NODE_ENV === 'test') {
-            return this.getTestConfig();
-        }
-        return !isDebug() ? this.getProductionConfig() : this.getDevelopmentConfig();
-    }
-
-    /**
-     * 生成迁移文件
-     * @param name 迁移名称
-     */
-    async generateMigration(name: string): Promise<void> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        try {
-            const migrations = await this.dataSource.runMigrations();
-            logger.info(`生成迁移文件: ${name}`);
-        } catch (error) {
-            logger.error('生成迁移文件失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 执行待执行的迁移
-     */
-    async runMigrations(): Promise<void> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        try {
-            const migrations = await this.dataSource.runMigrations();
-            if (migrations.length > 0) {
-                logger.info(`执行了 ${migrations.length} 个迁移:`, migrations.map(m => m.name));
-            } else {
-                logger.info('没有待执行的迁移');
-            }
-        } catch (error) {
-            logger.error('执行迁移失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 回滚最后一个迁移
-     */
-    async undoLastMigration(): Promise<void> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        try {
-            await this.dataSource.undoLastMigration();
-            logger.info('回滚最后一个迁移成功');
-        } catch (error) {
-            logger.error('回滚迁移失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 获取迁移状态
-     */
-    async getMigrationStatus(): Promise<{
-        executed: any[];
-        pending: any[];
-    }> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        try {
-            const executedMigrations = await this.dataSource.query(
-                'SELECT * FROM migrations ORDER BY timestamp'
-            );
-            
-            const pendingMigrations = await this.dataSource.showMigrations();
-            
-            return {
-                executed: executedMigrations,
-                pending: Array.isArray(pendingMigrations) ? pendingMigrations : []
-            };
-        } catch (error) {
-            logger.error('获取迁移状态失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 检查数据库连接
-     */
-    async checkConnection(): Promise<boolean> {
-        if (!this.dataSource) {
-            return false;
-        }
-
-        try {
-            await this.dataSource.query('SELECT 1');
-            return true;
-        } catch (error) {
-            logger.error('数据库连接检查失败:', error as Error);
-            return false;
-        }
-    }
-
-    /**
-     * 创建迁移表（如果不存在）
-     */
-    async createMigrationsTable(): Promise<void> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        try {
-            await this.dataSource.query(`
-                CREATE TABLE IF NOT EXISTS migrations (
-                    id INT AUTO_INCREMENT PRIMARY KEY,
-                    timestamp BIGINT NOT NULL,
-                    name VARCHAR(255) NOT NULL,
-                    UNIQUE KEY unique_migration (timestamp, name)
-                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
-            `);
-            logger.info('迁移表创建成功');
-        } catch (error) {
-            logger.error('创建迁移表失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 备份数据库（生产环境）
-     */
-    async backupDatabase(): Promise<string> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const backupFileName = `backup_${timestamp}.sql`;
-        
-        try {
-            // 这里应该调用实际的备份工具，如mysqldump
-            logger.info(`数据库备份开始: ${backupFileName}`);
-            // 实际实现需要根据具体环境配置
-            return backupFileName;
-        } catch (error) {
-            logger.error('数据库备份失败:', error as Error);
-            throw error;
-        }
-    }
-}
-
-// 导出单例实例
-export const migrationManager = MigrationManager.getInstance();