create-dp-koa 1.1.2 → 1.1.3

package/template/src/framework/decorator/processor/AnnotationRegistry.ts

@@ -1,117 +0,0 @@
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 注解注册中心
- * 统一管理所有注解的定义、注册和使用
- */
-export class AnnotationRegistry {
-    private static instance: AnnotationRegistry;
-    private processors: Map<string, AnnotationProcessor> = new Map();
-    private processorList: AnnotationProcessor[] = [];
-
-    private constructor() {}
-
-    static getInstance(): AnnotationRegistry {
-        if (!AnnotationRegistry.instance) {
-            AnnotationRegistry.instance = new AnnotationRegistry();
-        }
-        return AnnotationRegistry.instance;
-    }
-
-    /**
-     * 注册注解处理器
-     * @param processor 注解处理器实例
-     */
-    registerProcessor(processor: AnnotationProcessor): void {
-        if (this.processors.has(processor.name)) {
-            logger.warn(`注解处理器 ${processor.name} 已存在，将被覆盖`);
-        }
-        
-        this.processors.set(processor.name, processor);
-        this.processorList.push(processor);
-        
-        // 按优先级排序
-        this.processorList.sort((a, b) => a.priority - b.priority);
-        
-        logger.info(`注解处理器 ${processor.name} 已注册，优先级: ${processor.priority}`);
-    }
-
-    /**
-     * 获取注解处理器
-     * @param name 处理器名称
-     */
-    getProcessor(name: string): AnnotationProcessor | undefined {
-        return this.processors.get(name);
-    }
-
-    /**
-     * 获取所有处理器（按优先级排序）
-     */
-    getAllProcessors(): AnnotationProcessor[] {
-        return [...this.processorList];
-    }
-
-    /**
-     * 移除注解处理器
-     * @param name 处理器名称
-     */
-    unregisterProcessor(name: string): boolean {
-        const processor = this.processors.get(name);
-        if (processor) {
-            this.processors.delete(name);
-            const index = this.processorList.indexOf(processor);
-            if (index > -1) {
-                this.processorList.splice(index, 1);
-            }
-            logger.info(`注解处理器 ${name} 已移除`);
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * 清空所有处理器
-     */
-    clear(): void {
-        this.processors.clear();
-        this.processorList = [];
-        logger.info('所有注解处理器已清空');
-    }
-
-    /**
-     * 清理所有处理器的资源
-     * 在应用关闭时调用
-     */
-    cleanup(): void {
-        this.processorList.forEach(processor => {
-            // 检查处理器是否有 cleanup 方法
-            if (typeof (processor as any).cleanup === 'function') {
-                try {
-                    (processor as any).cleanup();
-                } catch (error) {
-                    logger.error(`清理处理器 ${processor.name} 时发生错误:`, error as Error);
-                }
-            }
-        });
-        logger.info('所有注解处理器资源已清理');
-    }
-
-    /**
-     * 获取注册的处理器列表
-     */
-    getRegisteredProcessors(): string[] {
-        return Array.from(this.processors.keys());
-    }
-
-    /**
-     * 检查处理器是否已注册
-     * @param name 处理器名称
-     */
-    hasProcessor(name: string): boolean {
-        return this.processors.has(name);
-    }
-}
-
-// 导出单例实例
-export const annotationRegistry = AnnotationRegistry.getInstance();

package/template/src/framework/decorator/processor/AnnotationSystemInitializer.ts

@@ -1,95 +0,0 @@
-import { annotationRegistry } from '@src/framework/decorator/processor/AnnotationRegistry';
-import { logger } from '@src/framework/utils/logger';
-import { getAllAnnotationProcessors } from '@src/framework/decorator/processor/AnnotationProcessorConfig';
-
-/**
- * 注解系统初始化器
- * 负责在应用启动时初始化所有注解处理器
- */
-export class AnnotationSystemInitializer {
-    private static initialized = false;
-
-    /**
-     * 初始化注解系统
-     * 注册所有内置和自定义注解处理器
-     */
-    static initialize(): void {
-        if (this.initialized) {
-            logger.warn('注解系统已经初始化，跳过重复初始化');
-            return;
-        }
-
-        try {
-            // 注册内置注解处理器
-            this.registerBuiltinProcessors();
-            
-            // 注册自定义注解处理器
-            this.registerCustomProcessors();
-            
-            this.initialized = true;
-            logger.info('注解系统初始化完成');
-            logger.info(`已注册的注解处理器: ${annotationRegistry.getRegisteredProcessors().join(', ')}`);
-            
-        } catch (error) {
-            logger.error('注解系统初始化失败:', error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 注册内置注解处理器
-     */
-    private static registerBuiltinProcessors(): void {
-        // 动态导入内置处理器，避免循环依赖
-        import('./processors/DefaultProcessors').then(({ 
-            ParameterValidationProcessor,
-            ResponseValidationProcessor,
-            CacheProcessor,
-            ResponseCodeProcessor,
-            ResponseHeaderProcessor
-        }) => {
-            annotationRegistry.registerProcessor(new ParameterValidationProcessor());
-            annotationRegistry.registerProcessor(new ResponseValidationProcessor());
-            annotationRegistry.registerProcessor(new CacheProcessor());
-            annotationRegistry.registerProcessor(new ResponseCodeProcessor());
-            annotationRegistry.registerProcessor(new ResponseHeaderProcessor());
-            
-            logger.info('内置注解处理器注册完成');
-        }).catch(error => {
-            logger.error('内置注解处理器注册失败:', error);
-        });
-    }
-
-    /**
-     * 注册自定义注解处理器
-     */
-    private static registerCustomProcessors(): void {
-        try {
-            // 使用配置文件注册所有注解处理器
-            const allProcessors = getAllAnnotationProcessors();
-            allProcessors.forEach(processor => {
-                annotationRegistry.registerProcessor(processor);
-            });
-            
-            logger.info(`自定义注解处理器注册完成，共注册 ${allProcessors.length} 个处理器`);
-        } catch (error) {
-            logger.error('自定义注解处理器注册失败:', error as Error);
-        }
-    }
-
-    /**
-     * 检查是否已初始化
-     */
-    static isInitialized(): boolean {
-        return this.initialized;
-    }
-
-    /**
-     * 重置初始化状态（主要用于测试）
-     */
-    static reset(): void {
-        this.initialized = false;
-        annotationRegistry.clear();
-        logger.info('注解系统已重置');
-    }
-}

package/template/src/framework/decorator/processor/ProcessorManager.ts

@@ -1,76 +0,0 @@
-import { annotationRegistry } from '@src/framework/decorator/processor/AnnotationRegistry';
-import { 
-    ParameterValidationProcessor,
-    ResponseValidationProcessor,
-    CacheProcessor,
-    ResponseCodeProcessor,
-    ResponseHeaderProcessor
-} from './processors/DefaultProcessors';
-
-/**
- * 注解处理器管理器
- * @deprecated 请使用 AnnotationRegistry 和 AnnotationSystemInitializer
- */
-export class ProcessorManager {
-    private static initialized = false;
-
-    /**
-     * 初始化默认处理器
-     */
-    static initialize(): void {
-        if (this.initialized) {
-            return;
-        }
-
-        // 注册默认处理器
-        this.registerDefaultProcessors();
-        this.initialized = true;
-    }
-
-    /**
-     * 注册默认处理器
-     */
-    private static registerDefaultProcessors(): void {
-        annotationRegistry.registerProcessor(new ParameterValidationProcessor());
-        annotationRegistry.registerProcessor(new ResponseValidationProcessor());
-        annotationRegistry.registerProcessor(new CacheProcessor());
-        annotationRegistry.registerProcessor(new ResponseCodeProcessor());
-        annotationRegistry.registerProcessor(new ResponseHeaderProcessor());
-    }
-
-    /**
-     * 注册自定义处理器
-     */
-    static registerProcessor(processor: any): void {
-        annotationRegistry.registerProcessor(processor);
-    }
-
-    /**
-     * 获取所有处理器
-     */
-    static getAllProcessors() {
-        return annotationRegistry.getAllProcessors();
-    }
-
-    /**
-     * 获取处理器
-     */
-    static getProcessor(name: string) {
-        return annotationRegistry.getProcessor(name);
-    }
-
-    /**
-     * 移除处理器
-     */
-    static removeProcessor(name: string): boolean {
-        return annotationRegistry.unregisterProcessor(name);
-    }
-
-    /**
-     * 清空所有处理器
-     */
-    static clear(): void {
-        annotationRegistry.clear();
-        this.initialized = false;
-    }
-}

package/template/src/framework/decorator/processor/processors/CustomProcessors.ts

@@ -1,126 +0,0 @@
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 日志注解处理器示例
- * 演示如何创建自定义注解处理器
- */
-export class LoggingProcessor implements AnnotationProcessor {
-    readonly name = 'Logging';
-    readonly priority = 10; // 高优先级，在其他处理器之前执行
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        const startTime = Date.now();
-        
-        // 只在调试模式下输出详细日志
-        logger.debug(`[${this.name}] 开始处理请求: ${controller.constructor.name}.${methodName}`);
-        logger.debug(`[${this.name}] 请求参数:`, callParams);
-        logger.debug(`[${this.name}] 注解数据:`, annotationData);
-        
-        // 将开始时间存储到上下文中，供后续使用
-        ctx.state.loggingStartTime = startTime;
-        
-        return true;
-    }
-
-    /**
-     * 记录响应日志
-     */
-    async logResponse(ctx: Context, controller: any, methodName: string, response: any): Promise<void> {
-        const startTime = ctx.state.loggingStartTime;
-        const duration = startTime ? Date.now() - startTime : 0;
-        
-        // 只在调试模式下输出详细日志
-        logger.debug(`[Logging] 完成处理请求: ${controller.constructor.name}.${methodName}`);
-        logger.debug(`[Logging] 响应数据:`, response);
-        logger.debug(`[Logging] 处理耗时: ${duration}ms`);
-    }
-}
-
-/**
- * 权限检查注解处理器示例
- */
-export class PermissionProcessor implements AnnotationProcessor {
-    readonly name = 'Permission';
-    readonly priority = 5; // 最高优先级
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        // 检查用户权限
-        const user = ctx.state.user;
-        if (!user) {
-            ctx.status = 401;
-            ctx.body = { error: '未授权访问' };
-            return false;
-        }
-
-        // 检查特定权限
-        if (annotationData && annotationData.requiredPermission) {
-            if (!user.permissions || !user.permissions.includes(annotationData.requiredPermission)) {
-                ctx.status = 403;
-                ctx.body = { error: '权限不足' };
-                return false;
-            }
-        }
-
-        return true;
-    }
-}
-
-/**
- * 限流注解处理器示例
- */
-export class RateLimitProcessor implements AnnotationProcessor {
-    readonly name = 'RateLimit';
-    readonly priority = 15;
-
-    private static requestCounts: Map<string, { count: number; resetTime: number }> = new Map();
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (!annotationData) {
-            return true;
-        }
-
-        const { maxRequests = 100, windowMs = 60000 } = annotationData;
-        const clientId = ctx.ip || 'unknown';
-        const key = `${clientId}:${controller.constructor.name}:${methodName}`;
-        
-        const now = Date.now();
-        const current = RateLimitProcessor.requestCounts.get(key);
-
-        if (!current || now > current.resetTime) {
-            // 重置计数器
-            RateLimitProcessor.requestCounts.set(key, {
-                count: 1,
-                resetTime: now + windowMs
-            });
-        } else {
-            current.count++;
-            if (current.count > maxRequests) {
-                ctx.status = 429;
-                ctx.body = { error: '请求过于频繁，请稍后再试' };
-                return false;
-            }
-        }
-
-        return true;
-    }
-}

package/template/src/framework/decorator/processor/processors/DefaultProcessors.ts

@@ -1,207 +0,0 @@
-import { Context } from 'koa';
-import { AnnotationProcessor } from '@src/framework/decorator/processor/AnnotationProcessor';
-import { validate } from 'class-validator';
-import { isPromise } from '@src/framework/utils/function';
-
-/**
- * 参数验证处理器
- */
-export class ParameterValidationProcessor implements AnnotationProcessor {
-    readonly name = 'ParameterValidation';
-    readonly priority = 100;
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (!controller.$_MethdosParamInfo) {
-            return true;
-        }
-
-        const paramsInfo = controller.$_MethdosParamInfo.get(methodName);
-        if (!paramsInfo || paramsInfo.length === 0) {
-            return true;
-        }
-
-        for (let i = 0; i < paramsInfo.length; i++) {
-            const paramInfo = paramsInfo[i];
-            const data = callParams[i];
-
-            if (paramInfo.validate && typeof paramInfo.validate === 'function' && data) {
-                const waitToValidateObject = new paramInfo.validate();
-
-                // 处理数据转换
-                for (let key in data) {
-                    if (waitToValidateObject.$_Transform && waitToValidateObject.$_Transform.get(key)) {
-                        const func = waitToValidateObject.$_Transform.get(key);
-                        const result = func(data[key]);
-                        if (isPromise(result)) {
-                            waitToValidateObject[key] = await result;
-                        } else {
-                            waitToValidateObject[key] = result;
-                        }
-                    } else {
-                        waitToValidateObject[key] = data[key];
-                    }
-                }
-
-                const validateErrors = await validate(waitToValidateObject);
-                if (validateErrors.length > 0) {
-                    ctx.status = 400;
-                    ctx.body = validateErrors;
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-}
-
-/**
- * 响应验证处理器
- */
-export class ResponseValidationProcessor implements AnnotationProcessor {
-    readonly name = 'ResponseValidation';
-    readonly priority = 200;
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        // 这个方法会在响应处理时被调用
-        // 这里先返回true，具体的响应验证逻辑会在响应处理阶段实现
-        return true;
-    }
-
-    /**
-     * 验证响应数据
-     */
-    async validateResponse(
-        controller: any,
-        methodName: string,
-        response: any
-    ): Promise<any[]> {
-        if (controller.$_ResponseValidateIf && controller.$_ResponseValidateIf.get(methodName)) {
-            const { fn, clas } = controller.$_ResponseValidateIf.get(methodName);
-            let callResult = fn(response);
-            if (isPromise(callResult)) {
-                callResult = await callResult;
-            }
-            if (callResult && (callResult instanceof Object)) {
-                const dto = new clas();
-                Object.assign(dto, callResult);
-                return await validate(dto, {
-                    skipMissingProperties: false,
-                    forbidNonWhitelisted: true,
-                    whitelist: true,
-                });
-            }
-        } else if (controller.$_ResponseValidator && controller.$_ResponseValidator.get(methodName)) {
-            const { clas, objectKey } = controller.$_ResponseValidator.get(methodName);
-            if (response instanceof Object) {
-                const dto = new clas();
-                let dataObject = response;
-                if (objectKey && response[objectKey] && (response[objectKey] instanceof Object)) {
-                    dataObject = response[objectKey];
-                }
-                Object.assign(dto, dataObject);
-                return await validate(dto, {
-                    skipMissingProperties: false,
-                    forbidNonWhitelisted: true,
-                    whitelist: true,
-                });
-            }
-        }
-        return [];
-    }
-}
-
-/**
- * 缓存处理器
- */
-export class CacheProcessor implements AnnotationProcessor {
-    readonly name = 'Cache';
-    readonly priority = 50;
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (!controller.$_ControllerCache || !controller.$_ControllerCache.get(methodName)) {
-            return true;
-        }
-
-        const { cacheyFn, options } = controller.$_ControllerCache.get(methodName);
-        if (!options || (options.enable !== undefined && !options.enable)) {
-            return true;
-        }
-
-        const cacheKey = cacheyFn(...callParams);
-        if (cacheKey) {
-            // 这里需要访问缓存存储，暂时跳过缓存逻辑
-            // 实际的缓存逻辑会在响应处理时实现
-        }
-
-        return true;
-    }
-}
-
-/**
- * 响应码处理器
- */
-export class ResponseCodeProcessor implements AnnotationProcessor {
-    readonly name = 'ResponseCode';
-    readonly priority = 300;
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (controller.$_ResponseCode) {
-            const code = controller.$_ResponseCode.get(methodName) ?? 200;
-            ctx.status = code;
-        }
-        return true;
-    }
-}
-
-/**
- * 响应头处理器
- */
-export class ResponseHeaderProcessor implements AnnotationProcessor {
-    readonly name = 'ResponseHeader';
-    readonly priority = 400;
-
-    async process(
-        ctx: Context,
-        controller: any,
-        methodName: string,
-        annotationData: any,
-        callParams: any[]
-    ): Promise<boolean> {
-        if (controller.$_ResponseHeader) {
-            const responseHeaders = controller.$_ResponseHeader.get(methodName);
-            if (responseHeaders) {
-                responseHeaders.forEach((value: any, key: string) => {
-                    if (value) {
-                        ctx.set(key, value);
-                    }
-                });
-            }
-        }
-        return true;
-    }
-}