create-dp-koa 1.0.0

package/template/src/repository/base/BaseRepository.ts

@@ -0,0 +1,124 @@
+import { Repository, EntityTarget, FindManyOptions, FindOneOptions, UpdateResult, DeleteResult, ObjectLiteral } from 'typeorm';
+import { IBaseRepository } from '@src/repository/interfaces/IBaseRepository';
+import { logger } from '@src/framework/utils/logger';
+
+/**
+ * 基础Repository实现
+ * 提供通用的数据访问操作
+ */
+export abstract class BaseRepository<T extends ObjectLiteral> implements IBaseRepository<T> {
+    protected repository: Repository<T>;
+
+    constructor(entity: EntityTarget<T>, repository: Repository<T>) {
+        this.repository = repository;
+    }
+
+    async findById(id: number): Promise<T | null> {
+        try {
+            return await this.repository.findOneBy({ id } as any);
+        } catch (error) {
+            logger.error(`查找实体失败 (ID: ${id}):`, error as Error);
+            throw error;
+        }
+    }
+
+    async findAll(options?: FindManyOptions<T>): Promise<T[]> {
+        try {
+            return await this.repository.find(options);
+        } catch (error) {
+            logger.error('查找所有实体失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async findOne(options: FindOneOptions<T>): Promise<T | null> {
+        try {
+            return await this.repository.findOne(options);
+        } catch (error) {
+            logger.error('查找单个实体失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async findMany(options: FindManyOptions<T>): Promise<T[]> {
+        try {
+            return await this.repository.find(options);
+        } catch (error) {
+            logger.error('查找多个实体失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async save(entity: Partial<T>): Promise<T> {
+        try {
+            return await this.repository.save(entity as any);
+        } catch (error) {
+            logger.error('保存实体失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async saveMany(entities: Partial<T>[]): Promise<T[]> {
+        try {
+            return await this.repository.save(entities as any);
+        } catch (error) {
+            logger.error('批量保存实体失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async update(id: number, updateData: Partial<T>): Promise<UpdateResult> {
+        try {
+            return await this.repository.update(id, updateData as any);
+        } catch (error) {
+            logger.error(`更新实体失败 (ID: ${id}):`, error as Error);
+            throw error;
+        }
+    }
+
+    async delete(id: number): Promise<DeleteResult> {
+        try {
+            return await this.repository.delete(id);
+        } catch (error) {
+            logger.error(`删除实体失败 (ID: ${id}):`, error as Error);
+            throw error;
+        }
+    }
+
+    async softDelete(id: number): Promise<UpdateResult> {
+        try {
+            return await this.repository.softDelete(id);
+        } catch (error) {
+            logger.error(`软删除实体失败 (ID: ${id}):`, error as Error);
+            throw error;
+        }
+    }
+
+    async exists(id: number): Promise<boolean> {
+        try {
+            const count = await this.repository.count({ where: { id } as any });
+            return count > 0;
+        } catch (error) {
+            logger.error(`检查实体存在性失败 (ID: ${id}):`, error as Error);
+            throw error;
+        }
+    }
+
+    async count(options?: FindManyOptions<T>): Promise<number> {
+        try {
+            return await this.repository.count(options);
+        } catch (error) {
+            logger.error('统计实体数量失败:', error as Error);
+            throw error;
+        }
+    }
+
+    async findAndCount(options: FindManyOptions<T>): Promise<[T[], number]> {
+        try {
+            return await this.repository.findAndCount(options);
+        } catch (error) {
+            logger.error('分页查询失败:', error as Error);
+            throw error;
+        }
+    }
+}

package/template/src/repository/interfaces/IBaseRepository.ts

@@ -0,0 +1,67 @@
+import { EntityTarget, FindManyOptions, FindOneOptions, UpdateResult, DeleteResult } from 'typeorm';
+
+/**
+ * 基础Repository接口
+ * 定义通用的数据访问操作
+ */
+export interface IBaseRepository<T> {
+    /**
+     * 根据ID查找实体
+     */
+    findById(id: number): Promise<T | null>;
+
+    /**
+     * 查找所有实体
+     */
+    findAll(options?: FindManyOptions<T>): Promise<T[]>;
+
+    /**
+     * 根据条件查找单个实体
+     */
+    findOne(options: FindOneOptions<T>): Promise<T | null>;
+
+    /**
+     * 根据条件查找多个实体
+     */
+    findMany(options: FindManyOptions<T>): Promise<T[]>;
+
+    /**
+     * 保存实体
+     */
+    save(entity: Partial<T>): Promise<T>;
+
+    /**
+     * 批量保存实体
+     */
+    saveMany(entities: Partial<T>[]): Promise<T[]>;
+
+    /**
+     * 更新实体
+     */
+    update(id: number, updateData: Partial<T>): Promise<UpdateResult>;
+
+    /**
+     * 删除实体
+     */
+    delete(id: number): Promise<DeleteResult>;
+
+    /**
+     * 软删除实体
+     */
+    softDelete(id: number): Promise<UpdateResult>;
+
+    /**
+     * 检查实体是否存在
+     */
+    exists(id: number): Promise<boolean>;
+
+    /**
+     * 统计实体数量
+     */
+    count(options?: FindManyOptions<T>): Promise<number>;
+
+    /**
+     * 分页查询
+     */
+    findAndCount(options: FindManyOptions<T>): Promise<[T[], number]>;
+}

package/template/src/routers/index.ts

@@ -0,0 +1,49 @@
+// import { UserController } from "../controllers/user.controller";
+import { logger } from "@src/framework/utils/logger";
+import { bindRouter } from "@src/framework/utils/router";
+import tokenMiddleware from "@src/middlewares/token.middleware";
+import { EmailSendController } from "@src/controllers/public/emailSend.controller";
+import { YtUserRegisterController } from "@src/controllers/home/register.controller";
+import { YtUserAuthController } from "@src/controllers/public/ytUserAuth.controller";
+import { YtUserController } from "@src/controllers/home/ytUser.controller";
+import { YtShopController } from "@src/controllers/home/ytShop.controller";
+import { YtGoodsController } from "@src/controllers/home/ytGoods.controller";
+import { HealthController } from "@src/controllers/health.controller";
+import { CacheManagementController } from "@src/controllers/cacheManagement.controller";
+import { TestDataController } from "@src/controllers/testData.controller";
+import { ExampleController } from "@src/controllers/example/ExampleController";
+import { AnnotationDemoController } from "@src/controllers/demo/AnnotationDemoController";
+import { EnterpriseExampleController } from "@src/controllers/example/EnterpriseExampleController";
+import { LogManagementController } from "@src/controllers/logManagement.controller";
+
+
+export default () => {
+    // bindRouter("/a", tokenMiddleware(), aMiddleware(), UserController);
+    bindRouter("/home/user/yt_user", tokenMiddleware(), YtUserController);
+    bindRouter("/home/shop/common", YtShopController);
+    bindRouter("/home/goods/common", tokenMiddleware(), YtGoodsController);
+    bindRouter("/home/register/yt_user", YtUserRegisterController);
+    bindRouter("/home/register/yt_user", YtUserRegisterController);
+    bindRouter("/public/auth/yt_user", YtUserAuthController);
+    bindRouter("/public/email", EmailSendController);
+    
+    // 健康检查端点
+    bindRouter("/health", HealthController);
+    
+    // 缓存管理端点
+    bindRouter("/admin/cache", CacheManagementController);
+    
+    // 测试数据管理端点（仅在内存数据库模式下有效）
+    bindRouter("/test", TestDataController);
+
+
+    bindRouter("/example/", ExampleController);
+    bindRouter("/demo/", AnnotationDemoController);
+    bindRouter("/enterprise/", EnterpriseExampleController);
+    
+    // 日志管理端点
+    bindRouter("/admin/logs", tokenMiddleware(), LogManagementController);
+
+    
+    logger.info("路由绑定完成");
+}

package/template/src/service/base.service.ts

@@ -0,0 +1,116 @@
+import { Injectable } from "dp-ioc2";
+import { getDataSource } from "@src/framework/utils/db"
+import { ObjectLiteral, EntityTarget, Repository } from "typeorm"
+import { CommonServiceResultCode, CommonServiceResult } from "@src/framework/types/ServiceResult"
+
+@Injectable()
+export class BaseService {
+
+    /**
+     * 获取数据仓库
+     * 延迟初始化，避免在数据库未初始化时出错
+     */
+    getDataRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Repository<T> {
+        const dbDataSource = getDataSource();
+        if (!dbDataSource || !dbDataSource.isInitialized) {
+            throw new Error("数据库未初始化，请等待数据库初始化完成");
+        }
+        return dbDataSource.getRepository(entity);
+    }
+
+    /**
+     * 创建懒加载的 Repository Getter
+     * 通用方法，用于实例化自定义 Repository
+     * 
+     * @template T Repository 类型
+     * @template R Repository 构造函数类型
+     * @param entity 实体类型
+     * @param RepositoryClass Repository 类
+     * @param cache Map 缓存对象
+     * @returns Getter 函数
+     * 
+     * @example
+     * ```typescript
+     * export class YtUserService extends BaseService {
+     *     private repositoryCache = new Map<string, any>();
+     *     
+     *     private get userRepository(): IUserRepository {
+     *         return this.createLazyRepository(
+     *             YtUserEntity,
+     *             UserRepository,
+     *             this.repositoryCache
+     *         );
+     *     }
+     * }
+     * ```
+     */
+    protected createLazyRepository<T extends ObjectLiteral, R>(
+        entity: EntityTarget<T>,
+        RepositoryClass: new (repository: Repository<T>) => R,
+        cache: Map<string, R>
+    ): R {
+        // 使用 RepositoryClass 名称作为缓存键
+        const cacheKey = RepositoryClass.name;
+        
+        if (!cache.has(cacheKey)) {
+            const dataSource = getDataSource();
+            if (!dataSource || !dataSource.isInitialized) {
+                throw new Error("数据库未初始化，请等待数据库初始化完成");
+            }
+            
+            const repository = dataSource.getRepository(entity);
+            const instance = new RepositoryClass(repository);
+            cache.set(cacheKey, instance);
+        }
+        
+        return cache.get(cacheKey)!;
+    }
+
+    /**
+     * 获取数据库管理器
+     */
+    getDbManager() {
+        const dbDataSource = getDataSource();
+        if (!dbDataSource || !dbDataSource.isInitialized) {
+            throw new Error("数据库未初始化，请等待数据库初始化完成");
+        }
+        return dbDataSource.manager;
+    }
+
+    async add<T>(data: T): Promise<T> {
+        return await this.getDbManager().save(data);
+        // return {
+        //     code: CommonServiceResultCode.SUCCESS,
+        //     data: result,
+        // }
+    }
+
+    async getById<T extends ObjectLiteral>(
+        entity: EntityTarget<T>,
+        id: number
+    ): Promise<T | null> {
+        const repository: Repository<T> = this.getDataRepository(entity);
+        return await repository.findOneBy({ id } as any);
+        
+        // if (!result) {
+        //     return {
+        //         code: CommonServiceResultCode.NOT_FOUND,
+        //         data: null,
+        //         message: "数据不存在"
+        //     };
+        // }
+
+        // return {
+        //     code: CommonServiceResultCode.SUCCESS,
+        //     data: result
+        // };
+    }
+
+    /**
+     * 清理资源
+     * 在应用关闭时调用，防止内存泄漏
+     */
+    cleanup(): void {
+        // BaseService 本身不需要清理，子类可以重写此方法
+    }
+}

package/template/src/service/paramValidateTest.service.ts

@@ -0,0 +1,139 @@
+/**
+ * 参数校验测试 Service
+ * 用于测试 dp-ioc2 的 @ParamValidate 装饰器功能
+ */
+
+import { Injectable, ParamValidate, IOCValidationError } from "dp-ioc2";
+import { IsString, IsEmail, MinLength, IsNumber, Min, Max } from "class-validator";
+import { BaseService } from "@src/service/base.service";
+import { CommonServiceResult } from "@src/framework/types/ServiceResult";
+import { logger } from "@src/framework/utils/logger";
+import Joi from "joi";
+
+/**
+ * 测试 DTO - 创建用户
+ */
+export class CreateTestUserDto {
+    @IsString({ message: '用户名必须是字符串' })
+    @MinLength(3, { message: '用户名长度不能少于3个字符' })
+    name!: string;
+
+    @IsEmail({}, { message: '邮箱格式不正确' })
+    email!: string;
+
+    @IsNumber({}, { message: '年龄必须是数字' })
+    @Min(18, { message: '年龄不能小于18岁' })
+    @Max(100, { message: '年龄不能大于100岁' })
+    age!: number;
+}
+
+/**
+ * 测试 DTO - 更新用户
+ */
+export class UpdateTestUserDto {
+    @IsString({ message: '用户名必须是字符串' })
+    @MinLength(3, { message: '用户名长度不能少于3个字符' })
+    name?: string;
+
+    @IsEmail({}, { message: '邮箱格式不正确' })
+    email?: string;
+}
+
+/**
+ * 参数校验测试 Service
+ */
+@Injectable()
+export class ParamValidateTestService extends BaseService {
+    
+    /**
+     * 测试1：对象参数校验（使用 class-validator）
+     */
+    async createUser(@ParamValidate(CreateTestUserDto) dto: CreateTestUserDto): Promise<CommonServiceResult<{ id: number; name: string; email: string; age: number }>> {
+        try {
+            // 业务逻辑（校验已在方法调用前自动完成）
+            const user = {
+                id: Math.floor(Math.random() * 1000),
+                name: dto.name,
+                email: dto.email,
+                age: dto.age
+            };
+            
+            logger.info(`创建用户成功: ${user.name}`);
+            return CommonServiceResult.success(user, "用户创建成功");
+        } catch (error) {
+            if (error instanceof IOCValidationError) {
+                return CommonServiceResult.validationError<{ id: number; name: string; email: string; age: number }>(
+                    error.message || "参数校验失败",
+                    null
+                );
+            }
+            logger.error("创建用户失败:", error as Error);
+            return CommonServiceResult.error("创建用户失败");
+        }
+    }
+
+    /**
+     * 测试2：基本类型参数校验（使用 Joi）
+     */
+    async getUserById(@ParamValidate(undefined, Joi.number().integer().positive().required()) userId: number): Promise<CommonServiceResult<{ id: number; name: string }>> {
+        try {
+            // 业务逻辑
+            const user = {
+                id: userId,
+                name: `用户${userId}`
+            };
+            
+            return CommonServiceResult.success(user, "获取用户成功");
+        } catch (error) {
+            if (error instanceof IOCValidationError) {
+                return CommonServiceResult.validationError<{ id: number; name: string }>(
+                    error.message || "参数校验失败",
+                    null
+                );
+            }
+            logger.error("获取用户失败:", error as Error);
+            return CommonServiceResult.error("获取用户失败");
+        }
+    }
+
+    /**
+     * 测试3：混合参数校验（基本类型 + 对象）
+     */
+    async updateUser(
+        @ParamValidate(undefined, Joi.number().integer().positive().required()) userId: number,
+        @ParamValidate(UpdateTestUserDto) dto: UpdateTestUserDto
+    ): Promise<CommonServiceResult<{ id: number; name?: string; email?: string }>> {
+        try {
+            // 业务逻辑
+            const user = {
+                id: userId,
+                ...dto
+            };
+            
+            return CommonServiceResult.success(user, "更新用户成功");
+        } catch (error) {
+            if (error instanceof IOCValidationError) {
+                return CommonServiceResult.validationError<{ id: number; name?: string; email?: string }>(
+                    error.message || "参数校验失败",
+                    null
+                );
+            }
+            logger.error("更新用户失败:", error as Error);
+            return CommonServiceResult.error("更新用户失败");
+        }
+    }
+
+    /**
+     * 测试4：无校验参数（用于对比）
+     */
+    async getUserWithoutValidation(userId: number): Promise<CommonServiceResult<{ id: number; name: string }>> {
+        // 这个方法没有使用 @ParamValidate，用于对比测试
+        const user = {
+            id: userId,
+            name: `用户${userId}`
+        };
+        
+        return CommonServiceResult.success(user, "获取用户成功");
+    }
+}
+

package/template/src/service/ytGoods.service.ts

@@ -0,0 +1,42 @@
+import { BaseService } from "@src/service/base.service";
+import { CommonServiceResult, CommonServiceResultCode } from "@src/framework/types/ServiceResult";
+import { YtGoodsUnlockerEntity } from "@src/entity/goodsUnlocker.entity";
+import { GoodsImagesUnlockKeyEntity } from "@src/entity/goodsImagesUnlockKey.entity";
+
+export class YtGoodsService extends BaseService {
+    
+    
+    async unlockGoodsImage(goodsId: number, userId: number, key: string): Promise<CommonServiceResult<boolean>> {
+        // 验证解锁key
+        const keyRepo = this.getDataRepository(GoodsImagesUnlockKeyEntity);
+        const unlockKey = await keyRepo.findOneBy({ key });
+        
+        if (!unlockKey || unlockKey.isUse) {
+            return new CommonServiceResult(CommonServiceResultCode.FAIL, false, "无效的解锁key");
+        }
+        
+        // 标记key为已使用
+        unlockKey.isUse = true;
+        await keyRepo.save(unlockKey);
+        
+        // 创建解锁记录
+        const unlockRepo = this.getDataRepository(YtGoodsUnlockerEntity);
+        await unlockRepo.save({
+            goodsId,
+            ytUserId: userId
+        });
+        
+        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, true);
+    }
+
+    /**
+     * 根据ID获取商品（兼容旧接口）
+     */
+    async getById(entityClass: any, id: number): Promise<any> {
+        try {
+            return await this.getDataRepository(entityClass).findOne({ where: { id } });
+        } catch (error) {
+            return null;
+        }
+    }
+}

package/template/src/service/ytShop.service.ts

@@ -0,0 +1,90 @@
+import { YtGoodsEntity, YtGoodsStatusEnum } from "@src/entity/ytGoods.entity";
+import { BaseService } from "@src/service/base.service";
+import { CommonServiceResult, CommonServiceResultCode } from "@src/framework/types/ServiceResult";
+import { YtUserEntity } from "@src/entity/ytUser.entity";
+import { ShopAndUserEntity } from "@src/entity/shopUser.entity";
+
+export class YtShopService extends BaseService {
+
+
+    /**
+     * 获取店铺的商品列表
+     * @param shopId 
+     * @param page 
+     * @param pageSize 
+     * @returns 
+     */
+    async getGoodsListByShopId(
+        shopId: number,
+        page: number,
+        pageSize: number
+    ): Promise<CommonServiceResult<[YtGoodsEntity[], number]>> {
+        const ds = this.getDataRepository(YtGoodsEntity);
+        try {
+            const result = await ds.findAndCount({
+                where: { shopId, status: YtGoodsStatusEnum.NORMAL },
+                skip: (page - 1) * pageSize,
+                take: pageSize,
+                order: { id: "DESC" }
+            });
+            return new CommonServiceResult(CommonServiceResultCode.SUCCESS, result);
+        } catch (error) {
+            return new CommonServiceResult(CommonServiceResultCode.ERROR, [[], 0], "查询商品列表失败");
+        }
+    }
+
+
+    /**
+     * 读取店铺的用户基本信息
+     * @param shopId 
+     */
+    async getShopUserInfo(shopId: number): Promise<CommonServiceResult<YtUserEntity | null>> {
+
+        const relation = await this.getDataRepository(ShopAndUserEntity).findOne({
+            where: {
+                shopId,
+            }
+        });
+
+        if (!relation) {
+            return new CommonServiceResult(CommonServiceResultCode.FAIL, null, "店铺未绑定用户")
+        }
+
+
+
+        const user = await this.getDataRepository(YtUserEntity).findOne({
+            where: {
+                id: relation.userId,
+            }
+        })
+        if (!user) {
+            return new CommonServiceResult(CommonServiceResultCode.FAIL, null, "用户不存在");
+        }
+        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, user,);
+    }
+
+
+    /**
+     * 检测用户是否有店铺 如果有，则返回shop id
+     * @param userId 
+     */
+    async checkHasShop(userId: number): Promise<CommonServiceResult<number | null>> {
+        const result = await this.getDataRepository(ShopAndUserEntity).findOne({
+            where: {
+                userId,
+            }
+        })
+        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, result?.shopId || null);
+    }
+
+    /**
+     * 根据ID获取店铺（兼容旧接口）
+     */
+    async getById(entityClass: any, id: number): Promise<any> {
+        try {
+            return await this.getDataRepository(entityClass).findOne({ where: { id } });
+        } catch (error) {
+            return null;
+        }
+    }
+}