create-dp-koa 1.0.1 → 1.0.2

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

@@ -1,159 +0,0 @@
-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()
-        });
-    }
-}

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

@@ -1,205 +0,0 @@
-import { Get, Post, Put, Del, Body, Query, Params } from '@src/framework/decorator/controller';
-import { BaseController } from '@src/controllers/base.controller';
-import { Api, ApiTags, ApiResponse, ApiBody, ApiParam } from '@src/framework/decorator/swagger';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * Swagger示例控制器 - 展示完整的Swagger注解用法
- */
-@ApiTags('Swagger示例', 'API文档完整示例')
-export class SwaggerExampleController extends BaseController {
-    
-    /**
-     * GET请求 - 带查询参数
-     */
-    @Get('/user/list')
-    @Api({
-        tags: ['用户管理'],
-        summary: '获取用户列表',
-        description: '根据查询参数获取用户列表',
-        operationId: 'getUserList',
-    })
-    @ApiResponse({
-        status: 200,
-        description: '成功返回用户列表',
-        schema: {
-            type: 'object',
-            properties: {
-                code: { type: 'number', example: 0 },
-                data: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'number' },
-                            name: { type: 'string' },
-                            email: { type: 'string' },
-                        },
-                    },
-                },
-                message: { type: 'string' },
-            },
-        },
-    })
-    async getUserList(@Query() query: { page: number; pageSize: number; keyword?: string }) {
-        return this.success({
-            users: [
-                { id: 1, name: '张三', email: 'zhang@example.com' },
-                { id: 2, name: '李四', email: 'li@example.com' },
-            ],
-            total: 2,
-            page: query.page || 1,
-            pageSize: query.pageSize || 10,
-        }, '获取用户列表成功');
-    }
-    
-    /**
-     * GET请求 - 带路径参数
-     */
-    @Get('/user/:id')
-    @Api({
-        tags: ['用户管理'],
-        summary: '获取用户详情',
-        description: '根据用户ID获取用户详细信息',
-    })
-    @ApiResponse({
-        status: 200,
-        description: '成功返回用户详情',
-    })
-    @ApiResponse({
-        status: 404,
-        description: '用户不存在',
-    })
-    async getUserById(@Params() params: { id: number }) {
-        return this.success({
-            id: params.id,
-            name: '张三',
-            email: 'zhang@example.com',
-            avatar: 'https://example.com/avatar.jpg',
-        }, '获取用户详情成功');
-    }
-    
-    /**
-     * POST请求 - 带请求体
-     */
-    @Post('/user')
-    @Api({
-        tags: ['用户管理'],
-        summary: '创建新用户',
-        description: '创建新用户并返回用户信息',
-    })
-    @ApiBody({
-        description: '用户信息',
-        required: true,
-        schema: {
-            type: 'object',
-            required: ['name', 'email'],
-            properties: {
-                name: { type: 'string', description: '用户名', example: '张三' },
-                email: { type: 'string', format: 'email', description: '邮箱', example: 'zhang@example.com' },
-                age: { type: 'number', description: '年龄', example: 25 },
-            },
-        },
-        examples: {
-            example1: {
-                summary: '示例数据1',
-                value: {
-                    name: '张三',
-                    email: 'zhang@example.com',
-                    age: 25,
-                },
-            },
-        },
-    })
-    @ApiResponse({
-        status: 200,
-        description: '成功创建用户',
-        schema: {
-            type: 'object',
-            properties: {
-                code: { type: 'number' },
-                data: {
-                    type: 'object',
-                    properties: {
-                        id: { type: 'number' },
-                        name: { type: 'string' },
-                        email: { type: 'string' },
-                    },
-                },
-                message: { type: 'string' },
-            },
-        },
-    })
-    @ApiResponse({
-        status: 400,
-        description: '参数验证失败',
-    })
-    async createUser(@Body() body: { name: string; email: string; age?: number }) {
-        return this.success({
-            id: Math.floor(Math.random() * 1000),
-            name: body.name,
-            email: body.email,
-            age: body.age,
-        }, '创建用户成功');
-    }
-    
-    /**
-     * PUT请求 - 更新资源
-     */
-    @Put('/user/:id')
-    @Api({
-        tags: ['用户管理'],
-        summary: '更新用户信息',
-        description: '根据用户ID更新用户信息',
-    })
-    @ApiBody({
-        description: '更新的用户信息',
-        required: true,
-        schema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: '用户名' },
-                email: { type: 'string', format: 'email', description: '邮箱' },
-                age: { type: 'number', description: '年龄' },
-            },
-        },
-    })
-    @ApiResponse({
-        status: 200,
-        description: '成功更新用户信息',
-    })
-    @ApiResponse({
-        status: 404,
-        description: '用户不存在',
-    })
-    async updateUser(@Params() params: { id: number }, @Body() body: { name?: string; email?: string; age?: number }) {
-        return this.success({
-            id: params.id,
-            ...body,
-        }, '更新用户成功');
-    }
-    
-    /**
-     * DELETE请求 - 删除资源
-     */
-    @Del('/user/:id')
-    @Api({
-        tags: ['用户管理'],
-        summary: '删除用户',
-        description: '根据用户ID删除用户',
-    })
-    @ApiResponse({
-        status: 200,
-        description: '成功删除用户',
-    })
-    @ApiResponse({
-        status: 404,
-        description: '用户不存在',
-    })
-    async deleteUser(@Params() params: { id: number }) {
-        logger.debug('🔍 deleteUser 方法被调用');
-        logger.debug('📋 参数:', params);
-        return this.success(null, '删除用户成功');
-    }
-}
-

package/template/src/controllers/example/TransactionExample.controller.ts

@@ -1,336 +0,0 @@
-/**
- * 事务管理器使用示例控制器
- * 演示在实际 API 中如何使用 TransactionManager
- */
-
-import { Post, Get, Put, Del } from '@src/framework/decorator/controller';
-import { Context } from 'koa';
-import { transactionManager } from '@src/framework/utils/TransactionManager';
-import { YtUserEntity } from '@src/entity/ytUser.entity';
-import { logger } from '@src/framework/utils/logger';
-import * as bcrypt from 'bcryptjs';
-
-export class TransactionExampleController {
-
-    /**
-     * 示例 1: 基本事务 - 创建用户
-     * POST /api/example/transaction/create-user
-     */
-    @Post('/create-user')
-    async createUser(ctx: Context) {
-        const { email, telnumber, password } = ctx.request.body;
-
-        try {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                // 检查用户是否已存在
-                const existingUser = await manager.findOne(YtUserEntity, {
-                    where: [{ email }, { telnumber }] as any
-                });
-
-                if (existingUser) {
-                    throw new Error('用户已存在');
-                }
-
-                // 创建新用户
-                const user = new YtUserEntity();
-                user.email = email;
-                user.telnumber = telnumber;
-                user.password = await bcrypt.hash(password, 10);
-                user.createDate = new Date();
-                user.updateDate = new Date();
-
-                return await manager.save(user);
-            });
-
-            ctx.body = {
-                success: true,
-                message: '用户创建成功',
-                data: result
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('创建用户失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: error instanceof Error ? error.message : '创建用户失败',
-                error: '事务已回滚'
-            };
-            ctx.status = 500;
-        }
-    }
-
-    /**
-     * 示例 2: 更新用户信息（使用隔离级别）
-     * PUT /api/example/transaction/update-user/:id
-     */
-    @Put('/update-user/:id')
-    async updateUser(ctx: Context) {
-        const id = parseInt(ctx.params.id);
-        const { email, telnumber } = ctx.request.body;
-
-        try {
-            const result = await transactionManager.executeInTransaction(
-                async (manager) => {
-                    // 查找用户
-                    const user = await manager.findOne(YtUserEntity, {
-                        where: { id } as any
-                    });
-
-                    if (!user) {
-                        throw new Error('用户不存在');
-                    }
-
-                    // 更新用户信息
-                    if (email) {
-                        // 检查邮箱是否被其他用户使用
-                        const existingUser = await manager.findOne(YtUserEntity, {
-                            where: { email } as any
-                        });
-                        if (existingUser && existingUser.id !== id) {
-                            throw new Error('邮箱已被其他用户使用');
-                        }
-                        user.email = email;
-                    }
-
-                    if (telnumber) {
-                        // 检查手机号是否被其他用户使用
-                        const existingUser = await manager.findOne(YtUserEntity, {
-                            where: { telnumber } as any
-                        });
-                        if (existingUser && existingUser.id !== id) {
-                            throw new Error('手机号已被其他用户使用');
-                        }
-                        user.telnumber = telnumber;
-                    }
-
-                    user.updateDate = new Date();
-                    return await manager.save(user);
-                },
-                'SERIALIZABLE' // 使用最高隔离级别，防止并发更新冲突
-            );
-
-            ctx.body = {
-                success: true,
-                message: '用户更新成功',
-                data: result
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('更新用户失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: error instanceof Error ? error.message : '更新用户失败',
-                error: '事务已回滚'
-            };
-            ctx.status = 500;
-        }
-    }
-
-    /**
-     * 示例 3: 批量创建用户
-     * POST /api/example/transaction/batch-create
-     */
-    @Post('/batch-create')
-    async batchCreateUsers(ctx: Context) {
-        const { users } = ctx.request.body; // [{ email, telnumber, password }, ...]
-
-        try {
-            const operations = users.map((userData: any) => {
-                return async (manager: any) => {
-                    // 验证数据
-                    if (!userData.email || !userData.password) {
-                        throw new Error('邮箱和密码不能为空');
-                    }
-
-                    // 加密密码
-                    const hashedPassword = await bcrypt.hash(userData.password, 10);
-
-                    // 创建用户
-                    const user = new YtUserEntity();
-                    user.email = userData.email;
-                    user.telnumber = userData.telnumber;
-                    user.password = hashedPassword;
-                    user.createDate = new Date();
-                    user.updateDate = new Date();
-
-                    return await manager.save(user);
-                };
-            });
-
-            const results = await transactionManager.executeBatchTransaction(operations);
-
-            ctx.body = {
-                success: true,
-                message: `成功创建 ${results.length} 个用户`,
-                data: results
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('批量创建用户失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: '批量创建用户失败，所有更改已回滚',
-                error: error instanceof Error ? error.message : '未知错误'
-            };
-            ctx.status = 500;
-        }
-    }
-
-    /**
-     * 示例 4: 删除用户（演示事务回滚）
-     * DELETE /api/example/transaction/delete-user/:id
-     */
-    @Del('/delete-user/:id')
-    async deleteUser(ctx: Context) {
-        const id = parseInt(ctx.params.id);
-
-        try {
-            await transactionManager.executeInTransaction(async (manager) => {
-                // 查找用户
-                const user = await manager.findOne(YtUserEntity, {
-                    where: { id } as any
-                });
-
-                if (!user) {
-                    throw new Error('用户不存在');
-                }
-
-                // 模拟业务规则：不允许删除管理员用户
-                if (user.userType && String(user.userType) === 'admin') {
-                    throw new Error('不能删除管理员用户');
-                }
-
-                // 删除用户
-                await manager.remove(user);
-
-                // 模拟额外操作（如果有的话）
-                // await manager.save(DeleteLog, { userId: id });
-            });
-
-            ctx.body = {
-                success: true,
-                message: '用户删除成功'
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('删除用户失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: error instanceof Error ? error.message : '删除用户失败',
-                error: '事务已回滚'
-            };
-            ctx.status = 500;
-        }
-    }
-
-    /**
-     * 示例 5: 查询统计（使用只读事务）
-     * GET /api/example/transaction/stats
-     */
-    @Get('/stats')
-    async getStats(ctx: Context) {
-        try {
-            const stats = await transactionManager.executeInReadOnlyTransaction(async (manager) => {
-                // 只读事务，不会产生任何写操作
-                const totalUsers = await manager.count(YtUserEntity);
-                const activeUsers = await manager.count(YtUserEntity, {
-                    where: { status: 'normal' } as any
-                });
-
-                const users = await manager.find(YtUserEntity, {
-                    take: 10,
-                    order: { createDate: 'DESC' } as any
-                });
-
-                return {
-                    total: totalUsers,
-                    active: activeUsers,
-                    inactive: totalUsers - activeUsers,
-                    recentUsers: users
-                };
-            });
-
-            ctx.body = {
-                success: true,
-                data: stats
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('获取统计信息失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: '获取统计信息失败'
-            };
-            ctx.status = 500;
-        }
-    }
-
-    /**
-     * 示例 6: 复杂业务场景 - 用户迁移
-     * POST /api/example/transaction/migrate-user
-     */
-    @Post('/migrate-user')
-    async migrateUser(ctx: Context) {
-        const { fromUserId, toEmail } = ctx.request.body;
-
-        try {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                // 步骤 1: 查找原用户
-                const fromUser = await manager.findOne(YtUserEntity, {
-                    where: { id: fromUserId } as any
-                });
-
-                if (!fromUser) {
-                    throw new Error('原用户不存在');
-                }
-
-                // 步骤 2: 检查新邮箱是否已使用
-                const existingUser = await manager.findOne(YtUserEntity, {
-                    where: { email: toEmail } as any
-                });
-
-                if (existingUser) {
-                    throw new Error('新邮箱已被使用');
-                }
-
-                // 步骤 3: 创建新用户（复制数据）
-                const newUser = new YtUserEntity();
-                newUser.email = toEmail;
-                newUser.telnumber = fromUser.telnumber;
-                newUser.password = fromUser.password;
-                newUser.createDate = new Date();
-                newUser.updateDate = new Date();
-                const savedNewUser = await manager.save(newUser);
-
-                // 步骤 4: 删除原用户
-                await manager.remove(fromUser);
-
-                return {
-                    oldUser: fromUser,
-                    newUser: savedNewUser
-                };
-            });
-
-            ctx.body = {
-                success: true,
-                message: '用户迁移成功',
-                data: result
-            };
-            ctx.status = 200;
-
-        } catch (error) {
-            logger.error('用户迁移失败:', error as Error);
-            ctx.body = {
-                success: false,
-                message: error instanceof Error ? error.message : '用户迁移失败',
-                error: '所有操作已回滚'
-            };
-            ctx.status = 500;
-        }
-    }
-}