create-dp-koa 1.0.0

package/template/src/framework/decorator/refactored/DecoratorFactory.ts

@@ -0,0 +1,99 @@
+/**
+ * 装饰器系统重构方案
+ * 统一装饰器接口和实现
+ */
+
+// 1. 基础装饰器接口
+export interface BaseDecorator {
+    readonly name: string;
+    readonly type: 'method' | 'parameter' | 'class';
+}
+
+// 2. HTTP方法装饰器接口
+export interface HttpMethodDecorator extends BaseDecorator {
+    readonly type: 'method';
+    readonly httpMethod: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'ALL';
+}
+
+// 3. 参数装饰器接口
+export interface ParameterDecorator extends BaseDecorator {
+    readonly type: 'parameter';
+    readonly parameterType: 'Body' | 'Query' | 'Params' | 'Headers' | 'State';
+}
+
+// 4. 统一的装饰器工厂
+export class DecoratorFactory {
+    /**
+     * 创建HTTP方法装饰器
+     */
+    static createHttpMethodDecorator(
+        httpMethod: HttpMethodDecorator['httpMethod'],
+        url?: string
+    ): MethodDecorator {
+        return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+            const methodName = String(propertyKey);
+            const metadataKey = `$_${httpMethod}Methods`;
+            
+            if (!target[metadataKey]) {
+                target[metadataKey] = new Set();
+            }
+            
+            target[metadataKey].add({
+                methodName,
+                url: url ?? methodName
+            });
+            
+            return descriptor;
+        };
+    }
+
+    /**
+     * 创建参数装饰器
+     */
+    static createParameterDecorator(
+        parameterType: ParameterDecorator['parameterType'],
+        validate?: any
+    ): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void {
+        return (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => {
+            const methodName = String(propertyKey);
+            const metadataKey = '$_MethodsParamInfo';
+            
+            if (!target[metadataKey]) {
+                target[metadataKey] = new Map<string, ParameterInfo[]>();
+            }
+            
+            let paramsInfo = target[metadataKey].get(methodName) ?? [];
+            paramsInfo[parameterIndex] = {
+                type: parameterType,
+                validate
+            };
+            
+            target[metadataKey].set(methodName, paramsInfo);
+        };
+    }
+}
+
+// 5. 类型定义
+export interface ParameterInfo {
+    type: ParameterDecorator['parameterType'];
+    validate?: any;
+}
+
+export interface MethodInfo {
+    methodName: string;
+    url: string;
+}
+
+// 6. 统一的装饰器导出
+export const Get = (url?: string) => DecoratorFactory.createHttpMethodDecorator('GET', url);
+export const Post = (url?: string) => DecoratorFactory.createHttpMethodDecorator('POST', url);
+export const Put = (url?: string) => DecoratorFactory.createHttpMethodDecorator('PUT', url);
+export const Delete = (url?: string) => DecoratorFactory.createHttpMethodDecorator('DELETE', url);
+export const Patch = (url?: string) => DecoratorFactory.createHttpMethodDecorator('PATCH', url);
+export const All = (url?: string) => DecoratorFactory.createHttpMethodDecorator('ALL', url);
+
+export const Body = (validate?: any) => DecoratorFactory.createParameterDecorator('Body', validate);
+export const Query = (validate?: any) => DecoratorFactory.createParameterDecorator('Query', validate);
+export const Params = (validate?: any) => DecoratorFactory.createParameterDecorator('Params', validate);
+export const Headers = (validate?: any) => DecoratorFactory.createParameterDecorator('Headers', validate);
+export const State = (validate?: any) => DecoratorFactory.createParameterDecorator('State', validate);

package/template/src/framework/decorator/refactored/DecoratorMetadataManager.ts

@@ -0,0 +1,125 @@
+/**
+ * 装饰器元数据管理器
+ * 统一管理所有装饰器的元数据
+ */
+
+export class DecoratorMetadataManager {
+    private static readonly METADATA_KEYS = {
+        HTTP_METHODS: '$_HttpMethods',
+        PARAMETERS: '$_Parameters',
+        RESPONSE_CODE: '$_ResponseCode',
+        RESPONSE_HEADER: '$_ResponseHeader',
+        RESPONSE_VALIDATOR: '$_ResponseValidator',
+        CONTROLLER_CACHE: '$_ControllerCache',
+        TRANSFORM: '$_Transform',
+        ANNOTATIONS: '$_Annotations'
+    } as const;
+
+    /**
+     * 获取HTTP方法元数据
+     */
+    static getHttpMethods(target: any): Map<string, MethodInfo[]> {
+        return target[this.METADATA_KEYS.HTTP_METHODS] || new Map();
+    }
+
+    /**
+     * 设置HTTP方法元数据
+     */
+    static setHttpMethod(
+        target: any,
+        methodName: string,
+        httpMethod: string,
+        url: string
+    ): void {
+        if (!target[this.METADATA_KEYS.HTTP_METHODS]) {
+            target[this.METADATA_KEYS.HTTP_METHODS] = new Map();
+        }
+
+        const methods = target[this.METADATA_KEYS.HTTP_METHODS];
+        if (!methods.has(methodName)) {
+            methods.set(methodName, []);
+        }
+
+        methods.get(methodName).push({ httpMethod, url });
+    }
+
+    /**
+     * 获取参数元数据
+     */
+    static getParameters(target: any, methodName: string): ParameterInfo[] {
+        const params = target[this.METADATA_KEYS.PARAMETERS];
+        return params?.get(methodName) || [];
+    }
+
+    /**
+     * 设置参数元数据
+     */
+    static setParameter(
+        target: any,
+        methodName: string,
+        index: number,
+        parameterInfo: ParameterInfo
+    ): void {
+        if (!target[this.METADATA_KEYS.PARAMETERS]) {
+            target[this.METADATA_KEYS.PARAMETERS] = new Map();
+        }
+
+        const params = target[this.METADATA_KEYS.PARAMETERS];
+        if (!params.has(methodName)) {
+            params.set(methodName, []);
+        }
+
+        const methodParams = params.get(methodName);
+        methodParams[index] = parameterInfo;
+    }
+
+    /**
+     * 获取注解元数据
+     */
+    static getAnnotations(target: any, methodName: string): Map<string, any> {
+        const annotations = target[this.METADATA_KEYS.ANNOTATIONS];
+        return annotations?.get(methodName) || new Map();
+    }
+
+    /**
+     * 设置注解元数据
+     */
+    static setAnnotation(
+        target: any,
+        methodName: string,
+        processorName: string,
+        data: any
+    ): void {
+        if (!target[this.METADATA_KEYS.ANNOTATIONS]) {
+            target[this.METADATA_KEYS.ANNOTATIONS] = new Map();
+        }
+
+        const annotations = target[this.METADATA_KEYS.ANNOTATIONS];
+        if (!annotations.has(methodName)) {
+            annotations.set(methodName, new Map());
+        }
+
+        annotations.get(methodName).set(processorName, data);
+    }
+
+    /**
+     * 清理元数据
+     */
+    static clear(target: any): void {
+        Object.values(this.METADATA_KEYS).forEach(key => {
+            delete target[key];
+        });
+    }
+}
+
+export interface MethodInfo {
+    httpMethod: string;
+    url: string;
+}
+
+export interface ParameterInfo {
+    type: 'Body' | 'Query' | 'Params' | 'Headers' | 'State';
+    validate?: any;
+    required?: boolean;
+    defaultValue?: any;
+}

package/template/src/framework/decorator/refactored/DecoratorValidator.ts

@@ -0,0 +1,128 @@
+/**
+ * 装饰器验证系统
+ * 提供装饰器配置的验证和错误检查
+ */
+
+import { DecoratorMetadataManager } from '@src/framework/decorator/refactored/DecoratorMetadataManager';
+
+export class DecoratorValidator {
+    /**
+     * 验证控制器装饰器配置
+     */
+    static validateController(target: any): ValidationResult {
+        const errors: string[] = [];
+        const warnings: string[] = [];
+
+        // 检查HTTP方法装饰器
+        const httpMethods = DecoratorMetadataManager.getHttpMethods(target);
+        if (httpMethods.size === 0) {
+            warnings.push('控制器没有定义任何HTTP方法');
+        }
+
+        // 检查重复的URL
+        const urlMap = new Map<string, string[]>();
+        httpMethods.forEach((methods, methodName) => {
+            methods.forEach(method => {
+                const key = `${method.httpMethod}:${method.url}`;
+                if (!urlMap.has(key)) {
+                    urlMap.set(key, []);
+                }
+                urlMap.get(key)!.push(methodName);
+            });
+        });
+
+        urlMap.forEach((methods, url) => {
+            if (methods.length > 1) {
+                errors.push(`URL冲突: ${url} 被多个方法使用: ${methods.join(', ')}`);
+            }
+        });
+
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+
+    /**
+     * 验证方法装饰器配置
+     */
+    static validateMethod(target: any, methodName: string): ValidationResult {
+        const errors: string[] = [];
+        const warnings: string[] = [];
+
+        // 检查参数装饰器
+        const parameters = DecoratorMetadataManager.getParameters(target, methodName);
+        const gaps = parameters.findIndex((param, index) => param === undefined);
+        if (gaps !== -1) {
+            errors.push(`方法 ${methodName} 的参数装饰器存在间隙，索引 ${gaps} 未定义`);
+        }
+
+        // 检查注解装饰器
+        const annotations = DecoratorMetadataManager.getAnnotations(target, methodName);
+        if (annotations.size === 0) {
+            warnings.push(`方法 ${methodName} 没有使用任何注解装饰器`);
+        }
+
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+
+    /**
+     * 验证整个控制器类
+     */
+    static validateClass(target: any): ValidationResult {
+        const errors: string[] = [];
+        const warnings: string[] = [];
+
+        // 验证控制器级别
+        const controllerResult = this.validateController(target);
+        errors.push(...controllerResult.errors);
+        warnings.push(...controllerResult.warnings);
+
+        // 验证所有方法
+        const methods = Object.getOwnPropertyNames(target.prototype)
+            .filter(name => name !== 'constructor' && typeof target.prototype[name] === 'function');
+
+        methods.forEach(methodName => {
+            const methodResult = this.validateMethod(target, methodName);
+            errors.push(...methodResult.errors);
+            warnings.push(...methodResult.warnings);
+        });
+
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+}
+
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/**
+ * 装饰器验证装饰器
+ * 在类加载时自动验证装饰器配置
+ */
+export function ValidateDecorators(): ClassDecorator {
+    return (target: any) => {
+        const result = DecoratorValidator.validateClass(target);
+        
+        if (!result.isValid) {
+            console.error(`装饰器验证失败 - ${target.name}:`, result.errors);
+        }
+        
+        if (result.warnings.length > 0) {
+            console.warn(`装饰器验证警告 - ${target.name}:`, result.warnings);
+        }
+        
+        return target;
+    };
+}

package/template/src/framework/decorator/refactored/TypeSafeDecorators.ts

@@ -0,0 +1,139 @@
+/**
+ * 类型安全的装饰器系统
+ * 提供完整的类型支持和智能提示
+ */
+
+import { DecoratorMetadataManager, ParameterInfo } from '@src/framework/decorator/refactored/DecoratorMetadataManager';
+
+// 1. 类型定义
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'ALL';
+export type ParameterType = 'Body' | 'Query' | 'Params' | 'Headers' | 'State';
+
+// 2. 装饰器配置接口
+export interface HttpMethodConfig {
+    url?: string;
+    middleware?: any[];
+}
+
+export interface ParameterConfig {
+    validate?: any;
+    required?: boolean;
+    defaultValue?: any;
+}
+
+// 3. 类型安全的HTTP方法装饰器
+export function createHttpMethodDecorator<T extends HttpMethod>(
+    method: T,
+    config?: HttpMethodConfig
+): MethodDecorator {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+        const methodName = String(propertyKey);
+        // HTTP方法装饰器的 target 是类的构造函数
+        const metadataKey = `$_${method}Methods`;
+        
+        if (!target[metadataKey]) {
+            target[metadataKey] = new Set();
+        }
+        
+        target[metadataKey].add({
+            methodName,
+            url: config?.url ?? methodName
+        });
+        
+        console.log(`装饰器执行: ${method} ${methodName} -> ${config?.url ?? methodName}`);
+        
+        return descriptor;
+    };
+}
+
+// 4. 类型安全的参数装饰器
+export function createParameterDecorator<T extends ParameterType>(
+    type: T,
+    config?: ParameterConfig
+): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => void {
+    return (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => {
+        const methodName = String(propertyKey);
+        // 参数装饰器的 target 是类的构造函数
+        const metadataKey = '$_MethodsParamInfo';
+        
+        if (!target[metadataKey]) {
+            target[metadataKey] = new Map<string, ParameterInfo[]>();
+        }
+        
+        let paramsInfo = target[metadataKey].get(methodName) ?? [];
+        paramsInfo[parameterIndex] = {
+            type,
+            validate: config?.validate,
+            required: config?.required ?? true,
+            defaultValue: config?.defaultValue
+        };
+        
+        target[metadataKey].set(methodName, paramsInfo);
+        
+        console.log(`参数装饰器执行: ${type} ${methodName}[${parameterIndex}]`);
+    };
+}
+
+// 5. 导出的装饰器（类型安全）
+export const Get = (config?: HttpMethodConfig) => createHttpMethodDecorator('GET', config);
+export const Post = (config?: HttpMethodConfig) => createHttpMethodDecorator('POST', config);
+export const Put = (config?: HttpMethodConfig) => createHttpMethodDecorator('PUT', config);
+export const Delete = (config?: HttpMethodConfig) => createHttpMethodDecorator('DELETE', config);
+export const Patch = (config?: HttpMethodConfig) => createHttpMethodDecorator('PATCH', config);
+export const All = (config?: HttpMethodConfig) => createHttpMethodDecorator('ALL', config);
+
+export const Body = (config?: ParameterConfig) => createParameterDecorator('Body', config);
+export const Query = (config?: ParameterConfig) => createParameterDecorator('Query', config);
+export const Params = (config?: ParameterConfig) => createParameterDecorator('Params', config);
+export const Headers = (config?: ParameterConfig) => createParameterDecorator('Headers', config);
+export const State = (config?: ParameterConfig) => createParameterDecorator('State', config);
+
+// 6. 高级装饰器
+export function ResponseCode(code: number = 200): MethodDecorator {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+        const methodName = String(propertyKey);
+        if (!target.$_ResponseCode) {
+            target.$_ResponseCode = new Map<string, number>();
+        }
+        target.$_ResponseCode.set(methodName, code);
+        return descriptor;
+    };
+}
+
+export function ResponseHeader(type: string, value: any): MethodDecorator {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+        const methodName = String(propertyKey);
+        if (!target.$_ResponseHeader) {
+            target.$_ResponseHeader = new Map<string, Map<string, any>>();
+        }
+        
+        let headerMap = target.$_ResponseHeader.get(methodName);
+        if (!headerMap) {
+            headerMap = new Map<string, any>();
+        }
+        headerMap.set(type, value);
+        target.$_ResponseHeader.set(methodName, headerMap);
+        
+        return descriptor;
+    };
+}
+
+export function ControllerCache(
+    cacheKeyFn: (...params: any[]) => string,
+    options: {
+        ttl: number | { max: number; min: number };
+        enable?: boolean;
+    } = { ttl: 20, enable: true }
+): MethodDecorator {
+    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+        const methodName = String(propertyKey);
+        if (!target.$_ControllerCache) {
+            target.$_ControllerCache = new Map<string, any>();
+        }
+        target.$_ControllerCache.set(methodName, {
+            cacheKeyFn,
+            options
+        });
+        return descriptor;
+    };
+}

package/template/src/framework/decorator/refactored/index.ts

@@ -0,0 +1,98 @@
+/**
+ * 统一的装饰器导出文件
+ * 重构后的装饰器系统入口
+ */
+
+// 1. 核心装饰器
+export {
+    Get,
+    Post,
+    Put,
+    Delete,
+    Patch,
+    All,
+    Body,
+    Query,
+    Params,
+    Headers,
+    State,
+    ResponseCode,
+    ResponseHeader,
+    ControllerCache
+} from './TypeSafeDecorators';
+
+// 2. 元数据管理
+export { DecoratorMetadataManager } from './DecoratorMetadataManager';
+
+// 3. 验证系统
+export { DecoratorValidator, ValidateDecorators } from './DecoratorValidator';
+
+// 4. 类型定义
+export type {
+    HttpMethod,
+    ParameterType,
+    HttpMethodConfig,
+    ParameterConfig
+} from './TypeSafeDecorators';
+
+export type {
+    MethodInfo,
+    ParameterInfo
+} from './DecoratorMetadataManager';
+
+export type {
+    ValidationResult
+} from './DecoratorValidator';
+
+// 5. 兼容性导出（保持向后兼容）
+export {
+    // 保持原有的导出名称
+    Get as GetDecorator,
+    Post as PostDecorator,
+    Put as PutDecorator,
+    Delete as DeleteDecorator,
+    Body as BodyDecorator,
+    Query as QueryDecorator,
+    Params as ParamsDecorator,
+    Headers as HeadersDecorator,
+    State as StateDecorator
+} from './TypeSafeDecorators';
+
+// 6. 工具函数
+import { DecoratorMetadataManager } from '@src/framework/decorator/refactored/DecoratorMetadataManager';
+import { DecoratorValidator } from '@src/framework/decorator/refactored/DecoratorValidator';
+
+export const DecoratorUtils = {
+    /**
+     * 获取控制器的所有HTTP方法
+     */
+    getHttpMethods: (target: any) => DecoratorMetadataManager.getHttpMethods(target),
+    
+    /**
+     * 获取方法的参数信息
+     */
+    getMethodParameters: (target: any, methodName: string) => 
+        DecoratorMetadataManager.getParameters(target, methodName),
+    
+    /**
+     * 获取方法的注解信息
+     */
+    getMethodAnnotations: (target: any, methodName: string) => 
+        DecoratorMetadataManager.getAnnotations(target, methodName),
+    
+    /**
+     * 验证控制器装饰器配置
+     */
+    validateController: (target: any) => DecoratorValidator.validateController(target),
+    
+    /**
+     * 验证方法装饰器配置
+     */
+    validateMethod: (target: any, methodName: string) => 
+        DecoratorValidator.validateMethod(target, methodName),
+    
+    /**
+     * 清理装饰器元数据
+     */
+    clearMetadata: (target: any) => DecoratorMetadataManager.clear(target)
+};