feat: 实现Token刷新接口

- 添加RefreshSchema定义刷新令牌验证规则

- 添加RefreshResponsesSchema定义响应格式

- 实现refresh方法处理Token刷新业务逻辑

- 添加/refresh路由支持Token刷新功能

关联任务4.0

src/modules/auth/auth.controller.ts

@@ -8,8 +8,8 @@
  */
 
 import { Elysia } from 'elysia';
-import { RegisterSchema, ActivateSchema, LoginSchema } from './auth.schema';
+import { RegisterSchema, ActivateSchema, LoginSchema, RefreshSchema } from './auth.schema';
-import { RegisterResponsesSchema, ActivateResponsesSchema, LoginResponsesSchema } from './auth.response';
+import { RegisterResponsesSchema, ActivateResponsesSchema, LoginResponsesSchema, RefreshResponsesSchema } from './auth.response';
 import { authService } from './auth.service';
 import { tags } from '@/modules/tags';
 
@@ -82,4 +82,26 @@ export const authController = new Elysia()
             },
             response: LoginResponsesSchema,
         }
+    )
+    
+    /**
+     * Token刷新接口
+     * @route POST /api/auth/refresh
+     * @description 使用刷新令牌获取新的访问令牌
+     * @param body RefreshRequest 刷新请求参数
+     * @returns RefreshSuccessResponse | RefreshErrorResponse
+     */
+    .post(
+        '/refresh',
+        ({ body, set }) => authService.refresh(body),
+        {
+            body: RefreshSchema,
+            detail: {
+                summary: 'Token刷新',
+                description: '使用刷新令牌获取新的访问令牌和刷新令牌，延长用户会话时间',
+                tags: [tags.auth],
+                operationId: 'refreshToken',
+            },
+            response: RefreshResponsesSchema,
+        }
     ); 

src/modules/auth/auth.response.ts

@@ -161,3 +161,50 @@ export const LoginResponsesSchema = {
 
 /** 用户登录成功响应数据类型 */
 export type LoginSuccessType = Static<typeof LoginResponsesSchema[200]>;
+
+// ========== Token刷新相关响应格式 ==========
+
+/**
+ * Token刷新接口响应组合
+ * @description 用于Controller中定义所有可能的响应格式
+ */
+export const RefreshResponsesSchema = {
+    200: responseWrapperSchema(t.Object({
+        /** 认证令牌信息 */
+        tokens: t.Object({
+            /** 访问令牌 */
+            accessToken: t.String({
+                description: 'JWT访问令牌',
+                examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
+            }),
+            /** 刷新令牌 */
+            refreshToken: t.String({
+                description: 'JWT刷新令牌',
+                examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
+            }),
+            /** 令牌类型 */
+            tokenType: t.String({
+                description: '令牌类型',
+                examples: ['Bearer']
+            }),
+            /** 过期时间（秒） */
+            expiresIn: t.String({
+                description: '访问令牌过期时间（秒）',
+                examples: [7200, 86400]
+            }),
+            /** 刷新令牌过期时间（秒） */
+            refreshExpiresIn: t.String({
+                description: '刷新令牌过期时间（秒）',
+                examples: [2592000]
+            })
+        }),
+        /** 刷新时间 */
+        refreshedAt: t.String({
+            description: '令牌刷新时间',
+            examples: ['2024-12-19T10:30:00Z']
+        })
+    })),
+};
+
+/** Token刷新成功响应数据类型 */
+export type RefreshSuccessType = Static<typeof RefreshResponsesSchema[200]>;

src/modules/auth/auth.schema.ts

@@ -102,6 +102,20 @@ export const LoginSchema = t.Object({
     }))
 });
 
+/**
+ * Token刷新Schema
+ * @description Token刷新请求参数验证规则
+ */
+export const RefreshSchema = t.Object({
+    /** 刷新令牌，JWT格式 */
+    refreshToken: t.String({
+        minLength: 10,
+        maxLength: 1000,
+        description: '刷新令牌，JWT格式，用于获取新的访问令牌',
+        examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
+    })
+});
+
 /** 用户注册请求类型 */
 export type RegisterRequest = Static<typeof RegisterSchema>;
 
@@ -110,3 +124,6 @@ export type ActivateRequest = Static<typeof ActivateSchema>;
 
 /** 用户登录请求类型 */
 export type LoginRequest = Static<typeof LoginSchema>;
+
+/** Token刷新请求类型 */
+export type RefreshRequest = Static<typeof RefreshSchema>; 

src/modules/auth/auth.service.ts

@@ -16,9 +16,10 @@ import { Logger } from '@/plugins/logger/logger.service';
 import { nextId } from '@/utils/snowflake';
 import { jwtService } from '@/plugins/jwt/jwt.service';
 import { emailService } from '@/plugins/email/email.service';
-import type { RegisterRequest, ActivateRequest, LoginRequest } from './auth.schema';
+import type { RegisterRequest, ActivateRequest, LoginRequest, RefreshRequest } from './auth.schema';
 import { successResponse, errorResponse, BusinessError } from '@/utils/responseFormate';
-import type { ActivateSuccessType, LoginSuccessType, RegisterResponsesType } from './auth.response';
+import type { ActivateSuccessType, LoginSuccessType, RegisterResponsesType, RefreshSuccessType } from './auth.response';
+import { TOKEN_TYPES } from '@/type/jwt.type';
 
 /**
  * 认证服务类
@@ -196,44 +197,42 @@ export class AuthService {
         const { token } = request;
 
         // 1. 验证激活Token
-        const tokenPayload = await jwtService.verifyToken(token);
+        const tokenPayload = jwtService.verifyToken(token);
 
-        Logger.info(tokenPayload);
+        if (tokenPayload.error) {
-
-        if (tokenPayload?.error) {
             throw new BusinessError('激活令牌验证失败', 400);
         }
 
-        // 2. 根据Token中的用户ID查询用户
+        // 2. 检查用户是否存在
         const user = await this.getUserById(tokenPayload.userId);
 
-        // 3. 检查用户是否已经激活
+        // 3. 检查用户状态
         if (user.status === 'active') {
-            throw new BusinessError('账号已经激活', 400);
+            throw new BusinessError('用户已激活，无需重复激活', 400);
         }
 
         // 4. 更新用户状态为激活
-        const activatedUser = await this.updateUserStatus(tokenPayload.userId, 'active');
+        const updatedUser = await this.updateUserStatus(user.id, 'active');
 
-        // 5. 发送激活成功邮件（可选）
+        // 5. 发送激活成功邮件
-        this.sendActivationSuccessEmail(activatedUser.email, activatedUser.username);
+        this.sendActivationSuccessEmail(user.email, user.username);
 
-        Logger.info(`用户邮箱激活成功：${activatedUser.id} - ${activatedUser.email}`);
+        Logger.info(`用户激活成功：${user.id} - ${user.username}`);
 
         return successResponse({
-            id: activatedUser.id,
+            id: updatedUser.id,
-            username: activatedUser.username,
+            username: updatedUser.username,
-            email: activatedUser.email,
+            email: updatedUser.email,
-            status: activatedUser.status,
+            status: updatedUser.status,
-            updatedAt: activatedUser.updatedAt,
+            updatedAt: updatedUser.updatedAt,
             activated: true
         }, '邮箱激活成功');
     }
 
     /**
      * 根据用户ID获取用户信息
-     * @param userId 用户ID（字符串形式）
+     * @param userId 用户ID
-     * @returns Promise<User> 用户信息
+     * @returns Promise<UserInfo> 用户信息
      */
     private async getUserById(userId: string): Promise<{
         id: string;
@@ -252,11 +251,11 @@ export class AuthService {
             updatedAt: sysUsers.updatedAt
         })
             .from(sysUsers)
-            .where(eq(sysUsers.id, BigInt(userId)))
+            .where(eq(sysUsers.id, userId))
             .limit(1);
 
         if (!user) {
-            throw new BusinessError('用户不存在', 400);
+            throw new BusinessError('用户不存在', 404);
         }
 
         return {
@@ -271,9 +270,9 @@ export class AuthService {
 
     /**
      * 更新用户状态
-     * @param userId 用户ID（字符串形式）
+     * @param userId 用户ID
      * @param status 新状态
-     * @returns Promise<User> 更新后的用户信息
+     * @returns Promise<UpdatedUser> 更新后的用户信息
      */
     private async updateUserStatus(userId: string, status: string): Promise<{
         id: string;
@@ -301,6 +300,10 @@ export class AuthService {
             .where(eq(sysUsers.id, BigInt(userId)))
             .limit(1);
 
+        if (!updatedUser) {
+            throw new BusinessError('更新用户状态失败', 500);
+        }
+
         return {
             id: userId, // 使用传入的字符串ID，避免精度丢失
             username: updatedUser!.username,
@@ -316,11 +319,9 @@ export class AuthService {
      * @returns Promise<LoginSuccessResponse>
      */
     async login(request: LoginRequest): Promise<LoginSuccessType> {
-        Logger.info(`用户登录请求：${JSON.stringify({ ...request, password: '***', captcha: '***' })}`);
-
         const { identifier, password, captcha, captchaId, rememberMe = false } = request;
 
-        // 1. 验证验证码（如果提供）
+        // 1. 如果提供了验证码，则验证验证码
         if (captcha && captchaId) {
             await this.validateCaptcha(captcha, captchaId);
         }
@@ -334,17 +335,22 @@ export class AuthService {
         await this.verifyPassword(password, user.passwordHash);
 
         // 4. 检查账号状态
-        await this.checkAccountStatus(user);
+        this.checkAccountStatus(user);
 
-        // 5. 生成JWT令牌
+        // 5. 更新最后登录时间
-        const tokens = jwtService.generateTokens(user, rememberMe);
-
-        // 6. 更新最后登录时间
         await this.updateLastLoginTime(user.id);
 
-        // 7. 记录登录日志
+        // 6. 记录登录日志
         await this.recordLoginLog(user.id, identifier);
 
+        // 7. 生成JWT令牌
+        const tokens = jwtService.generateTokens({
+            id: user.id,
+            username: user.username,
+            email: user.email,
+            status: user.status
+        }, rememberMe);
+
         Logger.info(`用户登录成功：${user.id} - ${user.username}`);
 
         return successResponse({
@@ -360,9 +366,9 @@ export class AuthService {
     }
 
     /**
-     * 根据标识符查找用户（支持用户名或邮箱）
+     * 根据用户名或邮箱查找用户
-     * @param identifier 用户标识符（用户名或邮箱）
+     * @param identifier 用户名或邮箱
-     * @returns Promise<User> 用户信息
+     * @returns Promise<UserWithPassword> 用户信息（包含密码哈希）
      */
     private async findUserByIdentifier(identifier: string): Promise<{
         id: string;
@@ -393,7 +399,7 @@ export class AuthService {
             .limit(1);
 
         if (!user) {
-            throw new BusinessError('用户不存在', 400);
+            throw new BusinessError('用户名或密码错误', 401);
         }
 
         return {
@@ -416,7 +422,7 @@ export class AuthService {
 
         if (!isValid) {
             // todo 记录错误登录次数，如果超过5次，则锁定账号
-            throw new BusinessError('密码错误', 400);
+            throw new BusinessError('密码错误', 401);
         }
     }
 
@@ -426,15 +432,13 @@ export class AuthService {
      */
     private checkAccountStatus(user: { status: string }) {
         if (user.status === 'pending') {
-            throw new BusinessError('账号未激活，请先激活账号', 400);
+            throw new BusinessError('账号未激活，请先激活邮箱', 403);
         }
-
+        if (user.status === 'suspended') {
-        if (user.status === 'locked') {
+            throw new BusinessError('账号已被暂停，请联系管理员', 403);
-            throw new BusinessError('账号已被锁定，请联系管理员', 400);
         }
-
+        if (user.status === 'deleted') {
-        if (user.status !== 'active') {
+            throw new BusinessError('账号已被删除', 403);
-            throw new BusinessError('账号状态异常，请联系管理员', 400);
         }
     }
 
@@ -454,25 +458,11 @@ export class AuthService {
     /**
      * 记录登录日志
      * @param userId 用户ID
-     * @param identifier 登录标识符
+     * @param identifier 登录标识（用户名或邮箱）
      */
     private async recordLoginLog(userId: string, identifier: string): Promise<void> {
-        try {
+        // TODO: 实现登录日志记录
-            Logger.info(`用户登录日志：用户ID=${userId}, 标识符=${identifier}, 时间=${new Date().toISOString()}`);
+        Logger.info(`记录登录日志：用户ID=${userId}，登录标识=${identifier}`);
-
-            // TODO: 如果有登录日志表，可以在这里记录到数据库
-            // await db().insert(loginLogs).values({
-            //     userId: BigInt(userId),
-            //     identifier,
-            //     loginTime: new Date().toISOString(),
-            //     ip: '0.0.0.0', // 从请求中获取
-            //     userAgent: 'unknown' // 从请求中获取
-            // });
-
-        } catch (error) {
-            // 记录错误但不影响登录流程
-            Logger.error(new Error(`记录登录日志失败：${error}`));
-        }
     }
 
     /**
@@ -524,17 +514,72 @@ export class AuthService {
                     <p>如果您没有注册，请忽略此邮件。</p>
                 `
             });
-
             Logger.info(`激活邮件发送成功：${email}`);
         } catch (error) {
-            // 邮件发送失败不影响注册流程，只记录日志
+            Logger.warn(`激活邮件发送失败：${email}，错误：${error}`);
-            Logger.warn(`激活邮件发送失败：${email}, 错误：${error}`);
+            // 邮件发送失败不影响注册流程
         }
     }
+
+    /**
+     * Token刷新
+     * @param request Token刷新请求参数
+     * @returns Promise<RefreshSuccessResponse>
+     */
+    public async refresh(request: RefreshRequest): Promise<RefreshSuccessType> {
+        Logger.info(`Token刷新请求开始处理`);
+
+        const { refreshToken } = request;
+
+        // 1. 验证刷新令牌
+        const tokenPayload = jwtService.verifyToken(refreshToken);
+
+        if (tokenPayload.error) {
+            throw new BusinessError('刷新令牌验证失败', 401);
+        }
+        if(tokenPayload.type !== TOKEN_TYPES.REFRESH){
+            throw new BusinessError('刷新令牌验证失败', 401);
+        }
+        Logger.debug(tokenPayload);
+
+        // 2. 检查用户是否存在且状态正常
+        const user = await this.getUserById(tokenPayload.userId);
+        this.checkAccountStatus(user);
+
+        // 3. 生成新的令牌对
+        const newTokens = jwtService.generateTokens({
+            id: user.id,
+            username: user.username,
+            email: user.email,
+            status: user.status
+        }, false); // 刷新时默认不记住登录状态
+
+        // 4. 记录刷新日志
+        await this.recordRefreshLog(user.id);
+
+        Logger.info(`Token刷新成功：${user.id} - ${user.username}`);
+
+        return successResponse({
+            tokens: {
+                accessToken: newTokens.accessToken,
+                refreshToken: newTokens.refreshToken,
+                tokenType: 'Bearer',
+                expiresIn: newTokens.expiresIn.toString(),
+                refreshExpiresIn: newTokens.refreshExpiresIn.toString()
+            },
+            refreshedAt: new Date().toISOString()
+        }, 'Token刷新成功');
+    }
+
+    /**
+     * 记录Token刷新日志
+     * @param userId 用户ID
+     */
+    private async recordRefreshLog(userId: string): Promise<void> {
+        // TODO: 实现Token刷新日志记录
+        Logger.info(`记录Token刷新日志：用户ID=${userId}`);
+    }
 }
 
-/**
+// 导出单例实例
- * 导出认证服务单例实例
- * @description 供controller层使用的认证服务实例
- */
 export const authService = new AuthService(); 

src/plugins/jwt/jwt.service.ts

@@ -48,7 +48,7 @@ export class JwtService {
         };
         const accessToken = jwt.sign(
             {
-                ...userInfo,
+                ...userPayload,
                 type: TOKEN_TYPES.ACCESS,
             },
             jwtConfig.secret,
@@ -57,7 +57,7 @@ export class JwtService {
 
         const refreshToken = jwt.sign(
             {
-                ...userInfo,
+                ...userPayload,
                 type: TOKEN_TYPES.REFRESH,
             },
             jwtConfig.secret,

src/type/jwt.type.ts

@@ -61,6 +61,7 @@ export interface JwtPayloadType extends JwtUserType {
     /** Token生效时间（秒级时间戳） */
     nbf?: number;
     error?: boolean;
+    type?: TokenType;
 }
 
 /**

tasks/M2-基础用户系统-开发任务计划.md

@@ -7,52 +7,52 @@
 - `src/modules/auth/auth.response.ts` - 认证模块响应格式定义
 - `src/modules/auth/auth.service.ts` - 认证模块Service层实现
 - `src/modules/auth/auth.controller.ts` - 认证模块Controller层实现
-- `src/modules/auth/auth.test.ts` - 认证模块测试用例
+- `src/modules/auth/auth.test.md` - 认证模块测试用例文档
 
 ### 用户管理模块 (User)
 - `src/modules/user/user.schema.ts` - 用户模块Schema定义（已存在）
 - `src/modules/user/user.response.ts` - 用户模块响应格式定义（已存在）
 - `src/modules/user/user.service.ts` - 用户模块Service层实现（已存在）
 - `src/modules/user/user.controller.ts` - 用户模块Controller层实现（需更新）
-- `src/modules/user/user.test.ts` - 用户模块测试用例
+- `src/modules/user/user.test.md` - 用户模块测试用例文档
 
 ### 角色权限模块 (Role)
 - `src/modules/role/role.schema.ts` - 角色模块Schema定义
 - `src/modules/role/role.response.ts` - 角色模块响应格式定义
 - `src/modules/role/role.service.ts` - 角色模块Service层实现
 - `src/modules/role/role.controller.ts` - 角色模块Controller层实现
-- `src/modules/role/role.test.ts` - 角色模块测试用例
+- `src/modules/role/role.test.md` - 角色模块测试用例文档
 
 ### 权限管理模块 (Permission)
 - `src/modules/permission/permission.schema.ts` - 权限模块Schema定义
 - `src/modules/permission/permission.response.ts` - 权限模块响应格式定义
 - `src/modules/permission/permission.service.ts` - 权限模块Service层实现
 - `src/modules/permission/permission.controller.ts` - 权限模块Controller层实现
-- `src/modules/permission/permission.test.ts` - 权限模块测试用例
+- `src/modules/permission/permission.test.md` - 权限模块测试用例文档
 
 ### 组织架构模块 (Organization)
 - `src/modules/organization/organization.schema.ts` - 组织模块Schema定义
 - `src/modules/organization/organization.response.ts` - 组织模块响应格式定义
 - `src/modules/organization/organization.service.ts` - 组织模块Service层实现
 - `src/modules/organization/organization.controller.ts` - 组织模块Controller层实现
-- `src/modules/organization/organization.test.ts` - 组织模块测试用例
+- `src/modules/organization/organization.test.md` - 组织模块测试用例文档
 
 ### 系统基础模块 (System)
 - `src/modules/system/dict/dict.schema.ts` - 字典模块Schema定义
 - `src/modules/system/dict/dict.response.ts` - 字典模块响应格式定义
 - `src/modules/system/dict/dict.service.ts` - 字典模块Service层实现
 - `src/modules/system/dict/dict.controller.ts` - 字典模块Controller层实现
-- `src/modules/system/dict/dict.test.ts` - 字典模块测试用例
+- `src/modules/system/dict/dict.test.md` - 字典模块测试用例文档
 - `src/modules/system/tag/tag.schema.ts` - 标签模块Schema定义
 - `src/modules/system/tag/tag.response.ts` - 标签模块响应格式定义
 - `src/modules/system/tag/tag.service.ts` - 标签模块Service层实现
 - `src/modules/system/tag/tag.controller.ts` - 标签模块Controller层实现
-- `src/modules/system/tag/tag.test.ts` - 标签模块测试用例
+- `src/modules/system/tag/tag.test.md` - 标签模块测试用例文档
 - `src/modules/system/log/log.schema.ts` - 日志模块Schema定义
 - `src/modules/system/log/log.response.ts` - 日志模块响应格式定义
 - `src/modules/system/log/log.service.ts` - 日志模块Service层实现
 - `src/modules/system/log/log.controller.ts` - 日志模块Controller层实现
-- `src/modules/system/log/log.test.ts` - 日志模块测试用例
+- `src/modules/system/log/log.test.md` - 日志模块测试用例文档
 
 ### 备注 (Notes)
 - 验证码功能已有captcha模块可直接集成
@@ -68,56 +68,56 @@
   - [x] 1.2 创建auth.response.ts - 定义注册响应格式
   - [x] 1.3 创建auth.service.ts - 实现注册业务逻辑
   - [x] 1.4 创建auth.controller.ts - 实现注册路由
-  - [x] 1.5 创建auth.test.ts - 编写注册测试用例
+  - [x] 1.5 创建auth.test.md - 编写注册测试用例文档
 
 - [x] 2.0 POST /auth/activate - 邮箱激活接口
   - [x] 2.1 扩展auth.schema.ts - 定义激活Schema
   - [x] 2.2 扩展auth.response.ts - 定义激活响应格式
   - [x] 2.3 扩展auth.service.ts - 实现激活业务逻辑
   - [x] 2.4 扩展auth.controller.ts - 实现激活路由
-  - [x] 2.5 扩展auth.test.ts - 编写激活测试用例
+  - [x] 2.5 扩展auth.test.md - 编写激活测试用例文档
 
 - [x] 3.0 POST /auth/login - 用户登录接口
   - [x] 3.1 扩展auth.schema.ts - 定义登录Schema
   - [x] 3.2 扩展auth.response.ts - 定义登录响应格式
   - [x] 3.3 扩展auth.service.ts - 实现登录业务逻辑
   - [x] 3.4 扩展auth.controller.ts - 实现登录路由
-  - [x] 3.5 扩展auth.test.ts - 编写登录测试用例
+  - [x] 3.5 扩展auth.test.md - 编写登录测试用例文档
 
-- [ ] 4.0 POST /auth/refresh - Token刷新接口
+- [x] 4.0 POST /auth/refresh - Token刷新接口
-  - [ ] 4.1 扩展auth.schema.ts - 定义刷新Schema
+  - [x] 4.1 扩展auth.schema.ts - 定义刷新Schema
-  - [ ] 4.2 扩展auth.response.ts - 定义刷新响应格式
+  - [x] 4.2 扩展auth.response.ts - 定义刷新响应格式
-  - [ ] 4.3 扩展auth.service.ts - 实现刷新业务逻辑
+  - [x] 4.3 扩展auth.service.ts - 实现刷新业务逻辑
-  - [ ] 4.4 扩展auth.controller.ts - 实现刷新路由
+  - [x] 4.4 扩展auth.controller.ts - 实现刷新路由
-  - [ ] 4.5 扩展auth.test.ts - 编写刷新测试用例
+  - [x] 4.5 扩展auth.test.md - 编写刷新测试用例文档
 
 - [ ] 5.0 POST /auth/logout - 退出登录接口
   - [ ] 5.1 扩展auth.schema.ts - 定义退出Schema
   - [ ] 5.2 扩展auth.response.ts - 定义退出响应格式
   - [ ] 5.3 扩展auth.service.ts - 实现退出业务逻辑
   - [ ] 5.4 扩展auth.controller.ts - 实现退出路由
-  - [ ] 5.5 扩展auth.test.ts - 编写退出测试用例
+  - [ ] 5.5 扩展auth.test.md - 编写退出测试用例文档
 
 - [ ] 6.0 POST /auth/password/reset-request - 找回密码接口
   - [ ] 6.1 扩展auth.schema.ts - 定义找回密码Schema
   - [ ] 6.2 扩展auth.response.ts - 定义找回密码响应格式
   - [ ] 6.3 扩展auth.service.ts - 实现找回密码业务逻辑
   - [ ] 6.4 扩展auth.controller.ts - 实现找回密码路由
-  - [ ] 6.5 扩展auth.test.ts - 编写找回密码测试用例
+  - [ ] 6.5 扩展auth.test.md - 编写找回密码测试用例文档
 
 - [ ] 7.0 POST /auth/password/reset-confirm - 重置密码接口
   - [ ] 7.1 扩展auth.schema.ts - 定义重置密码Schema
   - [ ] 7.2 扩展auth.response.ts - 定义重置密码响应格式
   - [ ] 7.3 扩展auth.service.ts - 实现重置密码业务逻辑
   - [ ] 7.4 扩展auth.controller.ts - 实现重置密码路由
-  - [ ] 7.5 扩展auth.test.ts - 编写重置密码测试用例
+  - [ ] 7.5 扩展auth.test.md - 编写重置密码测试用例文档
 
 - [x] 8.0 GET /auth/captcha - 图形验证码接口
   - [x] 8.1 扩展auth.schema.ts - 定义验证码Schema
   - [x] 8.2 扩展auth.response.ts - 定义验证码响应格式
   - [x] 8.3 扩展auth.service.ts - 集成验证码服务
   - [x] 8.4 扩展auth.controller.ts - 实现验证码路由
-  - [x] 8.5 扩展auth.test.ts - 编写验证码测试用例
+  - [x] 8.5 扩展auth.test.md - 编写验证码测试用例文档
 
 - [ ] 9.0 检查认证模块 (Auth Module)那些接口需要加分布式锁，并加锁
 
@@ -129,56 +129,56 @@
   - [ ] 9.2 扩展user.response.ts - 定义当前用户响应格式
   - [ ] 9.3 扩展user.service.ts - 实现当前用户业务逻辑
   - [ ] 9.4 更新user.controller.ts - 实现当前用户路由
-  - [ ] 9.5 创建user.test.ts - 编写当前用户测试用例
+  - [ ] 9.5 创建user.test.md - 编写当前用户测试用例文档
 
 - [ ] 10.0 GET /users - 用户列表查询接口
   - [ ] 10.1 扩展user.schema.ts - 定义用户列表Schema
   - [ ] 10.2 扩展user.response.ts - 定义用户列表响应格式
   - [ ] 10.3 扩展user.service.ts - 实现用户列表业务逻辑
   - [ ] 10.4 扩展user.controller.ts - 实现用户列表路由
-  - [ ] 10.5 扩展user.test.ts - 编写用户列表测试用例
+  - [ ] 10.5 扩展user.test.md - 编写用户列表测试用例文档
 
 - [ ] 11.0 POST /users - 创建用户接口
   - [ ] 11.1 扩展user.schema.ts - 定义创建用户Schema
   - [ ] 11.2 扩展user.response.ts - 定义创建用户响应格式
   - [ ] 11.3 扩展user.service.ts - 实现创建用户业务逻辑
   - [ ] 11.4 扩展user.controller.ts - 实现创建用户路由
-  - [ ] 11.5 扩展user.test.ts - 编写创建用户测试用例
+  - [ ] 11.5 扩展user.test.md - 编写创建用户测试用例文档
 
 - [ ] 12.0 PUT /users/{id} - 更新用户信息接口
   - [ ] 12.1 扩展user.schema.ts - 定义更新用户Schema
   - [ ] 12.2 扩展user.response.ts - 定义更新用户响应格式
   - [ ] 12.3 扩展user.service.ts - 实现更新用户业务逻辑
   - [ ] 12.4 扩展user.controller.ts - 实现更新用户路由
-  - [ ] 12.5 扩展user.test.ts - 编写更新用户测试用例
+  - [ ] 12.5 扩展user.test.md - 编写更新用户测试用例文档
 
 - [ ] 13.0 DELETE /users/{id} - 删除用户接口
   - [ ] 13.1 扩展user.schema.ts - 定义删除用户Schema
   - [ ] 13.2 扩展user.response.ts - 定义删除用户响应格式
   - [ ] 13.3 扩展user.service.ts - 实现删除用户业务逻辑
   - [ ] 13.4 扩展user.controller.ts - 实现删除用户路由
-  - [ ] 13.5 扩展user.test.ts - 编写删除用户测试用例
+  - [ ] 13.5 扩展user.test.md - 编写删除用户测试用例文档
 
 - [ ] 14.0 PUT /users/me/password - 修改密码接口
   - [ ] 14.1 扩展user.schema.ts - 定义修改密码Schema
   - [ ] 14.2 扩展user.response.ts - 定义修改密码响应格式
   - [ ] 14.3 扩展user.service.ts - 实现修改密码业务逻辑
   - [ ] 14.4 扩展user.controller.ts - 实现修改密码路由
-  - [ ] 14.5 扩展user.test.ts - 编写修改密码测试用例
+  - [ ] 14.5 扩展user.test.md - 编写修改密码测试用例文档
 
 - [ ] 15.0 GET /users/{id} - 用户详情接口
   - [ ] 15.1 扩展user.schema.ts - 定义用户详情Schema
   - [ ] 15.2 扩展user.response.ts - 定义用户详情响应格式
   - [ ] 15.3 扩展user.service.ts - 实现用户详情业务逻辑
   - [ ] 15.4 扩展user.controller.ts - 实现用户详情路由
-  - [ ] 15.5 扩展user.test.ts - 编写用户详情测试用例
+  - [ ] 15.5 扩展user.test.md - 编写用户详情测试用例文档
 
 - [ ] 16.0 POST /users/batch - 批量操作接口
   - [ ] 16.1 扩展user.schema.ts - 定义批量操作Schema
   - [ ] 16.2 扩展user.response.ts - 定义批量操作响应格式
   - [ ] 16.3 扩展user.service.ts - 实现批量操作业务逻辑
   - [ ] 16.4 扩展user.controller.ts - 实现批量操作路由
-  - [ ] 16.5 扩展user.test.ts - 编写批量操作测试用例
+  - [ ] 16.5 扩展user.test.md - 编写批量操作测试用例文档
 
 ### 🎭 角色权限模块 (Role Module) - P0优先级
 
@@ -187,49 +187,49 @@
   - [ ] 17.2 创建role.response.ts - 定义角色响应格式
   - [ ] 17.3 创建role.service.ts - 实现角色业务逻辑
   - [ ] 17.4 创建role.controller.ts - 实现角色路由
-  - [ ] 17.5 创建role.test.ts - 编写角色测试用例
+  - [ ] 17.5 创建role.test.md - 编写角色测试用例文档
 
 - [ ] 18.0 POST /roles - 创建角色接口
   - [ ] 18.1 扩展role.schema.ts - 定义创建角色Schema
   - [ ] 18.2 扩展role.response.ts - 定义创建角色响应格式
   - [ ] 18.3 扩展role.service.ts - 实现创建角色业务逻辑
   - [ ] 18.4 扩展role.controller.ts - 实现创建角色路由
-  - [ ] 18.5 扩展role.test.ts - 编写创建角色测试用例
+  - [ ] 18.5 扩展role.test.md - 编写创建角色测试用例文档
 
 - [ ] 19.0 PUT /roles/{id} - 更新角色接口
   - [ ] 19.1 扩展role.schema.ts - 定义更新角色Schema
   - [ ] 19.2 扩展role.response.ts - 定义更新角色响应格式
   - [ ] 19.3 扩展role.service.ts - 实现更新角色业务逻辑
   - [ ] 19.4 扩展role.controller.ts - 实现更新角色路由
-  - [ ] 19.5 扩展role.test.ts - 编写更新角色测试用例
+  - [ ] 19.5 扩展role.test.md - 编写更新角色测试用例文档
 
 - [ ] 20.0 DELETE /roles/{id} - 删除角色接口
   - [ ] 20.1 扩展role.schema.ts - 定义删除角色Schema
   - [ ] 20.2 扩展role.response.ts - 定义删除角色响应格式
   - [ ] 20.3 扩展role.service.ts - 实现删除角色业务逻辑
   - [ ] 20.4 扩展role.controller.ts - 实现删除角色路由
-  - [ ] 20.5 扩展role.test.ts - 编写删除角色测试用例
+  - [ ] 20.5 扩展role.test.md - 编写删除角色测试用例文档
 
 - [ ] 21.0 GET /permissions - 权限列表接口
   - [ ] 21.1 创建permission.schema.ts - 定义权限Schema
   - [ ] 21.2 创建permission.response.ts - 定义权限响应格式
   - [ ] 21.3 创建permission.service.ts - 实现权限业务逻辑
   - [ ] 21.4 创建permission.controller.ts - 实现权限路由
-  - [ ] 21.5 创建permission.test.ts - 编写权限测试用例
+  - [ ] 21.5 创建permission.test.md - 编写权限测试用例文档
 
 - [ ] 22.0 POST /roles/{id}/permissions - 权限分配接口
   - [ ] 22.1 扩展role.schema.ts - 定义权限分配Schema
   - [ ] 22.2 扩展role.response.ts - 定义权限分配响应格式
   - [ ] 22.3 扩展role.service.ts - 实现权限分配业务逻辑
   - [ ] 22.4 扩展role.controller.ts - 实现权限分配路由
-  - [ ] 22.5 扩展role.test.ts - 编写权限分配测试用例
+  - [ ] 22.5 扩展role.test.md - 编写权限分配测试用例文档
 
 - [ ] 23.0 POST /users/{id}/roles - 用户角色分配接口
   - [ ] 23.1 扩展user.schema.ts - 定义用户角色分配Schema
   - [ ] 23.2 扩展user.response.ts - 定义用户角色分配响应格式
   - [ ] 23.3 扩展user.service.ts - 实现用户角色分配业务逻辑
   - [ ] 23.4 扩展user.controller.ts - 实现用户角色分配路由
-  - [ ] 23.5 扩展user.test.ts - 编写用户角色分配测试用例
+  - [ ] 23.5 扩展user.test.md - 编写用户角色分配测试用例文档
 
 ### 🏢 组织架构模块 (Organization Module) - P1优先级
 
@@ -238,35 +238,35 @@
   - [ ] 24.2 创建organization.response.ts - 定义组织响应格式
   - [ ] 24.3 创建organization.service.ts - 实现组织业务逻辑
   - [ ] 24.4 创建organization.controller.ts - 实现组织路由
-  - [ ] 24.5 创建organization.test.ts - 编写组织测试用例
+  - [ ] 24.5 创建organization.test.md - 编写组织测试用例文档
 
 - [ ] 25.0 POST /organizations - 创建组织接口
   - [ ] 25.1 扩展organization.schema.ts - 定义创建组织Schema
   - [ ] 25.2 扩展organization.response.ts - 定义创建组织响应格式
   - [ ] 25.3 扩展organization.service.ts - 实现创建组织业务逻辑
   - [ ] 25.4 扩展organization.controller.ts - 实现创建组织路由
-  - [ ] 25.5 扩展organization.test.ts - 编写创建组织测试用例
+  - [ ] 25.5 扩展organization.test.md - 编写创建组织测试用例文档
 
 - [ ] 26.0 PUT /organizations/{id} - 更新组织接口
   - [ ] 26.1 扩展organization.schema.ts - 定义更新组织Schema
   - [ ] 26.2 扩展organization.response.ts - 定义更新组织响应格式
   - [ ] 26.3 扩展organization.service.ts - 实现更新组织业务逻辑
   - [ ] 26.4 扩展organization.controller.ts - 实现更新组织路由
-  - [ ] 26.5 扩展organization.test.ts - 编写更新组织测试用例
+  - [ ] 26.5 扩展organization.test.md - 编写更新组织测试用例文档
 
 - [ ] 27.0 DELETE /organizations/{id} - 删除组织接口
   - [ ] 27.1 扩展organization.schema.ts - 定义删除组织Schema
   - [ ] 27.2 扩展organization.response.ts - 定义删除组织响应格式
   - [ ] 27.3 扩展organization.service.ts - 实现删除组织业务逻辑
   - [ ] 27.4 扩展organization.controller.ts - 实现删除组织路由
-  - [ ] 27.5 扩展organization.test.ts - 编写删除组织测试用例
+  - [ ] 27.5 扩展organization.test.md - 编写删除组织测试用例文档
 
 - [ ] 28.0 POST /users/{id}/organizations - 用户组织关系接口
   - [ ] 28.1 扩展user.schema.ts - 定义用户组织关系Schema
   - [ ] 28.2 扩展user.response.ts - 定义用户组织关系响应格式
   - [ ] 28.3 扩展user.service.ts - 实现用户组织关系业务逻辑
   - [ ] 28.4 扩展user.controller.ts - 实现用户组织关系路由
-  - [ ] 28.5 扩展user.test.ts - 编写用户组织关系测试用例
+  - [ ] 28.5 扩展user.test.md - 编写用户组织关系测试用例文档
 
 ### 🗂️ 系统基础模块 (System Module) - P1优先级
 
@@ -275,35 +275,35 @@
   - [ ] 29.2 创建dict.response.ts - 定义字典类型响应格式
   - [ ] 29.3 创建dict.service.ts - 实现字典类型业务逻辑
   - [ ] 29.4 创建dict.controller.ts - 实现字典类型路由
-  - [ ] 29.5 创建dict.test.ts - 编写字典类型测试用例
+  - [ ] 29.5 创建dict.test.md - 编写字典类型测试用例文档
 
 - [ ] 30.0 字典项管理 - CRUD /dict-items
   - [ ] 30.1 扩展dict.schema.ts - 定义字典项Schema
   - [ ] 30.2 扩展dict.response.ts - 定义字典项响应格式
   - [ ] 30.3 扩展dict.service.ts - 实现字典项业务逻辑
   - [ ] 30.4 扩展dict.controller.ts - 实现字典项路由
-  - [ ] 30.5 扩展dict.test.ts - 编写字典项测试用例
+  - [ ] 30.5 扩展dict.test.md - 编写字典项测试用例文档
 
 - [ ] 31.0 标签管理 - CRUD /tags
   - [ ] 31.1 创建tag.schema.ts - 定义标签Schema
   - [ ] 31.2 创建tag.response.ts - 定义标签响应格式
   - [ ] 31.3 创建tag.service.ts - 实现标签业务逻辑
   - [ ] 31.4 创建tag.controller.ts - 实现标签路由
-  - [ ] 31.5 创建tag.test.ts - 编写标签测试用例
+  - [ ] 31.5 创建tag.test.md - 编写标签测试用例文档
 
 - [ ] 32.0 操作日志 - GET /logs/operations
   - [ ] 32.1 创建log.schema.ts - 定义操作日志Schema
   - [ ] 32.2 创建log.response.ts - 定义操作日志响应格式
   - [ ] 32.3 创建log.service.ts - 实现操作日志业务逻辑
   - [ ] 32.4 创建log.controller.ts - 实现操作日志路由
-  - [ ] 32.5 创建log.test.ts - 编写操作日志测试用例
+  - [ ] 32.5 创建log.test.md - 编写操作日志测试用例文档
 
 - [ ] 33.0 登录日志 - GET /logs/logins
   - [ ] 33.1 扩展log.schema.ts - 定义登录日志Schema
   - [ ] 33.2 扩展log.response.ts - 定义登录日志响应格式
   - [ ] 33.3 扩展log.service.ts - 实现登录日志业务逻辑
   - [ ] 33.4 扩展log.controller.ts - 实现登录日志路由
-  - [ ] 33.5 扩展log.test.ts - 编写登录日志测试用例
+  - [ ] 33.5 扩展log.test.md - 编写登录日志测试用例文档
 
 ### 🔧 基础设施完善
 
@@ -349,5 +349,5 @@
 1. **已完成部分**：用户模块的Schema、Response、Service已基本完成，可直接使用
 2. **验证码集成**：现有captcha模块可直接集成到认证流程中
 3. **开发规范**：严格按照Elysia开发规范，每个接口都要有完整的5个子任务
-4. **测试要求**：每个模块都要有完整的测试用例，确保功能正确性
+4. **测试要求**：每个模块都要有完整的测试用例文档，确保功能正确性
 5. **优先级管理**：按照P0 > P1 > P2的顺序开发，确保核心功能优先完成