create-dp-koa 1.0.0

package/template/src/entity/ytGoods.entity.ts

@@ -0,0 +1,94 @@
+import { Column, Entity, Index, ManyToOne, OneToMany, JoinColumn } from "typeorm";
+import { BaseEntity } from "@src/entity/base.entity";
+import { ShopEntity } from "@src/entity/shop.entity";
+import { YtGoodsUnlockerEntity } from "@src/entity/goodsUnlocker.entity";
+import { GoodsImagesUnlockKeyEntity } from "@src/entity/goodsImagesUnlockKey.entity";
+
+
+export enum YtGoodsStatusEnum {
+    NORMAL = "NORMAL",
+    FORBIDDEN = "FORBIDDEN",
+    CHECKING = "CHECKING",
+}
+
+
+@Entity({
+    name: "yt_goods"
+})
+export class YtGoodsEntity extends BaseEntity {
+
+    @Index()
+    @Column({ default: "" })
+    name: string;
+
+    @Index()
+    @Column({
+        default: 0,
+        type: "integer"
+    })
+    shopId: number
+
+    @Column({
+        type: "simple-array",
+        default: ""
+    })
+    albums: string[]
+
+    @Column({ default: 0 })
+    price: number;
+
+    @Column({
+        type: "simple-array",
+        default: ""
+    })
+    tags: string[];
+
+    @Column({
+        default: ""
+    })
+    description: string;
+
+
+    @Column({
+        type: "text",
+        default: ""
+    })
+    content: string
+
+    /**
+     * 商品内容中的图片，产品的照片相册
+     */
+    @Column({
+        type: "simple-array",
+        default: ""
+    })
+    imagesContent: string[]
+
+    @Column({
+        type: "varchar",
+        length: 50,
+        default: YtGoodsStatusEnum.NORMAL
+    })
+    status: YtGoodsStatusEnum;
+
+    // 关系定义
+    /**
+     * 商品所属的店铺
+     */
+    @ManyToOne(() => ShopEntity, shop => shop.goods)
+    @JoinColumn({ name: 'shopId' })
+    shop: ShopEntity;
+
+    /**
+     * 商品解锁记录
+     */
+    @OneToMany(() => YtGoodsUnlockerEntity, unlocker => unlocker.goods)
+    unlockRecords: YtGoodsUnlockerEntity[];
+
+    /**
+     * 商品图片解锁密钥
+     */
+    @OneToMany(() => GoodsImagesUnlockKeyEntity, key => key.goods)
+    unlockKeys: GoodsImagesUnlockKeyEntity[];
+
+}

package/template/src/entity/ytUser.entity.ts

@@ -0,0 +1,96 @@
+import { Column, Entity, OneToMany, OneToOne } from "typeorm";
+import { BaseEntity } from "@src/entity/base.entity";
+import { ShopAndUserEntity } from "@src/entity/shopUser.entity";
+import { YtGoodsUnlockerEntity } from "@src/entity/goodsUnlocker.entity";
+
+
+export enum YtUserStatusEnum {
+    NORMAL = "normal",
+    FORBIDDEN = "forbidden"
+}
+
+export enum YtUserTypeEnum {
+    CUSTOMER = "CUSTOMER", // 消费者
+    SHOP = "SHOP" // 商家
+}
+
+
+@Entity({
+    name: "yt_user"
+})
+export class YtUserEntity extends BaseEntity {
+
+
+
+    @Column({
+        default: ""
+    })
+    nickName: string
+
+    @Column({
+        default: ""
+    })
+    telnumber: string
+
+    @Column({
+        default: ""
+    })
+    email: string
+
+    @Column({
+        default: ""
+    })
+    password: string
+
+    @Column({
+        type: "varchar",
+        length: 50,
+        default: YtUserTypeEnum.CUSTOMER
+    })
+    userType: YtUserTypeEnum
+
+    @Column({
+        default: 0,
+    })
+    gender: number
+
+
+    @Column({
+        default: 0,
+    })
+    age: number
+
+
+    // 星座
+    @Column({
+        default: ""
+    })
+    constellation: string
+
+
+    @Column({
+        default: ""
+    })
+    avatar: string;
+
+    @Column({
+        default: YtUserStatusEnum.NORMAL,
+        type: "varchar",
+        length: 50
+    })
+    status: YtUserStatusEnum;
+
+    // 关系定义
+    /**
+     * 用户与店铺的关系（一个用户只能拥有一个店铺）
+     */
+    @OneToOne(() => ShopAndUserEntity, shopUser => shopUser.user)
+    shopRelation: ShopAndUserEntity;
+
+    /**
+     * 用户解锁的商品记录
+     */
+    @OneToMany(() => YtGoodsUnlockerEntity, unlocker => unlocker.user)
+    unlockedGoods: YtGoodsUnlockerEntity[];
+
+}

package/template/src/examples/InterceptorExampleRunner.ts

@@ -0,0 +1,284 @@
+/**
+ * 完整Service拦截器使用示例
+ * 展示基础拦截器和高级拦截器的使用
+ */
+
+import { Injectable, Interceptor } from "dp-ioc2";
+import { createServiceCallInterceptor } from '@src/framework/interceptors/ServiceCallInterceptor';
+import { createAdvancedServiceCallInterceptor, InterceptorOptions } from '@src/framework/interceptors/AdvancedServiceCallInterceptor';
+import { logger } from '@src/framework/utils/logger';
+
+/**
+ * 用户服务示例 - 使用基础拦截器
+ */
+@Injectable()
+export class UserService {
+    
+    @Interceptor(createServiceCallInterceptor())
+    async getUserById(id: number): Promise<{ id: number; name: string; email: string }> {
+        logger.info(`获取用户信息: ${id}`);
+        
+        // 模拟数据库查询
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        return {
+            id,
+            name: `用户${id}`,
+            email: `user${id}@example.com`
+        };
+    }
+    
+    @Interceptor(createServiceCallInterceptor())
+    async createUser(userData: { name: string; email: string; password: string }): Promise<{ id: number; name: string; email: string }> {
+        logger.info(`创建用户:`, userData);
+        
+        // 模拟创建用户
+        await new Promise(resolve => setTimeout(resolve, 200));
+        
+        const newUser = {
+            id: Math.floor(Math.random() * 1000),
+            name: userData.name,
+            email: userData.email
+        };
+        
+        return newUser;
+    }
+}
+
+/**
+ * 订单服务示例 - 使用高级拦截器
+ */
+@Injectable()
+export class OrderService {
+    
+    @Interceptor(createAdvancedServiceCallInterceptor({
+        enablePerformanceMonitoring: true,
+        enableCaching: true,
+        enableRetry: true,
+        enableCircuitBreaker: true,
+        cacheTTL: 300000, // 5分钟
+        maxRetries: 3,
+        retryDelay: 1000,
+        circuitBreakerThreshold: 3,
+        slowCallThreshold: 500
+    }))
+    async getOrderById(orderId: number): Promise<{ id: number; status: string; amount: number }> {
+        logger.info(`获取订单信息: ${orderId}`);
+        
+        // 模拟可能失败的外部API调用
+        if (Math.random() < 0.3) {
+            throw new Error('外部API调用失败');
+        }
+        
+        await new Promise(resolve => setTimeout(resolve, 300));
+        
+        return {
+            id: orderId,
+            status: 'completed',
+            amount: Math.floor(Math.random() * 1000) + 100
+        };
+    }
+    
+    @Interceptor(createAdvancedServiceCallInterceptor({
+        enablePerformanceMonitoring: true,
+        enableCaching: false,
+        enableRetry: true,
+        enableCircuitBreaker: false,
+        maxRetries: 2,
+        retryDelay: 500,
+        slowCallThreshold: 1000
+    }))
+    async createOrder(orderData: { userId: number; items: any[]; total: number }): Promise<{ id: number; status: string }> {
+        logger.info(`创建订单:`, orderData);
+        
+        // 模拟创建订单
+        await new Promise(resolve => setTimeout(resolve, 150));
+        
+        return {
+            id: Math.floor(Math.random() * 10000),
+            status: 'pending'
+        };
+    }
+}
+
+/**
+ * 支付服务示例 - 使用高级拦截器（熔断器测试）
+ */
+@Injectable()
+export class PaymentService {
+    
+    @Interceptor(createAdvancedServiceCallInterceptor({
+        enablePerformanceMonitoring: true,
+        enableCaching: false,
+        enableRetry: true,
+        enableCircuitBreaker: true,
+        maxRetries: 2,
+        retryDelay: 1000,
+        circuitBreakerThreshold: 2, // 低阈值，容易触发熔断
+        slowCallThreshold: 200
+    }))
+    async processPayment(paymentData: { orderId: number; amount: number; cardToken: string }): Promise<{ transactionId: string; status: string }> {
+        logger.info(`处理支付:`, paymentData);
+        
+        // 模拟支付服务不稳定（70%失败率）
+        if (Math.random() < 0.7) {
+            throw new Error('支付服务暂时不可用');
+        }
+        
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        return {
+            transactionId: `txn_${Date.now()}`,
+            status: 'success'
+        };
+    }
+}
+
+/**
+ * 拦截器示例运行器
+ */
+export class InterceptorExampleRunner {
+    
+    /**
+     * 运行基础拦截器示例
+     */
+    static async runBasicInterceptorExample() {
+        logger.info('=== 基础拦截器示例 ===');
+        
+        const userService = new UserService();
+        
+        try {
+            // 测试正常调用
+            const user = await userService.getUserById(123);
+            logger.info('获取用户成功:', user);
+            
+            // 测试创建用户
+            const newUser = await userService.createUser({
+                name: '张三',
+                email: 'zhangsan@example.com',
+                password: 'password123'
+            });
+            logger.info('创建用户成功:', newUser);
+            
+        } catch (error) {
+            logger.error('基础拦截器示例失败:', error as Error);
+        }
+    }
+    
+    /**
+     * 运行高级拦截器示例
+     */
+    static async runAdvancedInterceptorExample() {
+        logger.info('=== 高级拦截器示例 ===');
+        
+        const orderService = new OrderService();
+        
+        try {
+            // 测试缓存和重试
+            logger.info('--- 测试缓存和重试 ---');
+            for (let i = 0; i < 3; i++) {
+                try {
+                    const order = await orderService.getOrderById(456);
+                    logger.info(`第${i + 1}次调用成功:`, order);
+                } catch (error) {
+                    logger.info(`第${i + 1}次调用失败:`, (error as Error).message);
+                }
+            }
+            
+            // 测试创建订单
+            logger.info('--- 测试创建订单 ---');
+            const order = await orderService.createOrder({
+                userId: 123,
+                items: [{ id: 1, quantity: 2 }],
+                total: 299.99
+            });
+            logger.info('创建订单成功:', order);
+            
+        } catch (error) {
+            logger.error('高级拦截器示例失败:', error as Error);
+        }
+    }
+    
+    /**
+     * 运行熔断器示例
+     */
+    static async runCircuitBreakerExample() {
+        logger.info('=== 熔断器示例 ===');
+        
+        const paymentService = new PaymentService();
+        
+        try {
+            // 连续失败调用，触发熔断器
+            logger.info('--- 触发熔断器 ---');
+            for (let i = 0; i < 5; i++) {
+                try {
+                    const payment = await paymentService.processPayment({
+                        orderId: 789,
+                        amount: 99.99,
+                        cardToken: 'card_token_123'
+                    });
+                    logger.info(`第${i + 1}次支付成功:`, payment);
+                } catch (error) {
+                    logger.info(`第${i + 1}次支付失败:`, (error as Error).message);
+                }
+                
+                // 短暂延迟
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            
+            // 等待熔断器恢复
+            logger.info('--- 等待熔断器恢复 ---');
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // 尝试恢复调用
+            try {
+                const payment = await paymentService.processPayment({
+                    orderId: 999,
+                    amount: 199.99,
+                    cardToken: 'card_token_456'
+                });
+                logger.info('熔断器恢复后支付成功:', payment);
+            } catch (error) {
+                logger.info('熔断器恢复后支付仍然失败:', (error as Error).message);
+            }
+            
+        } catch (error) {
+            logger.error('熔断器示例失败:', error as Error);
+        }
+    }
+    
+    /**
+     * 显示拦截器统计信息
+     */
+    static showInterceptorStats() {
+        logger.info('=== 拦截器统计信息 ===');
+        
+        // 显示基础拦截器统计
+        const { serviceCallInterceptor } = require('@src/framework/interceptors/ServiceCallInterceptor');
+        logger.info('基础拦截器统计:');
+        logger.info(serviceCallInterceptor.generateReport());
+        
+        // 显示高级拦截器状态
+        const { advancedServiceCallInterceptor } = require('@src/framework/interceptors/AdvancedServiceCallInterceptor');
+        logger.info('高级拦截器状态:');
+        logger.info(JSON.stringify(advancedServiceCallInterceptor.getStatus(), null, 2));
+    }
+    
+    /**
+     * 运行所有示例
+     */
+    static async runAllExamples() {
+        try {
+            await this.runBasicInterceptorExample();
+            await this.runAdvancedInterceptorExample();
+            await this.runCircuitBreakerExample();
+            this.showInterceptorStats();
+            
+            logger.info('=== 所有拦截器示例运行完成 ===');
+            
+        } catch (error) {
+            logger.error('运行拦截器示例失败:', error as Error);
+        }
+    }
+}
+

package/template/src/examples/ServiceInterceptorExample.ts

@@ -0,0 +1,214 @@
+/**
+ * Service调用拦截器使用示例
+ * 展示如何在Service中使用Interceptor注解来监控方法调用
+ */
+
+import { Injectable, Interceptor } from "dp-ioc2";
+import { createServiceCallInterceptor } from '@src/framework/interceptors/ServiceCallInterceptor';
+import { logger } from '@src/framework/utils/logger';
+
+/**
+ * 示例Service - 展示拦截器的使用
+ */
+@Injectable()
+export class ExampleService {
+    
+    /**
+     * 示例方法1：同步方法
+     * 使用拦截器监控调用
+     */
+    @Interceptor(createServiceCallInterceptor())
+    getUserInfo(userId: number): { id: number; name: string; email: string } {
+        logger.info(`执行getUserInfo方法，参数: ${userId}`);
+        
+        // 模拟业务逻辑
+        return {
+            id: userId,
+            name: `用户${userId}`,
+            email: `user${userId}@example.com`
+        };
+    }
+    
+    /**
+     * 示例方法2：异步方法
+     * 使用拦截器监控调用
+     */
+    @Interceptor(createServiceCallInterceptor())
+    async createUser(userData: { name: string; email: string; password: string }): Promise<{ id: number; name: string; email: string }> {
+        logger.info(`执行createUser方法，参数:`, userData);
+        
+        // 模拟异步业务逻辑
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        const newUser = {
+            id: Math.floor(Math.random() * 1000),
+            name: userData.name,
+            email: userData.email
+        };
+        
+        logger.info(`创建用户成功:`, newUser);
+        return newUser;
+    }
+    
+    /**
+     * 示例方法3：可能抛出异常的方法
+     * 使用拦截器监控调用
+     */
+    @Interceptor(createServiceCallInterceptor())
+    async deleteUser(userId: number): Promise<boolean> {
+        logger.info(`执行deleteUser方法，参数: ${userId}`);
+        
+        // 模拟业务逻辑
+        if (userId <= 0) {
+            throw new Error('无效的用户ID');
+        }
+        
+        // 模拟异步操作
+        await new Promise(resolve => setTimeout(resolve, 50));
+        
+        logger.info(`删除用户成功: ${userId}`);
+        return true;
+    }
+    
+    /**
+     * 示例方法4：复杂参数的方法
+     * 使用拦截器监控调用
+     */
+    @Interceptor(createServiceCallInterceptor())
+    async updateUser(userId: number, updateData: { 
+        name?: string; 
+        email?: string; 
+        password?: string;
+        preferences?: any;
+    }): Promise<{ id: number; name: string; email: string; updated: string[] }> {
+        logger.info(`执行updateUser方法，参数:`, { userId, updateData });
+        
+        // 模拟业务逻辑
+        await new Promise(resolve => setTimeout(resolve, 80));
+        
+        const updatedFields = Object.keys(updateData).filter(key => updateData[key as keyof typeof updateData] !== undefined);
+        
+        const result = {
+            id: userId,
+            name: updateData.name || `用户${userId}`,
+            email: updateData.email || `user${userId}@example.com`,
+            updated: updatedFields
+        };
+        
+        logger.info(`更新用户成功:`, result);
+        return result;
+    }
+    
+    /**
+     * 示例方法5：批量操作
+     * 使用拦截器监控调用
+     */
+    @Interceptor(createServiceCallInterceptor())
+    async batchCreateUsers(usersData: Array<{ name: string; email: string; password: string }>): Promise<Array<{ id: number; name: string; email: string }>> {
+        logger.info(`执行batchCreateUsers方法，参数数量: ${usersData.length}`);
+        
+        const results = [];
+        
+        for (let i = 0; i < usersData.length; i++) {
+            const userData = usersData[i];
+            logger.info(`处理第${i + 1}个用户:`, userData);
+            
+            // 模拟异步操作
+            await new Promise(resolve => setTimeout(resolve, 30));
+            
+            const newUser = {
+                id: Math.floor(Math.random() * 1000) + i * 1000,
+                name: userData.name,
+                email: userData.email
+            };
+            
+            results.push(newUser);
+        }
+        
+        logger.info(`批量创建用户完成，共创建${results.length}个用户`);
+        return results;
+    }
+}
+
+/**
+ * 拦截器使用示例类
+ */
+export class ServiceInterceptorExample {
+    
+    /**
+     * 运行拦截器示例
+     */
+    static async runExample() {
+        try {
+            logger.info('=== Service调用拦截器示例开始 ===');
+            
+            // 创建Service实例
+            const exampleService = new ExampleService();
+            
+            // 测试同步方法
+            logger.info('\n--- 测试同步方法 ---');
+            const userInfo = exampleService.getUserInfo(123);
+            logger.info('同步方法结果:', userInfo);
+            
+            // 测试异步方法
+            logger.info('\n--- 测试异步方法 ---');
+            const newUser = await exampleService.createUser({
+                name: '张三',
+                email: 'zhangsan@example.com',
+                password: 'password123'
+            });
+            logger.info('异步方法结果:', newUser);
+            
+            // 测试异常方法
+            logger.info('\n--- 测试异常方法 ---');
+            try {
+                await exampleService.deleteUser(-1);
+            } catch (error) {
+                logger.info('捕获到预期的异常:', (error as Error).message);
+            }
+            
+            // 测试正常删除
+            await exampleService.deleteUser(456);
+            
+            // 测试复杂参数方法
+            logger.info('\n--- 测试复杂参数方法 ---');
+            const updateResult = await exampleService.updateUser(789, {
+                name: '李四',
+                email: 'lisi@example.com',
+                preferences: { theme: 'dark', language: 'zh-CN' }
+            });
+            logger.info('更新方法结果:', updateResult);
+            
+            // 测试批量操作
+            logger.info('\n--- 测试批量操作方法 ---');
+            const batchResult = await exampleService.batchCreateUsers([
+                { name: '王五', email: 'wangwu@example.com', password: 'pass123' },
+                { name: '赵六', email: 'zhaoliu@example.com', password: 'pass456' },
+                { name: '钱七', email: 'qianqi@example.com', password: 'pass789' }
+            ]);
+            logger.info('批量操作结果:', batchResult);
+            
+            logger.info('\n=== Service调用拦截器示例完成 ===');
+            
+        } catch (error) {
+            logger.error('运行拦截器示例失败:', error as Error);
+        }
+    }
+    
+    /**
+     * 显示拦截器统计信息
+     */
+    static showInterceptorStats() {
+        const { serviceCallInterceptor } = require('@src/framework/interceptors/ServiceCallInterceptor');
+        
+        logger.info('\n=== 拦截器统计信息 ===');
+        logger.info(serviceCallInterceptor.generateReport());
+        
+        logger.info('\n=== 最近调用历史 ===');
+        const history = serviceCallInterceptor.getCallHistory();
+        history.slice(-5).forEach((call: any, index: number) => {
+            logger.info(`${index + 1}. ${call.serviceName}.${call.methodName} - ${call.duration}ms - ${call.error ? '失败' : '成功'}`);
+        });
+    }
+}
+