create-dp-koa 1.0.0

package/template/src/controllers/example/EnterpriseExampleController.ts

@@ -0,0 +1,297 @@
+/**
+ * 企业级注解系统示例控制器
+ * 展示所有企业级注解的使用方法
+ */
+
+import { Get, Post, Body, Query, State } from '@src/framework/decorator/controller';
+import { Logging, Permission, RateLimit } from '@src/framework/decorator/processor/AnnotationDecorators';
+import { 
+    EnterprisePerformance, 
+    SecurityAudit, 
+    DistributedTracing, 
+    ConfigManagement 
+} from '@src/annotations';
+import { BaseController } from '@src/controllers/base.controller';
+
+/**
+ * 企业级示例控制器
+ * 展示企业级注解系统的完整功能
+ */
+export class EnterpriseExampleController extends BaseController {
+
+    /**
+     * 示例1: 基础企业级注解组合
+     * - @EnterprisePerformance: 企业级性能监控
+     * - @SecurityAudit: 安全审计
+     * - @DistributedTracing: 分布式追踪
+     * - @ConfigManagement: 配置管理
+     */
+    @Get('/enterprise/basic')
+    @EnterprisePerformance({
+        maxExecutionTime: 1000,
+        maxMemoryUsage: 50,
+        enableMetrics: true,
+        enableAlerts: true,
+        alertThresholds: {
+            executionTime: 500,
+            memoryUsage: 30
+        }
+    })
+    @SecurityAudit({
+        enableAudit: true,
+        logLevel: 'info',
+        includeRequestData: true,
+        complianceMode: 'GDPR',
+        sensitiveFields: ['email', 'phone']
+    })
+    @DistributedTracing({
+        enableTracing: true,
+        samplingRate: 1.0,
+        customTags: {
+            'service.version': '1.0.0',
+            'deployment.environment': 'production'
+        }
+    })
+    @ConfigManagement({
+        configKey: 'api.timeout',
+        defaultValue: 30000,
+        required: true,
+        validationRules: [
+            { type: 'number', min: 1000, max: 300000 }
+        ]
+    })
+    @Logging()
+    async getBasicEnterpriseData(@Query() query: any, ctx?: any) {
+        // 模拟一些业务逻辑
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        return {
+            code: 0,
+            data: {
+                message: '企业级基础数据',
+                query,
+                timestamp: new Date().toISOString(),
+                config: ctx?.state.config
+            }
+        };
+    }
+
+    /**
+     * 示例2: 高安全级别操作
+     * - 严格的权限控制
+     * - 详细的安全审计
+     * - 性能监控和告警
+     */
+    @Post('/enterprise/secure-operation')
+    @EnterprisePerformance({
+        maxExecutionTime: 2000,
+        enableAlerts: true,
+        alertThresholds: {
+            executionTime: 1000,
+            memoryUsage: 100
+        }
+    })
+    @SecurityAudit({
+        enableAudit: true,
+        logLevel: 'warn',
+        includeRequestData: true,
+        includeResponseData: true,
+        complianceMode: 'SOX',
+        sensitiveFields: ['amount', 'account', 'transaction']
+    })
+    @DistributedTracing({
+        enableTracing: true,
+        samplingRate: 1.0,
+        customTags: {
+            'operation.type': 'financial',
+            'security.level': 'high'
+        }
+    })
+    @Permission({ requiredPermission: 'financial:write' })
+    @RateLimit({ maxRequests: 5, windowMs: 60000 })
+    @Logging()
+    async performSecureOperation(@Body() data: any, @State() state: any) {
+        // 模拟高安全级别操作
+        const startTime = Date.now();
+        
+        // 模拟复杂业务逻辑
+        let result = 0;
+        for (let i = 0; i < 1000000; i++) {
+            result += Math.sqrt(i);
+        }
+        
+        const executionTime = Date.now() - startTime;
+        
+        return {
+            code: 0,
+            data: {
+                message: '安全操作完成',
+                result: result,
+                executionTime: `${executionTime}ms`,
+                user: state.user,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    /**
+     * 示例3: 配置驱动的操作
+     * - 动态配置管理
+     * - 环境相关配置
+     * - 配置验证
+     */
+    @Get('/enterprise/config-driven')
+    @ConfigManagement({
+        configKey: 'feature.flags',
+        defaultValue: { newFeature: false, betaFeature: false },
+        validationRules: [
+            { type: 'object' },
+            { 
+                type: 'object',
+                custom: (value) => typeof value.newFeature === 'boolean'
+            }
+        ]
+    })
+    @ConfigManagement({
+        configKey: 'api.rate.limit',
+        defaultValue: 100,
+        validationRules: [
+            { type: 'number', min: 1, max: 10000 }
+        ]
+    })
+    @EnterprisePerformance({
+        enableMetrics: true
+    })
+    @SecurityAudit({
+        enableAudit: true,
+        logLevel: 'info'
+    })
+    @Logging()
+    async getConfigDrivenData(@Query() query: any, ctx?: any) {
+        const config = ctx?.state.config || {};
+        
+        return {
+            code: 0,
+            data: {
+                message: '配置驱动的数据',
+                query,
+                featureFlags: config['feature.flags'],
+                rateLimit: config['api.rate.limit'],
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    /**
+     * 示例4: 分布式追踪演示
+     * - 跨服务调用追踪
+     * - 自定义标签和日志
+     * - 性能分析
+     */
+    @Get('/enterprise/distributed-demo')
+    @DistributedTracing({
+        enableTracing: true,
+        samplingRate: 1.0,
+        customTags: {
+            'service.name': 'enterprise-example',
+            'operation.category': 'demo',
+            'business.unit': 'engineering'
+        }
+    })
+    @EnterprisePerformance({
+        enableMetrics: true,
+        enableAlerts: true
+    })
+    @SecurityAudit({
+        enableAudit: true,
+        logLevel: 'info'
+    })
+    @Logging()
+    async getDistributedDemoData(@Query() query: any, ctx?: any) {
+        // 模拟跨服务调用
+        const serviceCalls = [
+            this.callUserService(query.userId),
+            this.callProductService(query.productId),
+            this.callOrderService(query.orderId)
+        ];
+        
+        const results = await Promise.all(serviceCalls);
+        
+        return {
+            code: 0,
+            data: {
+                message: '分布式追踪演示',
+                query,
+                serviceResults: results,
+                traceId: ctx?.state.traceContext?.traceId,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    /**
+     * 示例5: 错误处理和监控
+     * - 错误监控
+     * - 性能告警
+     * - 安全事件记录
+     */
+    @Post('/enterprise/error-demo')
+    @EnterprisePerformance({
+        enableAlerts: true,
+        alertThresholds: {
+            executionTime: 100
+        }
+    })
+    @SecurityAudit({
+        enableAudit: true,
+        logLevel: 'error'
+    })
+    @DistributedTracing({
+        enableTracing: true,
+        customTags: {
+            'operation.type': 'error-demo'
+        }
+    })
+    @Logging()
+    async demonstrateErrorHandling(@Body() data: any) {
+        try {
+            // 模拟可能出错的操作
+            if (data.shouldError) {
+                throw new Error('模拟的业务错误');
+            }
+            
+            // 模拟慢操作
+            if (data.slowOperation) {
+                await new Promise(resolve => setTimeout(resolve, 200));
+            }
+            
+            return {
+                code: 0,
+                data: {
+                    message: '操作成功',
+                    data,
+                    timestamp: new Date().toISOString()
+                }
+            };
+            
+        } catch (error) {
+            // 错误会被注解系统自动记录和追踪
+            throw error;
+        }
+    }
+
+    private async callUserService(userId: string): Promise<any> {
+        await new Promise(resolve => setTimeout(resolve, 50));
+        return { service: 'user', userId, data: 'user data' };
+    }
+
+    private async callProductService(productId: string): Promise<any> {
+        await new Promise(resolve => setTimeout(resolve, 30));
+        return { service: 'product', productId, data: 'product data' };
+    }
+
+    private async callOrderService(orderId: string): Promise<any> {
+        await new Promise(resolve => setTimeout(resolve, 40));
+        return { service: 'order', orderId, data: 'order data' };
+    }
+}

package/template/src/controllers/example/ExampleController.ts

@@ -0,0 +1,110 @@
+import { Get, Query, State } from '@src/framework/decorator/controller';
+import { Logging, Permission, RateLimit } from '@src/framework/decorator/processor/AnnotationDecorators';
+import { PerformanceMonitor } from '@src/annotations/decorators/PerformanceMonitor';
+import { BaseController } from '@src/controllers/base.controller';
+import { Api, ApiTags, ApiResponse, ApiOperation } from '@src/framework/decorator/swagger';
+
+/**
+ * 示例控制器 - 展示新的注解系统用法
+ */
+@ApiTags('示例', 'API文档示例')
+export class ExampleController extends BaseController {
+    
+    /**
+     * 示例1: 使用新的注解系统
+     * - @Logging: 记录请求日志
+     * - @Permission: 检查用户权限
+     * - @RateLimit: 限制请求频率
+     */
+    @Get('/example/secure')
+    @Logging()
+    @Permission({ requiredPermission: 'read:data' })
+    @RateLimit({ maxRequests: 10, windowMs: 60000 })
+    @Api({
+        tags: ['示例', '安全'],
+        summary: '获取受保护的数据',
+        description: '该接口需要权限验证和速率限制，展示如何保护敏感数据',
+    })
+    @ApiResponse({
+        status: 200,
+        description: '成功返回受保护的数据',
+    })
+    @ApiResponse({
+        status: 401,
+        description: '未授权访问',
+    })
+    @ApiResponse({
+        status: 403,
+        description: '权限不足',
+    })
+    async getSecureData(@Query() query: any, @State() state: any) {
+        return {
+            code: 0,
+            data: {
+                message: '这是受保护的数据',
+                user: state.user,
+                query: query
+            }
+        };
+    }
+
+    /**
+     * 示例2: 混合使用新旧注解系统
+     * - @PerformanceMonitor: 监控方法执行时间和内存使用
+     * - @Logging: 记录请求日志
+     */
+    @Get('/example/mixed')
+    @PerformanceMonitor({ maxExecutionTime: 100, maxMemoryUsage: 2 }) // 100ms, 2MB
+    @Logging()
+    @Api({
+        tags: ['示例', '性能监控'],
+        summary: '混合注解示例',
+        description: '展示如何使用性能监控装饰器来监控方法执行时间和内存使用',
+    })
+    @ApiResponse({
+        status: 200,
+        description: '成功返回计算结果',
+    })
+    async getMixedData(@Query() query: any) {
+        // 模拟一些计算操作来展示性能监控
+        let sum = 0;
+        for (let i = 0; i < 1000000; i++) {
+            sum += Math.sqrt(i);
+        }
+        
+        return {
+            code: 0,
+            data: {
+                message: '混合注解示例 - 包含性能监控',
+                query: query,
+                calculationResult: sum,
+                performance: 'monitored'
+            }
+        };
+    }
+
+    /**
+     * 示例3: 只使用新注解系统
+     */
+    @Get('/example/new-only')
+    @Logging()
+    @RateLimit({ maxRequests: 5, windowMs: 30000 })
+    @Api({
+        tags: ['示例', '基础'],
+        summary: '新注解系统示例',
+        description: '展示仅使用新的注解系统实现功能和文档',
+    })
+    @ApiResponse({
+        status: 200,
+        description: '成功返回',
+    })
+    async getNewOnlyData() {
+        return {
+            code: 0,
+            data: {
+                message: '仅使用新注解系统'
+            }
+        };
+    }
+}
+

package/template/src/controllers/example/NewAnnotationExampleController.ts

@@ -0,0 +1,159 @@
+import { Get, Post, Query, Body, State, ResponseCode, ResponseHeader } from '@src/framework/decorator/controller';
+import { BaseController, ControllerResponse } from '@src/controllers/base.controller';
+import { Inject } from 'dp-ioc2';
+import { YtUserService } from '@src/service/ytUser.service';
+import { Logging, Permission, RateLimit } from '@src/framework/decorator/processor/AnnotationDecorators';
+import { ExampleBodyDto, ExampleQueryDto } from '@src/dto/controller/example/NewAnnotationExampleController.dto';
+
+/**
+ * 新注解系统使用示例控制器
+ * 展示如何在实际项目中使用新的注解处理器系统
+ */
+export class NewAnnotationExampleController extends BaseController {
+    @Inject(YtUserService)
+    private ytUserService: YtUserService;
+
+    /**
+     * 示例1：基础的新注解使用
+     * 使用 Logging 注解记录请求日志
+     */
+    @Get('/basic-example')
+    @Logging()
+    @ResponseCode(200)
+    async basicExample(@Query() query: ExampleQueryDto): Promise<ControllerResponse<string>> {
+        console.log('执行基础示例方法');
+        return this.success('基础示例执行成功');
+    }
+
+    /**
+     * 示例2：权限控制
+     * 使用 Permission 注解进行权限检查
+     */
+    @Get('/protected-data')
+    @Logging()
+    @Permission({ requiredPermission: 'read:sensitive-data' })
+    @ResponseCode(200)
+    async getProtectedData(@State('user') user: any): Promise<ControllerResponse<any>> {
+        console.log('获取受保护的数据');
+        return this.success({
+            message: '这是受保护的数据',
+            user: user,
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * 示例3：请求限流
+     * 使用 RateLimit 注解限制请求频率
+     */
+    @Post('/rate-limited-endpoint')
+    @Logging()
+    @RateLimit({ maxRequests: 5, windowMs: 60000 }) // 每分钟最多5次请求
+    @ResponseCode(201)
+    async rateLimitedEndpoint(@Body() body: ExampleBodyDto): Promise<ControllerResponse<any>> {
+        console.log('处理限流端点请求');
+        return this.success({
+            message: '请求处理成功',
+            data: body,
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * 示例4：复合注解使用
+     * 同时使用多个新注解
+     */
+    @Get('/complex-example')
+    @Logging()
+    @Permission({ requiredPermission: 'read:complex-data' })
+    @RateLimit({ maxRequests: 10, windowMs: 300000 }) // 5分钟内最多10次请求
+    @ResponseCode(200)
+    @ResponseHeader('X-Custom-Header', 'ComplexExample')
+    async complexExample(
+        @Query() query: ExampleQueryDto,
+        @State('user') user: any
+    ): Promise<ControllerResponse<any>> {
+        console.log('执行复杂示例方法');
+        
+        // 模拟业务逻辑
+        const usersResult = await this.ytUserService.getUsers({ page: 1, pageSize: 10 });
+        
+        return this.success({
+            message: '复杂示例执行成功',
+            query: query,
+            user: user,
+            usersCount: usersResult.data ? usersResult.data[1] : 0,
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * 示例5：新旧注解混合使用
+     * 展示新旧注解系统的兼容性
+     */
+    @Post('/mixed-annotations')
+    @Logging() // 新注解
+    @ResponseCode(201) // 旧注解
+    @ResponseHeader('X-Mixed-Example', 'true') // 旧注解
+    async mixedAnnotations(@Body() body: ExampleBodyDto): Promise<ControllerResponse<any>> {
+        console.log('执行混合注解示例');
+        return this.success({
+            message: '混合注解示例执行成功',
+            data: body,
+            note: '这个端点同时使用了新旧注解系统'
+        });
+    }
+
+    /**
+     * 示例6：错误处理
+     * 展示注解处理器如何处理错误情况
+     */
+    @Get('/error-example')
+    @Logging()
+    @Permission({ requiredPermission: 'admin:access' })
+    async errorExample(): Promise<ControllerResponse<any>> {
+        console.log('执行错误示例');
+        
+        // 模拟权限不足的情况
+        throw new Error('模拟权限不足错误');
+    }
+
+    /**
+     * 示例7：异步处理
+     * 展示注解处理器如何处理异步方法
+     */
+    @Get('/async-example')
+    @Logging()
+    @RateLimit({ maxRequests: 3, windowMs: 60000 })
+    async asyncExample(): Promise<ControllerResponse<any>> {
+        console.log('开始异步处理');
+        
+        // 模拟异步操作
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        console.log('异步处理完成');
+        return this.success({
+            message: '异步处理完成',
+            timestamp: new Date().toISOString()
+        });
+    }
+
+    /**
+     * 示例8：数据验证
+     * 展示参数验证和响应验证
+     */
+    @Post('/validation-example')
+    @Logging()
+    async validationExample(@Body() body: ExampleBodyDto): Promise<ControllerResponse<any>> {
+        console.log('执行验证示例');
+        
+        // 这里会进行参数验证（通过 @Body 注解）
+        // 响应也会进行验证（通过 ControllerResponse 类型）
+        
+        return this.success({
+            message: '验证通过',
+            receivedData: body,
+            validationTimestamp: new Date().toISOString()
+        });
+    }
+}