create-dp-koa 1.0.0

package/template/src/controllers/health.controller.ts

@@ -0,0 +1,235 @@
+import { Get } from '@src/framework/decorator/controller';
+import { BaseController } from '@src/controllers/base.controller';
+import { dbMonitor } from '@src/framework/utils/dbMonitor';
+import { isDbConnected, getDataSource } from '@src/framework/utils/db';
+import { getCacheStats, getCacheMemoryUsage } from '@src/framework/utils/cache';
+import { metricsCollector } from '@src/framework/utils/metrics';
+import { logger } from '@src/framework/utils/logger';
+import { getRuntimeEnvironmentLabel } from '@src/framework/utils/function';
+
+export class HealthController extends BaseController {
+    
+    @Get("/")
+    async healthCheck() {
+        const dbStatus = isDbConnected();
+        const poolStatus = await dbMonitor.getConnectionPoolStatus();
+        const cacheStats = getCacheStats();
+        const cacheMemory = getCacheMemoryUsage();
+        
+        return this.success({
+            status: 'ok',
+            timestamp: new Date().toISOString(),
+            database: {
+                connected: dbStatus,
+                pool: poolStatus
+            },
+            cache: {
+                stats: cacheStats,
+                memory: cacheMemory
+            },
+            uptime: process.uptime(),
+            memory: {
+                used: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+                total: Math.round(process.memoryUsage().heapTotal / 1024 / 1024),
+                rss: Math.round(process.memoryUsage().rss / 1024 / 1024)
+            }
+        });
+    }
+
+    @Get('/db')
+    async dbHealthCheck() {
+        const dbStatus = isDbConnected();
+        const poolStatus = await dbMonitor.getConnectionPoolStatus();
+        
+        if (!dbStatus) {
+            return this.fail(500, '数据库连接异常');
+        }
+        
+        return this.success({
+            connected: dbStatus,
+            pool: poolStatus
+        });
+    }
+
+    @Get('/cache')
+    async cacheHealthCheck() {
+        const cacheStats = getCacheStats();
+        const cacheMemory = getCacheMemoryUsage();
+        
+        // 检查是否有缓存使用率过高
+        const highUsageCaches = Object.entries(cacheMemory).filter(([name, info]: [string, any]) => {
+            return parseFloat(info.usage) > 80; // 使用率超过80%
+        });
+
+        if (highUsageCaches.length > 0) {
+            return this.fail(500, `缓存使用率过高: ${highUsageCaches.map(([name]) => name).join(', ')}`);
+        }
+        
+        return this.success({
+            stats: cacheStats,
+            memory: cacheMemory,
+            status: 'healthy'
+        });
+    }
+
+    /**
+     * 企业级详细健康检查
+     */
+    @Get('/detailed')
+    async detailedHealthCheck() {
+        const health = {
+            status: 'healthy',
+            timestamp: new Date().toISOString(),
+            uptime: process.uptime(),
+            pid: process.pid,
+            version: process.env.npm_package_version || '1.0.0',
+            environment: getRuntimeEnvironmentLabel(),
+            checks: {
+                database: await this.checkDatabase(),
+                memory: this.checkMemory(),
+                cache: await this.checkCache()
+            }
+        };
+
+        // 检查是否有任何检查失败
+        const failedChecks = Object.values(health.checks).filter((check: any) => check.status !== 'healthy');
+        if (failedChecks.length > 0) {
+            health.status = 'unhealthy';
+        }
+
+        return this.success(health);
+    }
+
+    /**
+     * 就绪检查
+     */
+    @Get('/ready')
+    async readinessCheck() {
+        const checks = {
+            database: await this.checkDatabase()
+        };
+
+        const isReady = Object.values(checks).every((check: any) => check.status === 'healthy');
+
+        return this.success({
+            status: isReady ? 'ready' : 'not_ready',
+            timestamp: new Date().toISOString(),
+            checks
+        });
+    }
+
+    /**
+     * 存活检查
+     */
+    @Get('/live')
+    async livenessCheck() {
+        return this.success({
+            status: 'alive',
+            timestamp: new Date().toISOString(),
+            pid: process.pid,
+            uptime: process.uptime()
+        });
+    }
+
+    /**
+     * 指标端点
+     */
+    @Get('/metrics')
+    async metrics() {
+        return this.success({
+            prometheus: metricsCollector.generatePrometheusMetrics(),
+            json: metricsCollector.getSystemMetrics()
+        });
+    }
+
+    /**
+     * 检查数据库连接
+     */
+    private async checkDatabase(): Promise<any> {
+        try {
+            const dataSource = getDataSource();
+            if (!dataSource) {
+                return {
+                    status: 'unhealthy',
+                    message: 'Database not initialized'
+                };
+            }
+
+            if (!dataSource.isInitialized) {
+                return {
+                    status: 'unhealthy',
+                    message: 'Database not connected'
+                };
+            }
+
+            // 执行简单查询测试连接
+            await dataSource.query('SELECT 1');
+            
+            return {
+                status: 'healthy',
+                message: 'Database connection OK',
+                type: dataSource.options.type
+            };
+        } catch (error) {
+            logger.error('Database health check failed', error as Error);
+            return {
+                status: 'unhealthy',
+                message: 'Database connection failed',
+                error: (error as Error).message
+            };
+        }
+    }
+
+    /**
+     * 检查内存使用
+     */
+    private checkMemory(): any {
+        const memUsage = process.memoryUsage();
+        const maxMemory = 500 * 1024 * 1024; // 500MB
+        const isHealthy = memUsage.heapUsed < maxMemory;
+
+        return {
+            status: isHealthy ? 'healthy' : 'unhealthy',
+            message: isHealthy ? 'Memory usage OK' : 'Memory usage high',
+            details: {
+                heapUsed: memUsage.heapUsed,
+                heapTotal: memUsage.heapTotal,
+                rss: memUsage.rss,
+                external: memUsage.external
+            }
+        };
+    }
+
+    /**
+     * 检查缓存状态
+     */
+    private async checkCache(): Promise<any> {
+        try {
+            const cacheStats = getCacheStats();
+            const cacheMemory = getCacheMemoryUsage();
+            
+            // 检查是否有缓存使用率过高
+            const highUsageCaches = Object.entries(cacheMemory).filter(([name, info]: [string, any]) => {
+                return parseFloat(info.usage) > 80;
+            });
+
+            const isHealthy = highUsageCaches.length === 0;
+
+            return {
+                status: isHealthy ? 'healthy' : 'unhealthy',
+                message: isHealthy ? 'Cache status OK' : 'Cache usage high',
+                details: {
+                    stats: cacheStats,
+                    memory: cacheMemory,
+                    highUsageCaches: highUsageCaches.map(([name]) => name)
+                }
+            };
+        } catch (error) {
+            return {
+                status: 'unhealthy',
+                message: 'Cache check failed',
+                error: (error as Error).message
+            };
+        }
+    }
+}

package/template/src/controllers/home/register.controller.ts

@@ -0,0 +1,58 @@
+import { BaseController, ControllerResponse } from "@src/controllers/base.controller";
+import { Body, Post } from "@src/framework/decorator/controller";
+import { YtUserRegisterDto } from "@src/dto/controller/home/register.controller.dto";
+import * as jwt from "jsonwebtoken";
+import { Inject } from "dp-ioc2";
+import md5 from "md5"
+import { YtUserService } from "@src/service/ytUser.service";
+import { YtUserEntity } from "@src/entity/ytUser.entity";
+import { logger } from "@src/framework/utils/logger";
+
+interface IvcodeInfo {
+    vcode: string
+    expire: number
+}
+
+export class YtUserRegisterController extends BaseController {
+
+    @Inject(YtUserService)
+    ytUserService: YtUserService;
+
+    
+    @Post()
+    async register(
+        @Body(YtUserRegisterDto) body: YtUserRegisterDto
+    ): Promise<ControllerResponse<boolean>> {
+
+        let vcodeInfo: IvcodeInfo | null = null;
+        try {
+            vcodeInfo = jwt.verify(body.vcodeToken, process.env.jwt_secret ?? "123456") as any;
+        } catch (err) {
+            throw "验证码解析异常";
+        }
+
+        if (!vcodeInfo) {
+            return this.fail(-1, "验证码解析失败");
+        }
+
+        if (vcodeInfo?.expire < new Date().getTime()) {
+            return this.fail(-1, "验证码过期");
+        }
+
+        // 验证是否已经完成注册
+        const exist = await this.ytUserService.findByEmail(body.email);
+        if (exist) {
+            
+            // return this.fail(-1, "邮箱已经注册");
+        }
+
+        // 开始注册
+        const ytUser = new YtUserEntity();
+        ytUser.nickName = '新用户';
+        ytUser.email = body.email;
+        ytUser.password = md5(body.password);
+        await this.ytUserService.add(ytUser);
+
+        return this.success(true, "注册成功")
+    }
+}

package/template/src/controllers/home/ytGoods.controller.ts

@@ -0,0 +1,92 @@
+import { Body, ControllerCache, Get, Post, Query, State } from "@src/framework/decorator/controller";
+import { BaseController, ControllerResponse } from "@src/controllers/base.controller";
+import { GetGoodsInfoDto, GetGoodsInfoResultDto, GetGoodsUnlockInfoDto, UnlockGoodsImageDto } from "@src/dto/controller/home/ytGoods.controller.dto";
+import { Inject } from "dp-ioc2";
+import { YtGoodsService } from "@src/service/ytGoods.service";
+import { YtGoodsEntity } from "@src/entity/ytGoods.entity";
+import { CommonServiceResultCode } from "@src/framework/types/ServiceResult";
+import { isDebug } from "@src/framework/utils/function";
+import { YtGoodsUnlockerEntity } from "@src/entity/goodsUnlocker.entity";
+
+export class YtGoodsController extends BaseController {
+
+    @Inject(YtGoodsService)
+    goodsService: YtGoodsService;
+
+    /**
+     * 解锁商品图片
+     * @param body 
+     */
+    @Post()
+    async unlockGoodsImage(
+        @Body(UnlockGoodsImageDto) body: UnlockGoodsImageDto,
+        @State() state: any
+    ): Promise<ControllerResponse<boolean>> {
+        
+        const result = await this.goodsService.unlockGoodsImage(
+            body.goodsId, 
+            state.user.userId, 
+            body.key
+        );
+        
+        if (result.code !== CommonServiceResultCode.SUCCESS) {
+            return this.fail(-1, result.message || "解锁失败");
+        }
+        
+        return this.success(true);
+    }
+
+    @ControllerCache((query: GetGoodsInfoDto) => `YtGoodsController-getGoodsInfo-${query.id}`, {
+        ttl: {
+            max: 60 * 5,
+            min: 30,
+        },
+        enable: !isDebug()
+    })
+    @Get()
+    async getGoodsInfo(
+        @Query(GetGoodsInfoDto) query: GetGoodsInfoDto
+    ): Promise<ControllerResponse<GetGoodsInfoResultDto>> {
+
+        const goods = await this.goodsService.getById(YtGoodsEntity, query.id);
+        if (!goods) {
+            return this.fail(-1, "查询商品失败");
+        }
+
+        return this.success({
+            id: goods.id,
+            name: goods.name,
+            albums: goods.albums,
+            tags: goods.tags,
+            price: goods.price,
+            description: goods.description,
+            content: goods.content,
+            imagesContent: goods.imagesContent
+        })
+    }
+
+    // @ControllerCache((query: GetGoodsUnlockInfoDto) => `YtGoodsController-getGoodsUnlockInfo-${query.goodsId}`, {
+    //     ttl: {
+    //         max: 60 * 2,
+    //         min: 30,
+    //     },
+    //     enable: !isDebug()
+    // })
+    @Get()
+    async getGoodsUnlockInfo(
+        @Query(GetGoodsUnlockInfoDto) query: GetGoodsUnlockInfoDto,
+        @State() state: any,
+    ): Promise<ControllerResponse<boolean | null>> {
+
+        const result = await this.goodsService.getDataRepository(YtGoodsUnlockerEntity).findOne({
+            where: {
+                ytUserId: state.user.userId,
+                goodsId: query.goodsId,
+            }
+        });
+        if (result) {
+            return this.success(true);
+        }
+        return this.success(false);
+    }
+}

package/template/src/controllers/home/ytShop.controller.ts

@@ -0,0 +1,135 @@
+import { Inject } from "dp-ioc2"
+import { BaseController, ControllerResponse } from "@src/controllers/base.controller"
+import { YtShopService } from "@src/service/ytShop.service"
+import { Get, Query, ResponseValidateIf, State } from "@src/framework/decorator/controller";
+import { GetShopGoodsListQueryDto, GetShopGoodsListResultDto, GetShopInfoByIdQueryDto, GetShopInfoByIdResultDto, GetShopUserInfoDto } from "@src/dto/controller/home/ytShop.controller.dto";
+import { ShopEntity, ShopStatusEnum } from "@src/entity/shop.entity";
+import { CommonServiceResultCode } from "@src/framework/types/ServiceResult";
+import { getUserInfoByIdDto, GetUserInfoResponseDto } from "@src/dto/controller/home/ytUser.controller.dto";
+import { createCache, CacheType } from "@src/framework/utils/cache";
+import { YtUserService } from "@src/service/ytUser.service";
+import { YtUserEntity } from "@src/entity/ytUser.entity";
+
+// 创建店铺用户缓存实例
+const shopUserCache = createCache('yt-shop-user-controller', CacheType.USER, {
+    stdTTL: 1800, // 30分钟过期
+    maxKeys: 500
+});
+
+
+export class YtShopController extends BaseController {
+
+    @Inject(YtShopService)
+    ytShopService: YtShopService;
+
+    @Inject(YtUserService)
+    ytUserService: YtUserService
+
+
+    /**
+     * 读取店铺的基本信息
+     * @param state 
+     * @returns 
+     */
+    @ResponseValidateIf(GetShopInfoByIdResultDto, (data) => data && data.data)
+    @Get()
+    async getShopInfoById(
+        @Query(GetShopInfoByIdQueryDto) query: GetShopInfoByIdQueryDto
+    ): Promise<ControllerResponse<GetShopInfoByIdResultDto | null>> {
+
+        const shop = await this.ytShopService.getById(ShopEntity, query.id);
+        if (!shop) {
+            return this.fail(-1, "店铺不存在");
+        }
+      
+        if (shop.status == ShopStatusEnum.FORBIDDEN) {
+            return this.fail(-1, "店铺已被禁用");
+        }
+
+        // 读取 店铺用户的基本信息
+        const shopUserResult = await this.ytShopService.getShopUserInfo(shop.id);
+        if (shopUserResult.code != CommonServiceResultCode.SUCCESS) {
+            return this.fail(-1, "店铺用户信息加载失败");
+        }
+
+        return this.success({
+            id: shop.id,
+            name: shop.name,
+            description: shop.description,
+            userId: shopUserResult.data?.id ?? 0,
+            // avatar: shopUserResult.data?.avatar ?? "",
+            status: shop.status,
+        });
+    }
+
+    /**
+     * 获取店铺的商品列表
+     * @param query 
+     */
+    @Get()
+    async getShopGoodsList(
+        @Query(GetShopGoodsListQueryDto) query: GetShopGoodsListQueryDto
+    ): Promise<ControllerResponse<[GetShopGoodsListResultDto[], number]>> {
+        const { id, page = 1, pageSize = 10 } = query;
+        const result = await this.ytShopService.getGoodsListByShopId(id, page, pageSize);
+        if (result.code != CommonServiceResultCode.SUCCESS) {
+            return this.fail(-1, result.message);
+        }
+
+        // 过滤出精简信息
+        const responseData = result.data?.[0].map(item => {
+            return {
+                id: item.id,
+                name: item.name,
+                description: item.description,
+                price: item.price,
+                albums: item.albums,
+            }
+        }) ?? []
+        return this.success([responseData, result.data?.[1] ?? 0]);
+    }
+
+    @ResponseValidateIf(GetUserInfoResponseDto, (data) => data && data.data)
+    @Get()
+    async getShopUserInfo(
+        @Query(GetShopUserInfoDto) query: GetShopUserInfoDto
+    )
+        : Promise<ControllerResponse<null | GetUserInfoResponseDto>> {
+
+        const cacheKey = `shop_user_${query.shopId}`;
+        const user = shopUserCache.get(cacheKey);
+        if (user) {
+            return this.success({
+                id: user.id,
+                nickName: user.nickName,
+                status: user.status,
+                email: user.email,
+                type: user.userType,
+                avatar: user.avatar,
+                gender: user.gender,
+                age: user.age,
+                constellation: user.constellation,
+            })
+        }
+
+        const getUserResult = await this.ytShopService.getShopUserInfo(query.shopId);
+        if (getUserResult.code != CommonServiceResultCode.SUCCESS) {
+            return this.fail(-1, getUserResult.message)
+        }
+        const _user = getUserResult.data as YtUserEntity;
+        shopUserCache.set(cacheKey, _user);
+
+        return this.success({
+            id: _user.id,
+            nickName: _user.nickName,
+            status: _user.status,
+            email: _user.email,
+            type: _user.userType,
+            avatar: _user.avatar,
+            gender: _user.gender,
+            age: _user.age,
+            constellation: _user.constellation,
+        })
+    }
+
+}

package/template/src/controllers/home/ytUser.controller.ts

@@ -0,0 +1,89 @@
+import { Get, Query, ResponseValidateIf, ResponseValidator, State } from "@src/framework/decorator/controller";
+import { BaseController, ControllerResponse } from "@src/controllers/base.controller";
+import { logger } from "@src/framework/utils/logger";
+import { Inject } from "dp-ioc2";
+import { YtUserService } from "@src/service/ytUser.service";
+import { YtUserEntity } from "@src/entity/ytUser.entity";
+import { createCache, CacheType } from "@src/framework/utils/cache";
+import { CommonServiceResultCode } from "@src/framework/types/ServiceResult";
+import { getUserInfoByIdDto, GetUserInfoResponseDto } from "@src/dto/controller/home/ytUser.controller.dto";
+import { YtShopService } from "@src/service/ytShop.service";
+
+// 创建用户缓存实例
+const userCache = createCache('yt-user-controller', CacheType.USER, {
+    stdTTL: 1800, // 30分钟过期
+    maxKeys: 500
+});
+
+
+
+export class YtUserController extends BaseController {
+
+
+    @Inject(YtUserService)
+    ytUserService: YtUserService;
+
+    @Inject(YtShopService)
+    ytShopService: YtShopService;
+
+
+    @ResponseValidateIf(GetUserInfoResponseDto, (data) => data && data.data)
+    @Get()
+    async getUserInfo(@State() state: any)
+        : Promise<ControllerResponse<null | GetUserInfoResponseDto>> {
+
+        const cacheKey = `user_${state.user.userId}`;
+        const user = userCache.get(cacheKey);
+        if (user) {
+            return this.success({
+                id: user.id,
+                nickName: user.nickName,
+                status: user.status,
+                email: user.email,
+                type: user.userType,
+                avatar: user.avatar,
+                gender: user.gender,
+                age: user.age,
+                constellation: user.constellation,
+            })
+        }
+
+        const _user = await this.ytUserService.getById(YtUserEntity, state.user.userId);
+        if (!_user) {
+            return this.fail(-1, '用户不存在')
+        }
+      
+        userCache.set(cacheKey, _user);
+
+        return this.success({
+            id: _user.id,
+            nickName: _user.nickName,
+            status: _user.status,
+            email: _user.email,
+            type: _user.userType,
+            avatar: _user.avatar,
+            gender: _user.gender,
+            age: _user.age,
+            constellation: _user.constellation,
+        })
+    }
+
+
+    /**
+     * 检查当前用户是否有店铺
+     * @param state 
+     * @returns 
+     */
+    @Get()
+    async hasShop(
+        @State() state: any
+    ): Promise<ControllerResponse<number | null>> {
+
+        const result = await this.ytShopService.checkHasShop(state.user.userId);
+        if (result.code != CommonServiceResultCode.SUCCESS) {
+            return this.fail(-1, result.message);
+        }
+        return this.success(result.data);
+    }
+
+}