create-dp-koa 1.1.2 → 1.1.4

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

@@ -1,207 +0,0 @@
-import { Context } from 'koa';
-import { AnnotationExecutor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { ProcessorManager } from '@src/framework/decorator/processor/ProcessorManager';
-import { logger } from '@src/framework/utils/logger';
-import { isPromise } from '@src/framework/utils/function';
-import { createCache, CacheType } from '@src/framework/utils/cache';
-
-// 使用统一的缓存管理创建控制器结果缓存
-const controllerResultCacheStore = createCache('controller-result', CacheType.CONTROLLER, {
-    stdTTL: 20, // 20秒过期
-    maxKeys: 2000 // 控制器缓存可以更多
-});
-
-/**
- * 新的控制器调用函数
- * 使用注解处理器系统
- */
-export async function callControllerWithProcessors(
-    ctx: Context,
-    controller: any,
-    methodName: string
-): Promise<void> {
-    // 确保处理器已初始化
-    ProcessorManager.initialize();
-
-    // 构建调用参数
-    const callParams = await buildCallParams(ctx, controller, methodName);
-
-    // 执行注解处理器
-    const shouldContinue = await AnnotationExecutor.execute(
-        ctx,
-        controller,
-        methodName,
-        callParams
-    );
-
-    if (!shouldContinue) {
-        // 如果处理器返回false，说明已经处理了响应，直接返回
-        return;
-    }
-
-    try {
-        // 调用控制器方法
-        const callResult = controller[methodName].apply(controller, callParams);
-        
-        // 处理响应
-        let response: any;
-        if (isPromise(callResult)) {
-            response = await callResult;
-        } else {
-            response = callResult;
-        }
-
-        // 执行响应验证
-        await executeResponseValidation(ctx, controller, methodName, response);
-
-        // 处理缓存
-        await handleCache(controller, methodName, callParams, response);
-
-        // 执行日志记录
-        await executeLogging(ctx, controller, methodName, response);
-
-        // 执行后置处理器回调
-        await executePostProcessors(ctx, controller, methodName, response);
-
-        ctx.body = response;
-
-    } catch (err) {
-        logger.error(`控制器方法 ${controller.constructor.name}.${methodName} 执行失败:`, err as Error);
-        throw err;
-    }
-}
-
-/**
- * 执行响应验证
- * 通过接口调用，避免硬编码依赖
- */
-async function executeResponseValidation(ctx: Context, controller: any, methodName: string, response: any): Promise<void> {
-    const responseValidationProcessor = ProcessorManager.getProcessor('ResponseValidation');
-    if (responseValidationProcessor && typeof responseValidationProcessor.validateResponse === 'function') {
-        try {
-            const validationErrors = await responseValidationProcessor.validateResponse(
-                controller,
-                methodName,
-                response
-            );
-            
-            if (validationErrors && validationErrors.length > 0) {
-                ctx.status = 400;
-                logger.error(validationErrors.join(', '));
-                ctx.body = `接口${methodName}返回数据参数校验异常`;
-                return;
-            }
-        } catch (error) {
-            logger.error(`响应验证处理器执行失败:`, error as Error);
-        }
-    }
-}
-
-/**
- * 执行日志记录
- * 通过接口调用，避免硬编码依赖
- */
-async function executeLogging(ctx: Context, controller: any, methodName: string, response: any): Promise<void> {
-    const loggingProcessor = ProcessorManager.getProcessor('Logging');
-    if (loggingProcessor && typeof loggingProcessor.logResponse === 'function') {
-        try {
-            await loggingProcessor.logResponse(ctx, controller, methodName, response);
-        } catch (error) {
-            logger.error(`日志处理器执行失败:`, error as Error);
-        }
-    }
-}
-
-/**
- * 执行后置处理器回调
- * 框架层通过回调机制调用业务层的后置处理方法
- */
-async function executePostProcessors(ctx: Context, controller: any, methodName: string, response: any): Promise<void> {
-    // 获取所有已注册的处理器
-    const processors = ProcessorManager.getAllProcessors();
-    
-    for (const processor of processors) {
-        // 检查处理器是否有后置处理方法
-        if (typeof processor.postProcess === 'function') {
-            try {
-                await processor.postProcess(ctx, controller, methodName, response);
-            } catch (error) {
-                logger.error(`后置处理器 ${processor.name} 执行失败:`, error as Error);
-            }
-        }
-    }
-}
-
-/**
- * 构建调用参数
- */
-async function buildCallParams(ctx: Context, controller: any, methodName: string): Promise<any[]> {
-    const callParams: any[] = [];
-    
-    if (controller.$_MethdosParamInfo) {
-        const paramsInfo = controller.$_MethdosParamInfo.get(methodName);
-        if (paramsInfo && paramsInfo.length > 0) {
-            for (let paramInfo of paramsInfo) {
-                let data: any;
-
-                switch (paramInfo.type) {
-                    case 'Body':
-                        data = ctx.request.body;
-                        break;
-                    case 'Query':
-                        data = ctx.query;
-                        break;
-                    case 'Params':
-                        data = ctx.params;
-                        break;
-                    case 'Headers':
-                        data = ctx.request.headers;
-                        break;
-                    case 'State':
-                        data = ctx.state;
-                        break;
-                    default:
-                        data = undefined;
-                }
-
-                callParams.push(data);
-            }
-        }
-    }
-
-    return callParams;
-}
-
-/**
- * 处理缓存逻辑
- */
-async function handleCache(
-    controller: any,
-    methodName: string,
-    callParams: any[],
-    response: any
-): Promise<void> {
-    if (!controller.$_ControllerCache || !controller.$_ControllerCache.get(methodName)) {
-        return;
-    }
-
-    const { cacheyFn, options } = controller.$_ControllerCache.get(methodName);
-    if (!options || (options.enable !== undefined && !options.enable)) {
-        return;
-    }
-
-    const cacheKey = cacheyFn(...callParams);
-    if (cacheKey) {
-        let ttl = 20;
-        if (options.ttl) {
-            if (typeof options.ttl === 'object') {
-                // 随机TTL
-                ttl = Math.floor(Math.random() * (options.ttl.max - options.ttl.min + 1)) + options.ttl.min;
-            } else {
-                ttl = options.ttl;
-            }
-        }
-        
-        controllerResultCacheStore.set(cacheKey, response, ttl);
-    }
-}

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

@@ -1,172 +0,0 @@
-import { EntityManager, DataSource } from 'typeorm';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 事务管理器
- * 提供企业级事务管理功能
- */
-export class TransactionManager {
-    private static instance: TransactionManager;
-    private dataSource: DataSource | null = null;
-
-    private constructor() {}
-
-    static getInstance(): TransactionManager {
-        if (!TransactionManager.instance) {
-            TransactionManager.instance = new TransactionManager();
-        }
-        return TransactionManager.instance;
-    }
-
-    /**
-     * 设置数据源
-     */
-    setDataSource(dataSource: DataSource): void {
-        this.dataSource = dataSource;
-    }
-
-    /**
-     * 执行事务
-     * @param operation 事务操作函数
-     * @param isolationLevel 隔离级别
-     */
-    async executeInTransaction<T>(
-        operation: (manager: EntityManager) => Promise<T>,
-        isolationLevel?: 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE'
-    ): Promise<T> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-
-        try {
-            // 设置隔离级别
-            if (isolationLevel) {
-                await queryRunner.query(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`);
-            }
-
-            const result = await operation(queryRunner.manager);
-            await queryRunner.commitTransaction();
-            
-            logger.info('事务执行成功');
-            return result;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            logger.error('事务执行失败，已回滚:', error as Error);
-            throw error;
-        } finally {
-            await queryRunner.release();
-        }
-    }
-
-    /**
-     * 执行只读事务
-     * @param operation 只读操作函数
-     */
-    async executeInReadOnlyTransaction<T>(
-        operation: (manager: EntityManager) => Promise<T>
-    ): Promise<T> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction('READ COMMITTED');
-
-        try {
-            // 设置为只读事务
-            await queryRunner.query('SET TRANSACTION READ ONLY');
-            
-            const result = await operation(queryRunner.manager);
-            await queryRunner.commitTransaction();
-            
-            logger.debug('只读事务执行成功');
-            return result;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            logger.error('只读事务执行失败:', error as Error);
-            throw error;
-        } finally {
-            await queryRunner.release();
-        }
-    }
-
-    /**
-     * 批量操作事务
-     * @param operations 批量操作数组
-     */
-    async executeBatchTransaction<T>(
-        operations: Array<(manager: EntityManager) => Promise<T>>
-    ): Promise<T[]> {
-        return await this.executeInTransaction(async (manager) => {
-            const results: T[] = [];
-            for (const operation of operations) {
-                const result = await operation(manager);
-                results.push(result);
-            }
-            return results;
-        });
-    }
-
-    /**
-     * 嵌套事务支持
-     * @param operation 嵌套事务操作函数
-     */
-    async executeNestedTransaction<T>(
-        operation: (manager: EntityManager) => Promise<T>
-    ): Promise<T> {
-        if (!this.dataSource) {
-            throw new Error('数据源未初始化');
-        }
-
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        
-        // 检查是否已经在事务中
-        const isInTransaction = queryRunner.isTransactionActive;
-        
-        let shouldRelease = false;
-        
-        try {
-            if (!isInTransaction) {
-                // 开始新事务
-                await queryRunner.startTransaction();
-                shouldRelease = true;
-            }
-            
-            const result = await operation(queryRunner.manager);
-            
-            if (shouldRelease) {
-                await queryRunner.commitTransaction();
-            }
-            
-            return result;
-        } catch (error) {
-            if (shouldRelease) {
-                await queryRunner.rollbackTransaction();
-            }
-            logger.error('嵌套事务执行失败:', error as Error);
-            throw error;
-        } finally {
-            if (shouldRelease) {
-                await queryRunner.release();
-            }
-        }
-    }
-
-    /**
-     * 清理资源
-     * 在应用关闭时调用
-     */
-    cleanup(): void {
-        this.dataSource = null;
-        logger.info('事务管理器资源已清理');
-    }
-}
-
-// 导出单例实例
-export const transactionManager = TransactionManager.getInstance();