feat(dict): 完成字典模块创建字典项接口的Schema、响应、Service、Controller及相关文档,实现参数校验、唯一性校验、层级处理、数据库写入和统一响应。修复drizzle-orm类型兼容问题,调整Schema与Service参数处理逻辑,支持雪花ID生成。

This commit is contained in:
HeXiaoLong:Suanier 2025-07-07 18:32:31 +08:00
parent 863b376020
commit f9f75c9d2d
99 changed files with 18798 additions and 15672 deletions

View File

@ -1,5 +1,5 @@
---
description: "全局规则"
description: "生成产品需求文档 (PRD)"
globs: ["**/*"]
alwaysApply: true
---

View File

@ -1,5 +1,5 @@
---
description: "全局规则"
description: "从PRD生成任务清单"
globs: ["**/*"]
alwaysApply: true
---

View File

@ -1,3 +1,9 @@
---
description: "ElysiaAPI开发流程"
globs: ["**/*"]
alwaysApply: true
---
# ElysiaAPI开发流程
## 0. 概览

View File

@ -1,5 +1,5 @@
---
description: "全局规则"
description: "任务执行流程"
globs: ["**/*"]
alwaysApply: true
---
@ -44,3 +44,41 @@ alwaysApply: true
8. 完成一个子任务后提交git
9. 将已完成的任务归档到tasks的归档目录archive并修改文件名文件名前添加时间
10. 将需求prd也归档
重要的事情说三遍
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**
**每一个子任务执行完暂停,等待我确认,不要再连续执行接下来的任务**

75
.env Normal file
View File

@ -0,0 +1,75 @@
# ==============================================
# 项目环境变量配置文件
# ==============================================
# ==============================================
# 应用配置
# ==============================================
NODE_ENV=development
# ==============================================
# MySQL数据库配置
# ==============================================
# 基本连接配置
DB_HOST=uair.cc
DB_PORT=3306
DB_USER=nie
DB_PASSWORD=nie
DB_NAME=nie
# 连接池配置
DB_CONNECTION_LIMIT=10
DB_QUEUE_LIMIT=0
DB_ACQUIRE_TIMEOUT=60000
DB_TIMEOUT=60000
# ==============================================
# Redis配置
# ==============================================
REDIS_CONNECT_NAME=cursor-init-redis
REDIS_HOST=uair.cc
REDIS_PORT=6379
REDIS_USERNAME=default
REDIS_PASSWORD=nie
REDIS_DATABASE=0
# ==============================================
# JWT认证配置
# ==============================================
JWT_SECRET=your_jwt_secret_change_this_in_production
# ==============================================
# 日志配置
# ==============================================
LOG_LEVEL=debug
LOG_MAX_FILES=30d
LOG_MAX_SIZE=70k
LOG_DIRECTORY=logs
LOG_CONSOLE=true
# ====================
# 邮件服务配置
# ====================
# SMTP服务器配置
SMTP_USER=togy.gc@qq.com
SMTP_PASS=qyafspjzahydddaa
SMTP_FROM_EMAIL=togy.gc@qq.com # 必须与SMTP_USER一致
SMTP_FROM_NAME=星撰玉衡
# SMTP连接超时配置毫秒
SMTP_TIMEOUT=60000
SMTP_GREETING_TIMEOUT=30000
SMTP_SOCKET_TIMEOUT=60000
# 邮件基础配置
EMAIL_FROM=星撰玉衡
EMAIL_REPLY_TO=togy.gc@qq.com
# 邮件发送选项配置
EMAIL_RETRY_ATTEMPTS=3
EMAIL_RETRY_DELAY=5000
EMAIL_ENABLE_QUEUE=false
EMAIL_MAX_RECIPIENTS=50
EMAIL_RATE_LIMIT=100

1
.gitignore vendored
View File

@ -1,5 +1,4 @@
node_modules/
dist/
.env
bun.lockb
/logs

View File

@ -119,6 +119,7 @@ src/plugins/
```
### 1.4 类型定义 (type/)
```
src/type/
├── config.type.ts # 配置相关类型
@ -131,6 +132,7 @@ src/type/
```
### 1.5 工具函数 (utils/)
```
src/utils/
├── deviceInfo.ts # 设备信息工具
@ -148,11 +150,13 @@ src/utils/
```
### 1.6 常量定义 (constants/)
```
src/constants/
├── swaggerTags.ts # Swagger标签定义所有模块的tag应该集中在此定义
└── 其他常量
```
### 1.7 数据库实体
```
@ -163,6 +167,7 @@ src/eneities/
```
### 1.8 文件命名约定
- 模块名使用 **单数形式**`auth`、`user`、`product`、`order`
- 文件名格式:`[module].[type].ts`
- 导出名格式:`[module][类型名]`
@ -182,11 +187,12 @@ src/eneities/
- 注意已经存在的工具函数,比如分页有现成的简化工具,且能够统一请求格式
### 2.2 特别注意点
**必须遵循的命名模式:**
- Request类型`[动作][模块]Request` → `RegisterRequest`
- Schema名`[动作][模块]Schema` → `RegisterSchema`
### 2.3 代码示例
```ts
@ -206,38 +212,37 @@ import { createQuerySchema } from '@/utils/pagination';
* 用户列表查询参数Schema
* @description 用户列表查询的请求参数验证规则
*/
export const UserListQuerySchema = createQuerySchema(t.Object({
export const UserListQuerySchema = createQuerySchema(
t.Object({
// 用户特有参数
keyword: t.Optional(t.String({
keyword: t.Optional(
t.String({
minLength: 1,
maxLength: 100,
description: '搜索关键词,支持用户名、邮箱模糊搜索',
examples: ['admin', 'test@example.com']
})),
status: t.Optional(t.Union([
t.Literal('active'),
t.Literal('inactive'),
t.Literal('pending')
], {
examples: ['admin', 'test@example.com'],
}),
),
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive'), t.Literal('pending')], {
description: '用户状态筛选',
examples: ['active', 'inactive', 'pending']
})),
gender: t.Optional(t.Union([
t.Literal(0),
t.Literal(1),
t.Literal(2),
t.Literal('0'),
t.Literal('1'),
t.Literal('2'),
], {
examples: ['active', 'inactive', 'pending'],
}),
),
gender: t.Optional(
t.Union([t.Literal(0), t.Literal(1), t.Literal(2), t.Literal('0'), t.Literal('1'), t.Literal('2')], {
description: '性别筛选0-未知1-男2-女',
examples: [0, 1, 2]
})),
isRoot: t.Optional(t.Boolean({
examples: [0, 1, 2],
}),
),
isRoot: t.Optional(
t.Boolean({
description: '是否超级管理员筛选',
examples: [true, false]
}))
}));
examples: [true, false],
}),
),
}),
);
/** 用户列表查询参数类型 */
export type UserListQueryRequest = Static<typeof UserListQuerySchema>;
@ -251,9 +256,10 @@ export type UserListQueryRequest = Static<typeof UserListQuerySchema>;
- 错误相应只提供示例和描述
- 导出响应成功类型
### 3.2 特别注意点
**必须遵循的命名模式:**
- Response格式定义`[动作][模块]Response` → `RegisterResponse`
- Response成功类型`[动作][模块]SuccessType ` → `RegisterSuccessType `
@ -273,8 +279,6 @@ import { t, type Static } from 'elysia';
import { responseWrapperSchema } from '@/utils/responseFormate';
import { createPaginationResponseSchema } from '@/utils/pagination';
/**
* 用户列表项Schema
* @description 用户列表中单个用户的数据结构
@ -283,12 +287,12 @@ export const UserListItemSchema = t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 更多字段... */
@ -296,8 +300,8 @@ export const UserListItemSchema = t.Object({
/** 更新时间 */
updatedAt: t.String({
description: '更新时间',
examples: ['2024-12-19T10:30:00Z']
})
examples: ['2024-12-19T10:30:00Z'],
}),
});
/**
@ -306,28 +310,34 @@ export const UserListItemSchema = t.Object({
*/
export const GetUserListResponsesSchema = {
200: responseWrapperSchema(createPaginationResponseSchema(UserListItemSchema)),
401: responseWrapperSchema(t.Object({
401: responseWrapperSchema(
t.Object({
error: t.String({
description: '认证失败',
examples: ['未提供有效的认证令牌', '令牌已过期']
})
})),
400: responseWrapperSchema(t.Object({
examples: ['未提供有效的认证令牌', '令牌已过期'],
}),
}),
),
400: responseWrapperSchema(
t.Object({
error: t.String({
description: '参数错误',
examples: ['分页参数无效', '搜索关键词格式错误']
})
})),
500: responseWrapperSchema(t.Object({
examples: ['分页参数无效', '搜索关键词格式错误'],
}),
}),
),
500: responseWrapperSchema(
t.Object({
error: t.String({
description: '服务器错误',
examples: ['内部服务器错误']
})
}))
examples: ['内部服务器错误'],
}),
}),
),
};
/** 获取用户列表成功响应数据类型 */
export type GetUserListSuccessType = Static<typeof GetUserListResponsesSchema[200]>;
export type GetUserListSuccessType = Static<(typeof GetUserListResponsesSchema)[200]>;
```
## 4. Service业务逻辑层
@ -398,7 +408,7 @@ export class UserService {
status: sysUsers.status,
lastLoginAt: sysUsers.lastLoginAt,
createdAt: sysUsers.createdAt,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(userId)))
@ -406,17 +416,15 @@ export class UserService {
if (!user || user.length === 0) {
Logger.warn(`用户不存在:${userId}`);
throw new BusinessError(
`用户不存在:${userId}`,
404
);
throw new BusinessError(`用户不存在:${userId}`, 404);
}
const userData = user[0]!;
Logger.info(`获取用户信息成功:${userId} - ${userData.username}`);
return successResponse({
return successResponse(
{
id: userId, // 使用传入的字符串ID避免精度丢失
username: userData.username,
email: userData.email,
@ -426,10 +434,11 @@ export class UserService {
status: userData.status,
lastLoginAt: userData.lastLoginAt || null,
createdAt: userData.createdAt,
updatedAt: userData.updatedAt
}, '获取用户信息成功');
updatedAt: userData.updatedAt,
},
'获取用户信息成功',
);
}
}
// 导出单例实例
@ -463,10 +472,7 @@ export const authController = new Elysia()
* @route POST /api/auth/register
* @description 用户注册,包含验证码验证、用户名邮箱唯一性检查等
*/
.post(
'/register',
({ body }) => authService.register(body),
{
.post('/register', ({ body }) => authService.register(body), {
body: RegisterSchema,
detail: {
summary: '用户注册',
@ -475,9 +481,9 @@ export const authController = new Elysia()
operationId: 'registerUser',
},
response: RegisterResponsesSchema,
}
);
});
```
## 6. 错误处理
### 6.1 错误处理规范
@ -494,6 +500,7 @@ import { BusinessError } from '@/utils/responseFormate';
// 抛出业务错误
throw new BusinessError('消息说明...', 409);
```
## 7. 测试用例文档
1. 分模块

View File

@ -1,4 +1,5 @@
# 创建redis连接测试
_Exported on 2025/6/28 at GMT+8 22:07:57 from Cursor (1.1.6)_
---
@ -35,7 +36,7 @@ describe('Redis连接测试', () => {
beforeAll(async () => {
redis = new Redis();
// 等待连接建立
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
});
afterAll(async () => {
@ -103,7 +104,7 @@ describe('Redis连接测试', () => {
expect(result1).toBe(testValue);
// 等待过期
await new Promise(resolve => setTimeout(resolve, 2100));
await new Promise((resolve) => setTimeout(resolve, 2100));
// 过期后应该为null
const result2 = await redis.redisClient.get(testKey);
@ -450,28 +451,34 @@ const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
## 📋 测试覆盖范围
### 🔗 Redis连接管理
- ✅ Redis服务器连接测试
- ✅ 连接状态检查
- ✅ Ping命令测试
### 🔧 Redis基本操作
- ✅ 字符串的设置和获取
- ✅ 带过期时间的键值对
- ✅ 键的存在性检查
- ✅ 键的删除操作
### 📝 Redis Hash操作
- ✅ Hash字段的设置和获取
- ✅ 多个Hash字段操作
### 📜 Redis列表操作
- ✅ 列表元素的推入和弹出
### ⚠️ 错误处理测试
- ✅ 连接断开时的健康检查
- ✅ 重新连接功能
### ⚡ 性能测试
- ✅ 大量并发操作性能测试
## 🚀 如何运行测试
@ -614,8 +621,12 @@ class HealthService {
/** 系统整体状态 */
const overallStatus = this.determineOverallStatus([
mysqlStatus.status === 'fulfilled' ? mysqlStatus.value : { status: 'unhealthy', error: 'Connection failed' },
redisStatus.status === 'fulfilled' ? redisStatus.value : { status: 'unhealthy', error: 'Connection failed' },
mysqlStatus.status === 'fulfilled'
? mysqlStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
redisStatus.status === 'fulfilled'
? redisStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
]);
const responseTime = Date.now() - startTime;
@ -631,8 +642,14 @@ class HealthService {
version: process.env.npm_package_version || '1.0.0',
environment: process.env.NODE_ENV || 'development',
components: {
mysql: mysqlStatus.status === 'fulfilled' ? mysqlStatus.value : { status: 'unhealthy', error: 'Connection failed' },
redis: redisStatus.status === 'fulfilled' ? redisStatus.value : { status: 'unhealthy', error: 'Connection failed' },
mysql:
mysqlStatus.status === 'fulfilled'
? mysqlStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
redis:
redisStatus.status === 'fulfilled'
? redisStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
},
},
};
@ -782,7 +799,7 @@ class HealthService {
* @returns 整体状态
*/
private determineOverallStatus(components: ComponentStatus[]): 'healthy' | 'unhealthy' | 'degraded' {
const healthyCount = components.filter(c => c.status === 'healthy').length;
const healthyCount = components.filter((c) => c.status === 'healthy').length;
const totalCount = components.length;
if (healthyCount === totalCount) {
@ -1287,7 +1304,7 @@ import { app } from '@/app';
describe('健康检查接口测试', () => {
beforeAll(async () => {
// 等待应用启动
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
});
describe('GET /api/health', () => {
@ -1564,13 +1581,13 @@ describe('健康检查接口测试', () => {
new Request('http://localhost/api/health', {
method: 'GET',
}),
)
),
);
}
const responses = await Promise.all(promises);
responses.forEach(res => {
responses.forEach((res) => {
expect(res.status).toBe(200);
});
});
@ -1628,11 +1645,13 @@ import { app } from '@/app';
### ✅ 已实现的功能
#### 1. **健康检查控制器** (`src/controllers/health.controller.ts`)
- 📍 `/api/health` - 基本健康检查接口
- 📍 `/api/health/detailed` - 详细健康检查接口
- 📖 集成了完整的 Swagger 文档
#### 2. **健康检查服务** (`src/services/health.service.ts`)
- 🔄 **并行检查**:同时检查 MySQL 和 Redis 连接状态
- 📊 **三种状态**healthy、unhealthy、degraded
- ⏱️ **响应时间**:监控每个组件的响应时间
@ -1641,18 +1660,22 @@ import { app } from '@/app';
- ⚠️ **错误处理**:完善的异常捕获和错误响应
#### 3. **类型定义** (`src/type/health.type.ts`)
- 完整的 TypeScript 类型定义
- 组件状态、系统信息、性能指标等类型
#### 4. **响应验证器** (`src/validators/health.response.ts`)
- Elysia TypeBox 严格验证规则
- 支持基本和详细健康检查响应验证
#### 5. **应用集成** (`src/app.ts`)
- 将健康检查控制器集成到主应用
- 替换了原有的简单健康检查接口
#### 6. **全面测试** (`src/tests/health.test.ts`)
- 🧪 基本健康检查接口测试
- 🔍 详细健康检查接口测试
- 🔗 依赖服务状态测试
@ -1663,7 +1686,7 @@ import { app } from '@/app';
### 🌟 接口特性
| 特性 | 描述 |
|------|------|
| ------------ | ----------------------------------- |
| **依赖监控** | MySQL + Redis 连接状态实时检查 |
| **状态分级** | healthy/unhealthy/degraded 三级状态 |
| **性能监控** | CPU、内存、响应时间统计 |
@ -1674,6 +1697,7 @@ import { app } from '@/app';
### 📋 任务清单更新
任务清单已更新:
- ✅ 5.0 健康检查接口
- ✅ 5.1 实现 /health 路由,返回服务与依赖健康状态
@ -1867,11 +1891,13 @@ import { healthResponse } from '@/validators/health.response';
我已经修复了主要的导入问题,包括:
**已修复的问题**
- MySQL导入`mysql` 改为 `pool`
- Logger参数修复了错误日志记录的参数数量
- 类型导入:使用 `import type` 和内联类型定义
🔧 **当前状态**
- 健康检查功能已完全实现
- 任务5.0已标记为完成
- 还有一些TypeScript路径别名相关的警告
@ -1896,6 +1922,7 @@ ERROR undefined is not an object (evaluating 'this.checkMysqlHealth')
我看到了问题!测试虽然通过了,但有很多错误日志显示 `undefined is not an object (evaluating 'this.checkMysqlHealth')`。这是一个典型的 JavaScript `this` 上下文丢失的问题。
当我们在控制器中直接传递服务方法时:
```typescript
.get('/health', healthService.getHealthStatus, {
```
@ -2191,11 +2218,7 @@ export const HealthCheckResponseSchema = t.Object({
code: t.Number(),
message: t.String(),
data: t.Object({
status: t.Union([
t.Literal('healthy'),
t.Literal('unhealthy'),
t.Literal('degraded'),
], {
status: t.Union([t.Literal('healthy'), t.Literal('unhealthy'), t.Literal('degraded')], {
description: '系统健康状态healthy-健康unhealthy-不健康degraded-降级',
}),
timestamp: t.String({
@ -2219,18 +2242,22 @@ export const HealthCheckResponseSchema = t.Object({
examples: ['development', 'production', 'test'],
}),
components: t.Object({
mysql: t.Optional(t.Object({
mysql: t.Optional(
t.Object({
status: t.String(),
responseTime: t.Optional(t.Number()),
error: t.Optional(t.String()),
details: t.Optional(t.Any()),
})),
redis: t.Optional(t.Object({
}),
),
redis: t.Optional(
t.Object({
status: t.String(),
responseTime: t.Optional(t.Number()),
error: t.Optional(t.String()),
details: t.Optional(t.Any()),
})),
}),
),
}),
}),
});
@ -3251,4 +3278,3 @@ feat: 完成健康检查接口和Swagger文档完善
- src/tests/redis.test.ts - Redis连接测试
- src/tests/swagger.test.ts - Swagger文档功能测试
```

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,4 +1,5 @@
# 开始集成邮件发送服务
_Exported on 2025/7/4 at GMT+8 18:43:55 from Cursor (1.2.1)_
---
@ -24,6 +25,7 @@ _Exported on 2025/7/4 at GMT+8 18:43:55 from Cursor (1.2.1)_
现在我需要安装邮件发送服务所需的依赖包:
✅ 第一个子任务完成!已成功安装邮件发送服务所需的依赖包:
- nodemailer@7.0.4 (邮件发送核心库)
- @types/nodemailer@6.4.17 (TypeScript类型定义)
@ -187,6 +189,7 @@ export const ENV = process.env.NODE_ENV || process.env.BUN_ENV || 'development';
✅ 第二个子任务完成!已成功创建邮件配置文件:
**创建的文件和功能:**
- `src/config/email.config.ts` - 包含完整的邮件服务配置
- SMTP服务器配置支持QQ邮箱等
- 邮件基础配置(发件人、字符编码等)
@ -197,6 +200,7 @@ export const ENV = process.env.NODE_ENV || process.env.BUN_ENV || 'development';
- 更新了 `src/config/index.ts` 以导出邮件配置
**支持的环境变量:**
- `SMTP_HOST`, `SMTP_PORT`, `SMTP_SECURE` - SMTP服务器设置
- `SMTP_USER`, `SMTP_PASS` - 邮箱认证信息
- `EMAIL_FROM`, `EMAIL_REPLY_TO` - 发件人设置
@ -479,6 +483,7 @@ export interface EmailHealthCheckResult {
✅ 第三个子任务完成!已成功创建邮件服务类型定义文件:
**创建的类型定义:**
- `src/type/email.type.ts` - 包含完整的邮件服务类型定义
- **基础类型**EmailTransporter、EmailPriority、EmailTemplateType
- **邮件发送类型**EmailSendOptions、EmailAttachment、EmailSendResult
@ -489,6 +494,7 @@ export interface EmailHealthCheckResult {
- **Elysia集成类型**EmailContext扩展Elysia上下文
**类型特点:**
- 完整的类型安全支持
- 支持多种邮件发送模式(直接发送、模板发送、队列发送)
- 支持附件、抄送、密送等完整邮件功能
@ -621,7 +627,7 @@ export class EmailService {
private updateStatus(
status: EmailServiceStatus['status'],
transporterStatus: EmailServiceStatus['transporterStatus'],
error?: string
error?: string,
): void {
this._status = {
status,
@ -767,7 +773,7 @@ export class EmailService {
}
// 等待重试延迟
await new Promise(resolve => setTimeout(resolve, emailOptions.retryDelay));
await new Promise((resolve) => setTimeout(resolve, emailOptions.retryDelay));
}
}
@ -830,7 +836,7 @@ export class EmailService {
*/
private renderTemplate(
templateType: EmailTemplateType,
params: EmailTemplateParams
params: EmailTemplateParams,
): { subject: string; html: string; text: string } {
const template = emailTemplates[templateType];
const defaultParams = {
@ -1302,6 +1308,7 @@ export type EmailTemplateType = 'activation' | 'passwordReset' | 'welcome' | 'no
✅ 第四个子任务完成!已成功实现邮件发送服务类:
**创建的功能:**
- `src/plugins/email/email.service.ts` - 完整的邮件发送服务类
- **核心功能**:单例模式管理、配置验证、连接池支持
- **邮件发送**:支持重试机制、错误处理、详细日志记录
@ -1311,6 +1318,7 @@ export type EmailTemplateType = 'activation' | 'passwordReset' | 'welcome' | 'no
- **便捷方法**initializeEmailService、sendEmail、sendTemplateEmail等
**支持的邮件类型:**
- 直接发送邮件(自定义内容)
- 模板邮件发送(预定义模板)
- 支持抄送、密送、附件
@ -1318,6 +1326,7 @@ export type EmailTemplateType = 'activation' | 'passwordReset' | 'welcome' | 'no
- 完整的错误处理和重试机制
**修复的问题:**
- 修正了nodemailer API调用
- 统一了模板类型命名(驼峰命名)
- 处理了类型安全问题
@ -1471,11 +1480,7 @@ export const emailPlugin = new Elysia({ name: 'email' })
/**
* 发送欢迎邮件
*/
async sendWelcomeEmail(options: {
to: string;
username: string;
nickname?: string;
}): Promise<EmailSendResult> {
async sendWelcomeEmail(options: { to: string; username: string; nickname?: string }): Promise<EmailSendResult> {
return await emailService.sendTemplateEmail({
to: options.to,
template: 'welcome',
@ -1563,11 +1568,7 @@ export type EmailServiceDecorator = {
resetCode: string;
expireTime: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: {
to: string;
username: string;
nickname?: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: { to: string; username: string; nickname?: string }): Promise<EmailSendResult>;
sendPasswordChangedEmail(options: {
to: string;
username: string;
@ -1618,11 +1619,7 @@ export type EmailServiceDecorator = {
resetCode: string;
expireTime: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: {
to: string;
username: string;
nickname?: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: { to: string; username: string; nickname?: string }): Promise<EmailSendResult>;
sendPasswordChangedEmail(options: {
to: string;
username: string;
@ -1639,7 +1636,7 @@ export type EmailServiceDecorator = {
};
```
```markdown
````markdown
# 邮件服务插件
邮件服务插件为 Elysia 应用提供完整的邮件发送功能,包括模板邮件、重试机制、健康检查等。
@ -1676,6 +1673,7 @@ EMAIL_REPLY_TO=your-email@qq.com
EMAIL_RETRY_ATTEMPTS=3
EMAIL_RETRY_DELAY=5000
```
````
### 2. 插件注册
@ -1685,8 +1683,7 @@ EMAIL_RETRY_DELAY=5000
import { Elysia } from 'elysia';
import { emailPlugin } from '@/plugins/email/email.plugins';
const app = new Elysia()
.use(emailPlugin)
const app = new Elysia().use(emailPlugin);
// ... 其他插件
```
@ -1798,6 +1795,7 @@ app.get('/email/health', async ({ emailService }) => {
发送自定义邮件。
**参数:**
- `options.to`: 收件人邮箱(字符串或数组)
- `options.subject`: 邮件主题
- `options.html`: HTML 内容
@ -1812,6 +1810,7 @@ app.get('/email/health', async ({ emailService }) => {
发送模板邮件。
**参数:**
- `options.to`: 收件人邮箱
- `options.template`: 模板类型
- `options.params`: 模板参数
@ -1857,7 +1856,8 @@ app.get('/email/health', async ({ emailService }) => {
3. **发送限制**: 注意邮件提供商的发送频率限制
4. **模板自定义**: 可以通过修改服务类来自定义邮件模板
5. **安全性**: 避免在邮件内容中包含敏感信息
```
````
```typescript
/**
@ -1891,11 +1891,12 @@ export const plugins = (app: Elysia) =>
.use(emailPlugin)
// API 文档插件
.use(swaggerPlugin);
```
````
✅ 第五个子任务完成已成功创建邮件服务Elysia插件
**创建的文件和功能:**
- `src/plugins/email/email.plugins.ts` - 邮件服务Elysia插件
- **启动初始化**:验证配置、初始化服务、错误处理
- **上下文装饰**将邮件功能注入到Elysia上下文中
@ -1911,6 +1912,7 @@ export const plugins = (app: Elysia) =>
- **插件集成**:更新了 `src/plugins/index.ts` 以注册邮件插件
**插件特性:**
- 🔧 **自动初始化**:应用启动时自动初始化邮件服务
- 🛡️ **容错处理**:邮件服务故障不影响应用启动
- 📝 **类型安全**完整的TypeScript类型支持
@ -1988,13 +1990,13 @@ import {
sendTemplateEmail,
getEmailServiceStatus,
checkEmailServiceHealth,
closeEmailService
closeEmailService,
} from '@/plugins/email/email.service';
import { validateEmailConfig } from '@/config/email.config';
import type { EmailSendOptions, EmailTemplateSendOptions } from '@/type/email.type';
// 简单的延时函数
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
// 测试用的邮箱地址(请根据实际情况修改)
const TEST_EMAIL = 'test@example.com';
@ -2067,7 +2069,9 @@ describe('邮件服务测试', () => {
// 只在邮件配置有效时运行实际发送测试
const runSendTest = isEmailConfigValid ? it : it.skip;
runSendTest('应该能够发送简单文本邮件', async () => {
runSendTest(
'应该能够发送简单文本邮件',
async () => {
const emailOptions: EmailSendOptions = {
to: TEST_EMAIL,
subject: '测试邮件 - 简单文本',
@ -2088,9 +2092,13 @@ describe('邮件服务测试', () => {
} else {
console.warn('邮件发送失败:', result.error);
}
}, 10000); // 设置较长的超时时间
},
10000,
); // 设置较长的超时时间
runSendTest('应该能够发送带抄送的邮件', async () => {
runSendTest(
'应该能够发送带抄送的邮件',
async () => {
const emailOptions: EmailSendOptions = {
to: TEST_EMAIL,
cc: TEST_EMAIL, // 测试环境下抄送给同一个邮箱
@ -2101,7 +2109,9 @@ describe('邮件服务测试', () => {
const result = await sendEmail(emailOptions);
expect(result).toHaveProperty('success');
expect(result).toHaveProperty('sentAt');
}, 10000);
},
10000,
);
it('应该处理邮件发送错误', async () => {
const invalidEmailOptions: EmailSendOptions = {
@ -2126,7 +2136,9 @@ describe('邮件服务测试', () => {
describe('模板邮件功能', () => {
const runTemplateTest = isEmailConfigValid ? it : it.skip;
runTemplateTest('应该能够发送用户激活邮件', async () => {
runTemplateTest(
'应该能够发送用户激活邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'activation',
@ -2149,9 +2161,13 @@ describe('邮件服务测试', () => {
expect(result).toHaveProperty('messageId');
console.log('激活邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送密码重置邮件', async () => {
runTemplateTest(
'应该能够发送密码重置邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'passwordReset',
@ -2173,9 +2189,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('密码重置邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送欢迎邮件', async () => {
runTemplateTest(
'应该能够发送欢迎邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'welcome',
@ -2194,9 +2214,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('欢迎邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送密码修改通知邮件', async () => {
runTemplateTest(
'应该能够发送密码修改通知邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'passwordChanged',
@ -2215,9 +2239,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('密码修改通知邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送系统通知邮件', async () => {
runTemplateTest(
'应该能够发送系统通知邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'notification',
@ -2237,7 +2265,9 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('系统通知邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
it('应该处理无效模板类型', async () => {
const invalidTemplateOptions = {
@ -2281,7 +2311,9 @@ describe('邮件服务测试', () => {
describe('邮件服务性能测试', () => {
const runPerformanceTest = isEmailConfigValid ? it : it.skip;
runPerformanceTest('应该能够并发发送多封邮件', async () => {
runPerformanceTest(
'应该能够并发发送多封邮件',
async () => {
const emailPromises = [];
const emailCount = 3; // 限制并发数量以避免SMTP限制
@ -2303,7 +2335,9 @@ describe('邮件服务测试', () => {
expect(result).toHaveProperty('sentAt');
console.log(`邮件 ${index + 1} 发送结果:`, result.success ? '成功' : '失败');
});
}, 30000); // 更长的超时时间用于并发测试
},
30000,
); // 更长的超时时间用于并发测试
});
describe('邮件模板渲染测试', () => {
@ -2340,6 +2374,7 @@ describe('邮件服务测试', () => {
## 🎉 测试结果总结
### ✅ 成功的功能
1. **服务初始化** - 邮件服务成功连接和初始化
2. **配置验证** - 正确验证邮件配置有效性
3. **状态管理** - 服务状态检查和健康监控
@ -2348,7 +2383,9 @@ describe('邮件服务测试', () => {
6. **并发处理** - 支持并发邮件发送
### ⚠️ 需要配置的部分
邮件发送失败的原因是SMTP认证问题
- **QQ邮箱需要授权码**需要在QQ邮箱设置中生成授权码
- **From头部格式**:需要正确的邮箱地址格式
@ -2372,6 +2409,7 @@ describe('邮件服务测试', () => {
## 📋 任务完成情况
**所有8个子任务已完成**
1. 邮件服务基础配置 ✅
2. 邮件配置文件创建 ✅
3. 邮件服务类型定义 ✅
@ -2386,6 +2424,7 @@ describe('邮件服务测试', () => {
## 🚀 邮件服务功能特点
### 💼 核心功能
- **完整的邮件发送服务**支持文本和HTML邮件
- **5种内置模板**:用户激活、密码重置、欢迎邮件、系统通知、密码修改通知
- **智能重试机制**:自动重试失败的邮件发送
@ -2393,6 +2432,7 @@ describe('邮件服务测试', () => {
- **并发支持**:支持批量和并发邮件发送
### 🔧 技术特点
- **TypeScript类型安全**:完整的类型定义
- **Elysia插件集成**便捷的API调用方式
- **配置灵活**支持多种SMTP服务商
@ -2409,8 +2449,8 @@ app.post('/send-activation', async ({ email }) => {
params: {
username: 'user123',
nickname: '用户昵称',
activationUrl: 'https://yoursite.com/activate?token=xxx'
}
activationUrl: 'https://yoursite.com/activate?token=xxx',
},
});
return { success: result.success };
});
@ -2433,8 +2473,8 @@ app.post('/send-activation', async ({ email }) => {
params: {
username: 'user123',
nickname: '用户昵称',
activationUrl: 'https://yoursite.com/activate?token=xxx'
}
activationUrl: 'https://yoursite.com/activate?token=xxx',
},
});
return { success: result.success };
});
@ -2465,7 +2505,7 @@ import {
sendEmail,
sendTemplateEmail,
checkEmailServiceHealth,
closeEmailService
closeEmailService,
} from '@/plugins/email/email.service';
import { validateEmailConfig } from '@/config/email.config';
import type { EmailSendOptions, EmailTemplateSendOptions } from '@/type/email.type';
@ -2643,7 +2683,7 @@ async function main() {
// 等待一下再发送模板邮件
console.log('\n⏳ 等待2秒后发送模板邮件...');
await new Promise(resolve => setTimeout(resolve, 2000));
await new Promise((resolve) => setTimeout(resolve, 2000));
await demo.sendTemplateEmail(testEmail);
@ -2651,7 +2691,6 @@ async function main() {
console.log('✨ Demo执行完成请检查您的邮箱收件箱');
console.log('📬 如果没收到邮件,请检查垃圾邮件文件夹');
console.log('='.repeat(50));
} catch (error) {
console.log('💥 Demo执行过程中出现错误:', error);
} finally {
@ -2676,11 +2715,7 @@ export { EmailDemo };
* 运行方式: bun run quick-email-test.ts your@email.com
*/
import {
initializeEmailService,
sendEmail,
closeEmailService
} from './src/plugins/email/email.service';
import { initializeEmailService, sendEmail, closeEmailService } from './src/plugins/email/email.service';
async function quickTest() {
const testEmail = process.argv[2];
@ -2709,7 +2744,7 @@ async function quickTest() {
<h2>🎉 邮件测试成功!</h2>
<p>如果您收到这封邮件,说明邮件服务配置正确。</p>
<p><small>发送时间: ${new Date().toLocaleString('zh-CN')}</small></p>
`
`,
});
if (result.success) {
@ -2720,7 +2755,6 @@ async function quickTest() {
console.log('❌ 邮件发送失败');
console.log(`💥 错误: ${result.error}`);
}
} catch (error) {
console.log('💥 执行失败:', error);
} finally {
@ -2786,6 +2820,7 @@ bun run quick-email-test.ts your@email.com
```
如果一切配置正确,你应该会看到:
- ✅ 初始化成功
- ✅ 邮件发送成功
- 📮 消息ID: xxx
@ -2887,25 +2922,17 @@ import { validateEmailConfig, getEmailConfig } from './src/config/email.config';
function checkEnvVariables() {
console.log('🔍 检查环境变量配置...\n');
const requiredVars = [
'SMTP_HOST',
'SMTP_PORT',
'SMTP_USER',
'SMTP_PASS',
'SMTP_FROM_EMAIL'
];
const requiredVars = ['SMTP_HOST', 'SMTP_PORT', 'SMTP_USER', 'SMTP_PASS', 'SMTP_FROM_EMAIL'];
const missingVars: string[] = [];
const presentVars: string[] = [];
requiredVars.forEach(varName => {
requiredVars.forEach((varName) => {
const value = process.env[varName];
if (value) {
presentVars.push(varName);
// 对敏感信息进行脱敏显示
const displayValue = varName === 'SMTP_PASS'
? '*'.repeat(value.length)
: value;
const displayValue = varName === 'SMTP_PASS' ? '*'.repeat(value.length) : value;
console.log(`✅ ${varName}: ${displayValue}`);
} else {
missingVars.push(varName);
@ -2917,7 +2944,7 @@ function checkEnvVariables() {
if (missingVars.length > 0) {
console.log(`\n🚨 缺少以下环境变量:`);
missingVars.forEach(varName => {
missingVars.forEach((varName) => {
console.log(` - ${varName}`);
});
return false;
@ -2967,7 +2994,6 @@ async function testConnection() {
// 这里不实际连接,只是显示配置信息
console.log('✅ 配置信息已就绪,可以尝试发送测试邮件');
} catch (error) {
console.log('❌ 配置验证失败:', error);
return false;
@ -3067,6 +3093,7 @@ async function testConnection() {
### 🔥 快速解决步骤
#### 1⃣ 先检查当前配置
```bash
bun run check-email-config.ts
```
@ -3098,6 +3125,7 @@ from: process.env.EMAIL_FROM || `"星撰系统" <${smtpConfig.auth.user}>`,
## 🚨 问题原因
QQ邮箱要求
1. **From邮箱地址必须与SMTP认证用户名完全一致**
2. **From字段格式必须符合RFC5322标准**
@ -3256,11 +3284,13 @@ export const emailConfig = {
现在创建一个正确的环境变量配置示例:
```markdown
````markdown
# QQ邮箱配置指南
## 🚨 问题原因
错误 `550 The "From" header is missing or invalid` 是因为QQ邮箱要求
1. **From字段的邮箱地址必须与SMTP认证用户名完全一致**
2. **From字段格式必须符合RFC5322标准**
@ -3296,10 +3326,12 @@ SMTP_FROM_NAME=星撰系统
# 其他配置
EMAIL_REPLY_TO=your_qq_email@qq.com
```
````
### 第三步:替换为你的真实信息
**示例配置:**
```env
SMTP_HOST=smtp.qq.com
SMTP_PORT=587
@ -3332,16 +3364,21 @@ bun run src/tests/demo/emailDemo.ts your_receive_email@example.com
## 🔧 常见问题
### Q: 为什么要用授权码而不是QQ密码
A: QQ邮箱的安全策略第三方应用必须使用授权码
### Q: 授权码在哪里生成?
A: QQ邮箱设置 → 账户 → 开启IMAP/SMTP服务时生成
### Q: 为什么From地址必须与SMTP_USER一致
A: QQ邮箱的反欺诈机制防止伪造发件人
### Q: 可以使用其他邮箱服务吗?
A: 可以修改SMTP_HOST即可
- 163邮箱`smtp.163.com`
- Gmail`smtp.gmail.com`
- 企业邮箱:根据提供商配置
@ -3361,7 +3398,8 @@ SMTP_FROM_EMAIL=替换为你的QQ邮箱@qq.com
SMTP_FROM_NAME=星撰系统
EMAIL_REPLY_TO=替换为你的QQ邮箱@qq.com
```
```
````
## 🎉 From字段问题已修复
@ -3381,7 +3419,7 @@ EMAIL_REPLY_TO=替换为你的QQ邮箱@qq.com
SMTP_PASS=your_16_digit_authorization_code
SMTP_FROM_EMAIL=your_qq_email@qq.com # 必须与SMTP_USER一致
SMTP_FROM_NAME=星撰系统
```
````
### 🧪 测试修复效果
@ -3427,4 +3465,3 @@ bun run quick-email-test.ts x71291@outlook.com
现在按照rules执行任务完成流程
好的我直接进行git提交和任务归档

View File

@ -51,8 +51,7 @@ export class ExampleService {
import type { GetUserByUsernameParams, UserInfo } from './example.schema';
import { GetUserByUsernameSchema } from './example.schema';
export const controller = new Elysia()
.get(
export const controller = new Elysia().get(
'/user/:username',
async ({ params }) => {
// params 自动推断为 GetUserByUsernameParams 类型
@ -62,7 +61,7 @@ export const controller = new Elysia()
{
// 使用 Schema 进行运行时验证
params: GetUserByUsernameSchema,
}
},
);
```
@ -76,11 +75,11 @@ describe('用户查询测试', () => {
it('应该正确处理参数类型', () => {
// 类型安全的测试数据
const validParams: GetUserByUsernameParams = {
username: 'testuser'
username: 'testuser',
};
const invalidParams = {
username: 'a' // TypeScript 会提示这可能不符合验证规则
username: 'a', // TypeScript 会提示这可能不符合验证规则
};
});
});
@ -124,10 +123,7 @@ export type GetUserSuccessResponseType = Static<typeof GetUserSuccessResponse>;
```typescript
// 完整的类型安全流程
import type {
GetUserByUsernameParams,
UserInfo
} from './example.schema';
import type { GetUserByUsernameParams, UserInfo } from './example.schema';
// Service 层
class UserService {
@ -138,15 +134,18 @@ class UserService {
}
// Controller 层
const controller = new Elysia()
.get('/user/:username', async ({ params }) => {
const controller = new Elysia().get(
'/user/:username',
async ({ params }) => {
// params 自动推断类型
const user = await userService.getUser(params);
// user 自动推断为 UserInfo 类型
return { code: 0, message: '成功', data: user };
}, {
},
{
params: GetUserByUsernameSchema, // 运行时验证
});
},
);
```
## 💡 最佳实践

View File

@ -17,22 +17,25 @@
### 1. 短期操作(推荐不开启自动续期)
**适用场景**
- 用户登录
- Token刷新
- 数据查询
- 简单的数据更新
**配置建议**
```typescript
const lock = await DistributedLockService.acquire({
key: 'user:login:username',
ttl: 15, // 15秒过期
timeout: 8000, // 8秒超时
autoRenew: false // 不开启自动续期
autoRenew: false, // 不开启自动续期
});
```
**优点**
- 简单可靠,不会出现死锁
- 性能开销小
- 适合快速操作
@ -40,23 +43,26 @@ const lock = await DistributedLockService.acquire({
### 2. 长期操作(需要开启自动续期)
**适用场景**
- 用户注册(包含邮件发送)
- 密码重置(包含邮件发送)
- 文件上传
- 复杂的数据处理
**配置建议**
```typescript
const lock = await DistributedLockService.acquire({
key: 'user:register:username:email',
ttl: 60, // 60秒过期
timeout: 15000, // 15秒超时
autoRenew: true, // 开启自动续期
renewInterval: 20000 // 20秒续期一次
renewInterval: 20000, // 20秒续期一次
});
```
**注意事项**
- 必须确保在操作完成后手动释放锁
- 进程退出时会自动清理锁
- 续期失败时会记录警告日志
@ -64,26 +70,29 @@ const lock = await DistributedLockService.acquire({
## 锁键名设计规范
### 1. 命名规则
```
{业务模块}:{操作类型}:{关键标识}
```
### 2. 示例
```typescript
// 用户注册锁
'user:register:username:email'
'user:register:username:email';
// 用户登录锁
'user:login:username'
'user:login:username';
// 密码重置锁
'password:reset:email'
'password:reset:email';
// Token刷新锁
'token:refresh:token_value'
'token:refresh:token_value';
```
### 3. 注意事项
- 键名要具有唯一性
- 避免使用过长的键名
- 使用有意义的标识符
@ -93,64 +102,71 @@ const lock = await DistributedLockService.acquire({
### 1. 锁的粒度控制
**好的做法**
```typescript
// 针对特定用户加锁
const lock = await DistributedLockService.acquire({
key: `user:login:${username}`,
ttl: 15,
autoRenew: false
autoRenew: false,
});
```
**避免的做法**
```typescript
// 锁的粒度太粗,影响其他用户
const lock = await DistributedLockService.acquire({
key: 'user:login', // 所有用户登录都被阻塞
ttl: 15,
autoRenew: false
autoRenew: false,
});
```
### 2. 超时时间设置
**原则**
- 超时时间应该大于预期的操作时间
- 但不要设置过长,避免长时间阻塞
**建议**
```typescript
// 快速操作
timeout: 5000 // 5秒
timeout: 5000; // 5秒
// 中等操作
timeout: 10000 // 10秒
timeout: 10000; // 10秒
// 慢速操作
timeout: 30000 // 30秒
timeout: 30000; // 30秒
```
### 3. TTL设置
**原则**
- TTL应该大于操作时间
- 对于自动续期的锁TTL可以设置得相对较短
**建议**
```typescript
// 快速操作
ttl: 10 // 10秒
ttl: 10; // 10秒
// 中等操作
ttl: 30 // 30秒
ttl: 30; // 30秒
// 慢速操作
ttl: 60 // 60秒
ttl: 60; // 60秒
```
### 4. 错误处理
**必须使用 try-finally**
```typescript
const lock = await DistributedLockService.acquire(config);
@ -166,12 +182,14 @@ try {
### 5. 监控和日志
**监控指标**
- 锁获取成功率
- 锁等待时间
- 锁释放情况
- 死锁检测
**日志记录**
```typescript
Logger.info(`获取分布式锁成功: ${lockKey}`);
Logger.warn(`锁续期失败: ${lockKey}`);
@ -183,11 +201,13 @@ Logger.error(`获取锁超时: ${lockKey}`);
### 1. 死锁问题
**原因**
- 进程崩溃但锁未释放
- 网络中断导致无法续期
- 业务逻辑异常导致锁未释放
**解决方案**
- 设置合理的TTL
- 使用try-finally确保锁释放
- 进程退出时自动清理锁
@ -196,11 +216,13 @@ Logger.error(`获取锁超时: ${lockKey}`);
### 2. 性能问题
**原因**
- 锁的粒度太粗
- 锁的持有时间过长
- 频繁的锁竞争
**解决方案**
- 细化锁的粒度
- 优化业务逻辑,减少锁持有时间
- 使用读写锁分离
@ -209,11 +231,13 @@ Logger.error(`获取锁超时: ${lockKey}`);
### 3. 一致性问题
**原因**
- 锁释放时机不当
- 业务逻辑异常
- 并发控制不当
**解决方案**
- 确保锁的原子性操作
- 使用事务保证数据一致性
- 添加业务层面的幂等性检查
@ -238,7 +262,7 @@ async function complexOperation() {
const lock = await DistributedLockService.acquire({
key: 'complex:operation',
ttl: 60,
autoRenew: true
autoRenew: true,
});
try {

View File

@ -119,6 +119,7 @@ src/plugins/
```
### 1.4 类型定义 (type/)
```
src/type/
├── config.type.ts # 配置相关类型
@ -131,6 +132,7 @@ src/type/
```
### 1.5 工具函数 (utils/)
```
src/utils/
├── deviceInfo.ts # 设备信息工具
@ -148,11 +150,13 @@ src/utils/
```
### 1.6 常量定义 (constants/)
```
src/constants/
├── swaggerTags.ts # Swagger标签定义所有模块的tag应该集中在此定义
└── 其他常量
```
### 1.7 数据库实体
```
@ -163,6 +167,7 @@ src/eneities/
```
### 1.8 文件命名约定
- 模块名使用 **单数形式**`auth`、`user`、`product`、`order`
- 文件名格式:`[module].[type].ts`
- 导出名格式:`[module][类型名]`
@ -182,11 +187,12 @@ src/eneities/
- 注意已经存在的工具函数,比如分页有现成的简化工具,且能够统一请求格式
### 2.2 特别注意点
**必须遵循的命名模式:**
- Request类型`[动作][模块]Request` → `RegisterRequest`
- Schema名`[动作][模块]Schema` → `RegisterSchema`
### 2.3 代码示例
```ts
@ -206,38 +212,37 @@ import { createQuerySchema } from '@/utils/pagination';
* 用户列表查询参数Schema
* @description 用户列表查询的请求参数验证规则
*/
export const UserListQuerySchema = createQuerySchema(t.Object({
export const UserListQuerySchema = createQuerySchema(
t.Object({
// 用户特有参数
keyword: t.Optional(t.String({
keyword: t.Optional(
t.String({
minLength: 1,
maxLength: 100,
description: '搜索关键词,支持用户名、邮箱模糊搜索',
examples: ['admin', 'test@example.com']
})),
status: t.Optional(t.Union([
t.Literal('active'),
t.Literal('inactive'),
t.Literal('pending')
], {
examples: ['admin', 'test@example.com'],
}),
),
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive'), t.Literal('pending')], {
description: '用户状态筛选',
examples: ['active', 'inactive', 'pending']
})),
gender: t.Optional(t.Union([
t.Literal(0),
t.Literal(1),
t.Literal(2),
t.Literal('0'),
t.Literal('1'),
t.Literal('2'),
], {
examples: ['active', 'inactive', 'pending'],
}),
),
gender: t.Optional(
t.Union([t.Literal(0), t.Literal(1), t.Literal(2), t.Literal('0'), t.Literal('1'), t.Literal('2')], {
description: '性别筛选0-未知1-男2-女',
examples: [0, 1, 2]
})),
isRoot: t.Optional(t.Boolean({
examples: [0, 1, 2],
}),
),
isRoot: t.Optional(
t.Boolean({
description: '是否超级管理员筛选',
examples: [true, false]
}))
}));
examples: [true, false],
}),
),
}),
);
/** 用户列表查询参数类型 */
export type UserListQueryRequest = Static<typeof UserListQuerySchema>;
@ -251,9 +256,10 @@ export type UserListQueryRequest = Static<typeof UserListQuerySchema>;
- 错误相应只提供示例和描述
- 导出响应成功类型
### 3.2 特别注意点
**必须遵循的命名模式:**
- Response格式定义`[动作][模块]Response` → `RegisterResponse`
- Response成功类型`[动作][模块]SuccessType ` → `RegisterSuccessType `
@ -273,8 +279,6 @@ import { t, type Static } from 'elysia';
import { responseWrapperSchema } from '@/utils/responseFormate';
import { createPaginationResponseSchema } from '@/utils/pagination';
/**
* 用户列表项Schema
* @description 用户列表中单个用户的数据结构
@ -283,12 +287,12 @@ export const UserListItemSchema = t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 更多字段... */
@ -296,8 +300,8 @@ export const UserListItemSchema = t.Object({
/** 更新时间 */
updatedAt: t.String({
description: '更新时间',
examples: ['2024-12-19T10:30:00Z']
})
examples: ['2024-12-19T10:30:00Z'],
}),
});
/**
@ -306,28 +310,34 @@ export const UserListItemSchema = t.Object({
*/
export const GetUserListResponsesSchema = {
200: responseWrapperSchema(createPaginationResponseSchema(UserListItemSchema)),
401: responseWrapperSchema(t.Object({
401: responseWrapperSchema(
t.Object({
error: t.String({
description: '认证失败',
examples: ['未提供有效的认证令牌', '令牌已过期']
})
})),
400: responseWrapperSchema(t.Object({
examples: ['未提供有效的认证令牌', '令牌已过期'],
}),
}),
),
400: responseWrapperSchema(
t.Object({
error: t.String({
description: '参数错误',
examples: ['分页参数无效', '搜索关键词格式错误']
})
})),
500: responseWrapperSchema(t.Object({
examples: ['分页参数无效', '搜索关键词格式错误'],
}),
}),
),
500: responseWrapperSchema(
t.Object({
error: t.String({
description: '服务器错误',
examples: ['内部服务器错误']
})
}))
examples: ['内部服务器错误'],
}),
}),
),
};
/** 获取用户列表成功响应数据类型 */
export type GetUserListSuccessType = Static<typeof GetUserListResponsesSchema[200]>;
export type GetUserListSuccessType = Static<(typeof GetUserListResponsesSchema)[200]>;
```
## 4. Service业务逻辑层
@ -398,7 +408,7 @@ export class UserService {
status: sysUsers.status,
lastLoginAt: sysUsers.lastLoginAt,
createdAt: sysUsers.createdAt,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(userId)))
@ -406,17 +416,15 @@ export class UserService {
if (!user || user.length === 0) {
Logger.warn(`用户不存在:${userId}`);
throw new BusinessError(
`用户不存在:${userId}`,
404
);
throw new BusinessError(`用户不存在:${userId}`, 404);
}
const userData = user[0]!;
Logger.info(`获取用户信息成功:${userId} - ${userData.username}`);
return successResponse({
return successResponse(
{
id: userId, // 使用传入的字符串ID避免精度丢失
username: userData.username,
email: userData.email,
@ -426,10 +434,11 @@ export class UserService {
status: userData.status,
lastLoginAt: userData.lastLoginAt || null,
createdAt: userData.createdAt,
updatedAt: userData.updatedAt
}, '获取用户信息成功');
updatedAt: userData.updatedAt,
},
'获取用户信息成功',
);
}
}
// 导出单例实例
@ -463,10 +472,7 @@ export const authController = new Elysia()
* @route POST /api/auth/register
* @description 用户注册,包含验证码验证、用户名邮箱唯一性检查等
*/
.post(
'/register',
({ body }) => authService.register(body),
{
.post('/register', ({ body }) => authService.register(body), {
body: RegisterSchema,
detail: {
summary: '用户注册',
@ -475,9 +481,9 @@ export const authController = new Elysia()
operationId: 'registerUser',
},
response: RegisterResponsesSchema,
}
);
});
```
## 6. 错误处理
### 6.1 错误处理规范
@ -494,6 +500,7 @@ import { BusinessError } from '@/utils/responseFormate';
// 抛出业务错误
throw new BusinessError('消息说明...', 409);
```
## 7. 测试用例文档
1. 分模块

View File

@ -3,12 +3,15 @@ description:
globs:
alwaysApply: true
---
## Git 提交规范Commit Message Rules
1. **提交格式**
```
<type>(<scope>): <subject>
```
- `type`:提交类型(必填)
- `scope`:影响范围(可选)
- `subject`:简要描述(必填)

View File

@ -7,6 +7,7 @@
## 类型定义
### 1. JwtUserType - JWT中的用户信息
```typescript
interface JwtUserType {
userId: number;
@ -19,6 +20,7 @@ interface JwtUserType {
```
### 2. JwtPayloadType - 完整的JWT载荷
```typescript
interface JwtPayloadType extends JwtUserType {
iat: number; // 发行时间
@ -40,9 +42,7 @@ interface JwtPayloadType extends JwtUserType {
import { createJwtPayload } from '@/utils/jwt.helper';
import type { UserInfoType } from '@/modules/example/example.schema';
export const authController = new Elysia()
.use(jwtPlugin)
.post('/login', async ({ body, jwt }) => {
export const authController = new Elysia().use(jwtPlugin).post('/login', async ({ body, jwt }) => {
// 用户登录验证逻辑...
const userInfo: UserInfoType = await getUserFromDatabase(body.username);
@ -74,9 +74,7 @@ export const authController = new Elysia()
import { formatUserForLog, isValidJwtUser } from '@/utils/jwt.helper';
import type { JwtUserType } from '@/type/jwt.type';
export const userController = new Elysia()
.use(jwtAuthPlugin)
.get('/profile', async ({ user, payload }) => {
export const userController = new Elysia().use(jwtAuthPlugin).get('/profile', async ({ user, payload }) => {
// user 自动推断为 JwtUserType 类型
// payload 自动推断为 JwtPayloadType 类型
@ -115,9 +113,7 @@ export class UserService {
}
// 更新用户信息
const updatedUser = await db.update(users)
.set(updateData)
.where(eq(users.id, currentUser.userId));
const updatedUser = await db.update(users).set(updateData).where(eq(users.id, currentUser.userId));
Logger.info(`用户资料更新: ${currentUser.username} (ID: ${currentUser.userId})`);
return updatedUser;
@ -125,11 +121,9 @@ export class UserService {
// 根据JWT用户信息获取权限
async getUserPermissions(jwtUser: JwtUserType): Promise<string[]> {
const permissions = await db.select()
.from(userPermissions)
.where(eq(userPermissions.userId, jwtUser.userId));
const permissions = await db.select().from(userPermissions).where(eq(userPermissions.userId, jwtUser.userId));
return permissions.map(p => p.permission);
return permissions.map((p) => p.permission);
}
}
```
@ -138,11 +132,7 @@ export class UserService {
```typescript
// middleware/token-check.ts
import {
isTokenExpiringSoon,
getTokenRemainingTime,
formatRemainingTime
} from '@/utils/jwt.helper';
import { isTokenExpiringSoon, getTokenRemainingTime, formatRemainingTime } from '@/utils/jwt.helper';
export const tokenStatusMiddleware = (app: Elysia) =>
app.derive(({ payload, user }) => {

View File

@ -157,53 +157,38 @@
"compositePrimaryKeys": {
"sys_dict_items_id": {
"name": "sys_dict_items_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_key": {
"name": "idx_key",
"columns": [
"item_key"
],
"columns": ["item_key"],
"isUnique": false
},
"idx_pid": {
"name": "idx_pid",
"columns": [
"pid"
],
"columns": ["pid"],
"isUnique": false
},
"idx_sort": {
"name": "idx_sort",
"columns": [
"type_id",
"sort_order"
],
"columns": ["type_id", "sort_order"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
},
"idx_type_id": {
"name": "idx_type_id",
"columns": [
"type_id"
],
"columns": ["type_id"],
"isUnique": false
}
},
@ -211,11 +196,7 @@
"uniqueConstraints": {
"uk_type_key": {
"name": "uk_type_key",
"columns": [
"type_id",
"item_key",
"deleted_at"
]
"columns": ["type_id", "item_key", "deleted_at"]
}
},
"checkConstraint": {}
@ -339,60 +320,43 @@
"compositePrimaryKeys": {
"sys_dict_types_id": {
"name": "sys_dict_types_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_is_system": {
"name": "idx_is_system",
"columns": [
"is_system"
],
"columns": ["is_system"],
"isUnique": false
},
"idx_name": {
"name": "idx_name",
"columns": [
"name"
],
"columns": ["name"],
"isUnique": false
},
"idx_path": {
"name": "idx_path",
"columns": [
"path"
],
"columns": ["path"],
"isUnique": false
},
"idx_pid": {
"name": "idx_pid",
"columns": [
"pid"
],
"columns": ["pid"],
"isUnique": false
},
"idx_sort": {
"name": "idx_sort",
"columns": [
"pid",
"sort_order"
],
"columns": ["pid", "sort_order"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
}
},
@ -400,10 +364,7 @@
"uniqueConstraints": {
"uk_code": {
"name": "uk_code",
"columns": [
"code",
"deleted_at"
]
"columns": ["code", "deleted_at"]
}
},
"checkConstraint": {}
@ -521,53 +482,38 @@
"compositePrimaryKeys": {
"sys_operation_logs_id": {
"name": "sys_operation_logs_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_created_at": {
"name": "idx_created_at",
"columns": [
"created_at"
],
"columns": ["created_at"],
"isUnique": false
},
"idx_ip": {
"name": "idx_ip",
"columns": [
"ip"
],
"columns": ["ip"],
"isUnique": false
},
"idx_module_action": {
"name": "idx_module_action",
"columns": [
"module",
"action"
],
"columns": ["module", "action"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
},
"idx_target": {
"name": "idx_target",
"columns": [
"target_id"
],
"columns": ["target_id"],
"isUnique": false
},
"idx_user_id": {
"name": "idx_user_id",
"columns": [
"user_id"
],
"columns": ["user_id"],
"isUnique": false
}
},
@ -736,67 +682,48 @@
"compositePrimaryKeys": {
"sys_organizations_id": {
"name": "sys_organizations_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_leader_id": {
"name": "idx_leader_id",
"columns": [
"leader_id"
],
"columns": ["leader_id"],
"isUnique": false
},
"idx_name": {
"name": "idx_name",
"columns": [
"name"
],
"columns": ["name"],
"isUnique": false
},
"idx_path": {
"name": "idx_path",
"columns": [
"path"
],
"columns": ["path"],
"isUnique": false
},
"idx_pid": {
"name": "idx_pid",
"columns": [
"pid"
],
"columns": ["pid"],
"isUnique": false
},
"idx_sort": {
"name": "idx_sort",
"columns": [
"pid",
"sort_order"
],
"columns": ["pid", "sort_order"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
},
"idx_type": {
"name": "idx_type",
"columns": [
"type"
],
"columns": ["type"],
"isUnique": false
}
},
@ -804,10 +731,7 @@
"uniqueConstraints": {
"uk_code": {
"name": "uk_code",
"columns": [
"code",
"deleted_at"
]
"columns": ["code", "deleted_at"]
}
},
"checkConstraint": {}
@ -951,54 +875,38 @@
"compositePrimaryKeys": {
"sys_permissions_id": {
"name": "sys_permissions_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_pid": {
"name": "idx_pid",
"columns": [
"pid"
],
"columns": ["pid"],
"isUnique": false
},
"idx_resource_action": {
"name": "idx_resource_action",
"columns": [
"resource",
"action"
],
"columns": ["resource", "action"],
"isUnique": false
},
"idx_sort": {
"name": "idx_sort",
"columns": [
"pid",
"sort_order"
],
"columns": ["pid", "sort_order"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
},
"idx_type": {
"name": "idx_type",
"columns": [
"type"
],
"columns": ["type"],
"isUnique": false
}
},
@ -1006,10 +914,7 @@
"uniqueConstraints": {
"uk_code": {
"name": "uk_code",
"columns": [
"code",
"deleted_at"
]
"columns": ["code", "deleted_at"]
}
},
"checkConstraint": {}
@ -1065,31 +970,23 @@
"compositePrimaryKeys": {
"sys_role_permissions_id": {
"name": "sys_role_permissions_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_is_half": {
"name": "idx_is_half",
"columns": [
"is_half"
],
"columns": ["is_half"],
"isUnique": false
},
"idx_permission_id": {
"name": "idx_permission_id",
"columns": [
"permission_id"
],
"columns": ["permission_id"],
"isUnique": false
},
"idx_role_id": {
"name": "idx_role_id",
"columns": [
"role_id"
],
"columns": ["role_id"],
"isUnique": false
}
},
@ -1097,10 +994,7 @@
"uniqueConstraints": {
"uk_role_permission": {
"name": "uk_role_permission",
"columns": [
"role_id",
"permission_id"
]
"columns": ["role_id", "permission_id"]
}
},
"checkConstraint": {}
@ -1246,60 +1140,43 @@
"compositePrimaryKeys": {
"sys_roles_id": {
"name": "sys_roles_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_is_system": {
"name": "idx_is_system",
"columns": [
"is_system"
],
"columns": ["is_system"],
"isUnique": false
},
"idx_name": {
"name": "idx_name",
"columns": [
"name"
],
"columns": ["name"],
"isUnique": false
},
"idx_path": {
"name": "idx_path",
"columns": [
"path"
],
"columns": ["path"],
"isUnique": false
},
"idx_pid": {
"name": "idx_pid",
"columns": [
"pid"
],
"columns": ["pid"],
"isUnique": false
},
"idx_sort": {
"name": "idx_sort",
"columns": [
"pid",
"sort_order"
],
"columns": ["pid", "sort_order"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
}
},
@ -1307,10 +1184,7 @@
"uniqueConstraints": {
"uk_code": {
"name": "uk_code",
"columns": [
"code",
"deleted_at"
]
"columns": ["code", "deleted_at"]
}
},
"checkConstraint": {}
@ -1388,38 +1262,28 @@
"compositePrimaryKeys": {
"sys_tags_id": {
"name": "sys_tags_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_name": {
"name": "idx_name",
"columns": [
"name"
],
"columns": ["name"],
"isUnique": false
},
"idx_type": {
"name": "idx_type",
"columns": [
"type"
],
"columns": ["type"],
"isUnique": false
},
"idx_usage_count": {
"name": "idx_usage_count",
"columns": [
"usage_count"
],
"columns": ["usage_count"],
"isUnique": false
}
},
@ -1427,11 +1291,7 @@
"uniqueConstraints": {
"uk_name_type": {
"name": "uk_name_type",
"columns": [
"name",
"type",
"deleted_at"
]
"columns": ["name", "type", "deleted_at"]
}
},
"checkConstraint": {}
@ -1502,38 +1362,28 @@
"compositePrimaryKeys": {
"sys_user_organizations_id": {
"name": "sys_user_organizations_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_is_primary": {
"name": "idx_is_primary",
"columns": [
"is_primary"
],
"columns": ["is_primary"],
"isUnique": false
},
"idx_joined_at": {
"name": "idx_joined_at",
"columns": [
"joined_at"
],
"columns": ["joined_at"],
"isUnique": false
},
"idx_organization_id": {
"name": "idx_organization_id",
"columns": [
"organization_id"
],
"columns": ["organization_id"],
"isUnique": false
},
"idx_user_id": {
"name": "idx_user_id",
"columns": [
"user_id"
],
"columns": ["user_id"],
"isUnique": false
}
},
@ -1541,10 +1391,7 @@
"uniqueConstraints": {
"uk_user_org": {
"name": "uk_user_org",
"columns": [
"user_id",
"organization_id"
]
"columns": ["user_id", "organization_id"]
}
},
"checkConstraint": {}
@ -1599,38 +1446,28 @@
"compositePrimaryKeys": {
"sys_user_roles_id": {
"name": "sys_user_roles_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_created_at": {
"name": "idx_created_at",
"columns": [
"created_at"
],
"columns": ["created_at"],
"isUnique": false
},
"idx_expired_at": {
"name": "idx_expired_at",
"columns": [
"expired_at"
],
"columns": ["expired_at"],
"isUnique": false
},
"idx_role_id": {
"name": "idx_role_id",
"columns": [
"role_id"
],
"columns": ["role_id"],
"isUnique": false
},
"idx_user_id": {
"name": "idx_user_id",
"columns": [
"user_id"
],
"columns": ["user_id"],
"isUnique": false
}
},
@ -1638,10 +1475,7 @@
"uniqueConstraints": {
"uk_user_role": {
"name": "uk_user_role",
"columns": [
"user_id",
"role_id"
]
"columns": ["user_id", "role_id"]
}
},
"checkConstraint": {}
@ -1689,31 +1523,23 @@
"compositePrimaryKeys": {
"sys_user_tags_id": {
"name": "sys_user_tags_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_created_at": {
"name": "idx_created_at",
"columns": [
"created_at"
],
"columns": ["created_at"],
"isUnique": false
},
"idx_tag_id": {
"name": "idx_tag_id",
"columns": [
"tag_id"
],
"columns": ["tag_id"],
"isUnique": false
},
"idx_user_id": {
"name": "idx_user_id",
"columns": [
"user_id"
],
"columns": ["user_id"],
"isUnique": false
}
},
@ -1721,10 +1547,7 @@
"uniqueConstraints": {
"uk_user_tag": {
"name": "uk_user_tag",
"columns": [
"user_id",
"tag_id"
]
"columns": ["user_id", "tag_id"]
}
},
"checkConstraint": {}
@ -1912,52 +1735,38 @@
"compositePrimaryKeys": {
"sys_users_id": {
"name": "sys_users_id",
"columns": [
"id"
]
"columns": ["id"]
}
},
"indexes": {
"idx_created_at": {
"name": "idx_created_at",
"columns": [
"created_at"
],
"columns": ["created_at"],
"isUnique": false
},
"idx_deleted_at": {
"name": "idx_deleted_at",
"columns": [
"deleted_at"
],
"columns": ["deleted_at"],
"isUnique": false
},
"idx_is_root": {
"name": "idx_is_root",
"columns": [
"is_root"
],
"columns": ["is_root"],
"isUnique": false
},
"idx_last_login": {
"name": "idx_last_login",
"columns": [
"last_login_at"
],
"columns": ["last_login_at"],
"isUnique": false
},
"idx_mobile": {
"name": "idx_mobile",
"columns": [
"mobile"
],
"columns": ["mobile"],
"isUnique": false
},
"idx_status": {
"name": "idx_status",
"columns": [
"status"
],
"columns": ["status"],
"isUnique": false
}
},
@ -1965,17 +1774,11 @@
"uniqueConstraints": {
"uk_email": {
"name": "uk_email",
"columns": [
"email",
"deleted_at"
]
"columns": ["email", "deleted_at"]
},
"uk_username": {
"name": "uk_username",
"columns": [
"username",
"deleted_at"
]
"columns": ["username", "deleted_at"]
}
},
"checkConstraint": {}

View File

@ -1,3 +1,2 @@
import { relations } from "drizzle-orm/relations";
import { } from "./schema";
import { relations } from 'drizzle-orm/relations';
import {} from './schema';

View File

@ -1,287 +1,325 @@
import { mysqlTable, mysqlSchema, AnyMySqlColumn, index, primaryKey, unique, bigint, varchar, text, int, json, datetime, tinyint, date } from "drizzle-orm/mysql-core"
import { sql } from "drizzle-orm"
import {
mysqlTable,
mysqlSchema,
AnyMySqlColumn,
index,
primaryKey,
unique,
bigint,
varchar,
int,
json,
timestamp,
text,
datetime,
tinyint,
date,
} from 'drizzle-orm/mysql-core';
import { sql } from 'drizzle-orm';
export const sysDictItems = mysqlTable("sys_dict_items", {
id: bigint({ mode: "number" }).notNull(),
typeId: bigint("type_id", { mode: "number" }).notNull(),
itemKey: varchar("item_key", { length: 50 }).notNull(),
itemValue: varchar("item_value", { length: 200 }).notNull(),
label: varchar({ length: 100 }).notNull(),
labelEn: varchar("label_en", { length: 200 }),
description: text(),
pid: bigint({ mode: "number" }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
cssClass: varchar("css_class", { length: 50 }),
color: varchar({ length: 50 }),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_key").on(table.itemKey),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.typeId, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type_id").on(table.typeId),
primaryKey({ columns: [table.id], name: "sys_dict_items_id"}),
unique("uk_type_key").on(table.typeId, table.itemKey, table.deletedAt),
]);
export const sysDictTypes = mysqlTable("sys_dict_types", {
id: bigint({ mode: "number" }).notNull(),
export const sysDict = mysqlTable(
'sys_dict',
{
id: bigint({ mode: 'number' }).autoincrement().notNull(),
code: varchar({ length: 50 }).notNull(),
name: varchar({ length: 100 }).notNull(),
description: text(),
pid: bigint({ mode: "number" }),
path: varchar({ length: 500 }),
value: varchar({ length: 200 }),
description: varchar({ length: 500 }),
icon: varchar({ length: 100 }),
pid: bigint({ mode: 'number' }),
level: int().default(1).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
isSystem: tinyint("is_system").default(0).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
isSystem: tinyint('is_system').default(0).notNull(),
color: varchar({ length: 20 }),
extra: json(),
createdAt: timestamp('created_at', { mode: 'string' }).defaultNow().notNull(),
updatedAt: timestamp('updated_at', { mode: 'string' }).defaultNow().onUpdateNow().notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_system").on(table.isSystem),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_dict_types_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_level').on(table.level),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.sortOrder),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_dict_id' }),
unique('uk_code').on(table.code),
],
);
export const sysOperationLogs = mysqlTable("sys_operation_logs", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }),
export const sysOperationLogs = mysqlTable(
'sys_operation_logs',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }),
username: varchar({ length: 100 }),
module: varchar({ length: 50 }).notNull(),
action: varchar({ length: 50 }).notNull(),
target: varchar({ length: 200 }),
targetId: bigint("target_id", { mode: "number" }),
requestData: text("request_data"),
responseData: text("response_data"),
targetId: bigint('target_id', { mode: 'number' }),
requestData: text('request_data'),
responseData: text('response_data'),
status: varchar({ length: 20 }).notNull(),
ip: varchar({ length: 45 }),
userAgent: varchar("user_agent", { length: 200 }),
duration: bigint({ mode: "number" }),
errorMsg: text("error_msg"),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
userAgent: varchar('user_agent', { length: 200 }),
duration: bigint({ mode: 'number' }),
errorMsg: text('error_msg'),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_ip").on(table.ip),
index("idx_module_action").on(table.module, table.action),
index("idx_status").on(table.status),
index("idx_target").on(table.targetId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_operation_logs_id"}),
]);
index('idx_created_at').on(table.createdAt),
index('idx_ip').on(table.ip),
index('idx_module_action').on(table.module, table.action),
index('idx_status').on(table.status),
index('idx_target').on(table.targetId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_operation_logs_id' }),
],
);
export const sysOrganizations = mysqlTable("sys_organizations", {
id: bigint({ mode: "number" }).notNull(),
export const sysOrganizations = mysqlTable(
'sys_organizations',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 100 }).notNull(),
name: varchar({ length: 200 }).notNull(),
fullName: varchar("full_name", { length: 200 }),
fullName: varchar('full_name', { length: 200 }),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
type: varchar({ length: 20 }),
status: varchar({ length: 20 }).default('active').notNull(),
sortOrder: int("sort_order").default(0).notNull(),
leaderId: bigint("leader_id", { mode: "number" }),
sortOrder: int('sort_order').default(0).notNull(),
leaderId: bigint('leader_id', { mode: 'number' }),
address: varchar({ length: 200 }),
phone: varchar({ length: 50 }),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_leader_id").on(table.leaderId),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type").on(table.type),
primaryKey({ columns: [table.id], name: "sys_organizations_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_leader_id').on(table.leaderId),
index('idx_name').on(table.name),
index('idx_path').on(table.path),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
index('idx_type').on(table.type),
primaryKey({ columns: [table.id], name: 'sys_organizations_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysPermissions = mysqlTable("sys_permissions", {
id: bigint({ mode: "number" }).notNull(),
export const sysPermissions = mysqlTable(
'sys_permissions',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 100 }).notNull(),
name: varchar({ length: 100 }).notNull(),
type: varchar({ length: 20 }).notNull(),
resource: varchar({ length: 50 }),
action: varchar({ length: 50 }),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
meta: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_pid").on(table.pid),
index("idx_resource_action").on(table.resource, table.action),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type").on(table.type),
primaryKey({ columns: [table.id], name: "sys_permissions_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_pid').on(table.pid),
index('idx_resource_action').on(table.resource, table.action),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
index('idx_type').on(table.type),
primaryKey({ columns: [table.id], name: 'sys_permissions_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysRolePermissions = mysqlTable("sys_role_permissions", {
id: bigint({ mode: "number" }).notNull(),
roleId: bigint("role_id", { mode: "number" }).notNull(),
permissionId: bigint("permission_id", { mode: "number" }).notNull(),
isHalf: tinyint("is_half").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysRolePermissions = mysqlTable(
'sys_role_permissions',
{
id: bigint({ mode: 'number' }).notNull(),
roleId: bigint('role_id', { mode: 'number' }).notNull(),
permissionId: bigint('permission_id', { mode: 'number' }).notNull(),
isHalf: tinyint('is_half').default(0).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_is_half").on(table.isHalf),
index("idx_permission_id").on(table.permissionId),
index("idx_role_id").on(table.roleId),
primaryKey({ columns: [table.id], name: "sys_role_permissions_id"}),
unique("uk_role_permission").on(table.roleId, table.permissionId),
]);
index('idx_is_half').on(table.isHalf),
index('idx_permission_id').on(table.permissionId),
index('idx_role_id').on(table.roleId),
primaryKey({ columns: [table.id], name: 'sys_role_permissions_id' }),
unique('uk_role_permission').on(table.roleId, table.permissionId),
],
);
export const sysRoles = mysqlTable("sys_roles", {
id: bigint({ mode: "number" }).notNull(),
export const sysRoles = mysqlTable(
'sys_roles',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 50 }).notNull(),
name: varchar({ length: 100 }).notNull(),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
isSystem: tinyint("is_system").default(0).notNull(),
permissionsSnapshot: json("permissions_snapshot"),
isSystem: tinyint('is_system').default(0).notNull(),
permissionsSnapshot: json('permissions_snapshot'),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_system").on(table.isSystem),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_roles_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_is_system').on(table.isSystem),
index('idx_name').on(table.name),
index('idx_path').on(table.path),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_roles_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysTags = mysqlTable("sys_tags", {
id: bigint({ mode: "number" }).notNull(),
export const sysTags = mysqlTable(
'sys_tags',
{
id: bigint({ mode: 'number' }).notNull(),
name: varchar({ length: 50 }).notNull(),
type: varchar({ length: 50 }).default('user'),
color: varchar({ length: 50 }),
description: text(),
usageCount: int("usage_count").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
usageCount: int('usage_count').default(0).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_name").on(table.name),
index("idx_type").on(table.type),
index("idx_usage_count").on(table.usageCount),
primaryKey({ columns: [table.id], name: "sys_tags_id"}),
unique("uk_name_type").on(table.name, table.type, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_name').on(table.name),
index('idx_type').on(table.type),
index('idx_usage_count').on(table.usageCount),
primaryKey({ columns: [table.id], name: 'sys_tags_id' }),
unique('uk_name_type').on(table.name, table.type, table.deletedAt),
],
);
export const sysUserOrganizations = mysqlTable("sys_user_organizations", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
organizationId: bigint("organization_id", { mode: "number" }).notNull(),
isPrimary: tinyint("is_primary").default(0).notNull(),
export const sysUserOrganizations = mysqlTable(
'sys_user_organizations',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
organizationId: bigint('organization_id', { mode: 'number' }).notNull(),
isPrimary: tinyint('is_primary').default(0).notNull(),
position: varchar({ length: 100 }),
joinedAt: datetime("joined_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
joinedAt: datetime('joined_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_is_primary").on(table.isPrimary),
index("idx_joined_at").on(table.joinedAt),
index("idx_organization_id").on(table.organizationId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_organizations_id"}),
unique("uk_user_org").on(table.userId, table.organizationId),
]);
index('idx_is_primary').on(table.isPrimary),
index('idx_joined_at').on(table.joinedAt),
index('idx_organization_id').on(table.organizationId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_organizations_id' }),
unique('uk_user_org').on(table.userId, table.organizationId),
],
);
export const sysUserRoles = mysqlTable("sys_user_roles", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
roleId: bigint("role_id", { mode: "number" }).notNull(),
expiredAt: datetime("expired_at", { mode: 'string'}),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysUserRoles = mysqlTable(
'sys_user_roles',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
roleId: bigint('role_id', { mode: 'number' }).notNull(),
expiredAt: datetime('expired_at', { mode: 'string' }),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_expired_at").on(table.expiredAt),
index("idx_role_id").on(table.roleId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_roles_id"}),
unique("uk_user_role").on(table.userId, table.roleId),
]);
index('idx_created_at').on(table.createdAt),
index('idx_expired_at').on(table.expiredAt),
index('idx_role_id').on(table.roleId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_roles_id' }),
unique('uk_user_role').on(table.userId, table.roleId),
],
);
export const sysUserTags = mysqlTable("sys_user_tags", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
tagId: bigint("tag_id", { mode: "number" }).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysUserTags = mysqlTable(
'sys_user_tags',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
tagId: bigint('tag_id', { mode: 'number' }).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_tag_id").on(table.tagId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_tags_id"}),
unique("uk_user_tag").on(table.userId, table.tagId),
]);
index('idx_created_at').on(table.createdAt),
index('idx_tag_id').on(table.tagId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_tags_id' }),
unique('uk_user_tag').on(table.userId, table.tagId),
],
);
export const sysUsers = mysqlTable("sys_users", {
id: bigint({ mode: "number" }).notNull(),
export const sysUsers = mysqlTable(
'sys_users',
{
id: bigint({ mode: 'number' }).notNull(),
username: varchar({ length: 50 }).notNull(),
email: varchar({ length: 100 }).notNull(),
mobile: varchar({ length: 20 }),
passwordHash: varchar("password_hash", { length: 255 }).notNull(),
passwordHash: varchar('password_hash', { length: 255 }).notNull(),
avatar: varchar({ length: 255 }),
nickname: varchar({ length: 100 }),
status: varchar({ length: 20 }).default('active').notNull(),
@ -289,28 +327,33 @@ export const sysUsers = mysqlTable("sys_users", {
// you can use { mode: 'date' }, if you want to have Date as type for this column
birthday: date({ mode: 'string' }),
bio: varchar({ length: 500 }),
loginCount: int("login_count").default(0).notNull(),
lastLoginAt: datetime("last_login_at", { mode: 'string'}),
lastLoginIp: varchar("last_login_ip", { length: 45 }),
failedAttempts: int("failed_attempts").default(0).notNull(),
lockedUntil: datetime("locked_until", { mode: 'string'}),
isRoot: tinyint("is_root").default(0).notNull(),
loginCount: int('login_count').default(0).notNull(),
lastLoginAt: datetime('last_login_at', { mode: 'string' }),
lastLoginIp: varchar('last_login_ip', { length: 45 }),
failedAttempts: int('failed_attempts').default(0).notNull(),
lockedUntil: datetime('locked_until', { mode: 'string' }),
isRoot: tinyint('is_root').default(0).notNull(),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_root").on(table.isRoot),
index("idx_last_login").on(table.lastLoginAt),
index("idx_mobile").on(table.mobile),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_users_id"}),
unique("uk_email").on(table.email, table.deletedAt),
unique("uk_username").on(table.username, table.deletedAt),
]);
index('idx_created_at').on(table.createdAt),
index('idx_deleted_at').on(table.deletedAt),
index('idx_is_root').on(table.isRoot),
index('idx_last_login').on(table.lastLoginAt),
index('idx_mobile').on(table.mobile),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_users_id' }),
unique('uk_email').on(table.email, table.deletedAt),
unique('uk_username').on(table.username, table.deletedAt),
],
);

File diff suppressed because it is too large Load Diff

View File

@ -861,12 +861,14 @@ INSERT INTO `sys_tags` (`name`, `type`, `color`, `description`) VALUES
## 7. 性能优化建议
### 7.1 查询优化
- 使用覆盖索引减少回表查询
- 合理使用联合索引,注意索引顺序
- 避免在WHERE子句中对字段进行函数操作
- 使用EXPLAIN分析SQL执行计划
### 7.2 树形结构查询优化
```sql
-- 查询所有子节点使用path
SELECT * FROM sys_roles WHERE path LIKE '/1/2/%' AND deleted_at IS NULL;
@ -885,6 +887,7 @@ SELECT * FROM role_tree;
```
### 7.3 权限查询优化
```sql
-- 使用权限快照避免多表联查
SELECT permissions_snapshot FROM sys_roles WHERE id = ?;

View File

@ -5,10 +5,13 @@
## 1. 引言
### 1.1. 文档目的
本文档是 "M2 - 基础用户系统" 阶段的 **V2 修订版**旨在提供一份详尽、准确、可直接用于开发的技术设计方案。V2 版根据反馈进行了全面重构重点增强了数据库设计的合理性、API定义的完整性并补充了关键的 `root` 用户机制和标签功能。
### 1.2. 模块范围
本设计覆盖功能点包括:
- 用户认证(注册、登录)及 `root` 超级管理员机制。
- 用户、角色、权限、组织、字典的CRUD管理支持层级结构。
- 用户标签系统。
@ -19,7 +22,9 @@
## 2. 数据库设计 (Revised)
### 2.1. E-R 图 (Entity-Relationship Diagram)
*已更新,包含标签和重构后的字典表*
_已更新包含标签和重构后的字典表_
```mermaid
erDiagram
users {
@ -98,34 +103,40 @@ erDiagram
### 2.2. 表结构定义
#### `roles` / `organizations`
- **`parent_id`**: `BIGINT NULL`, `FOREIGN KEY (parent_id) REFERENCES roles(id) ON DELETE SET NULL`。此字段用于实现树形层级结构。值为`NULL`表示为顶级角色/组织。
#### `dictionary_types` - 字典类型表
| 字段名 | 类型 | 约束 | 描述 |
|---------------|---------------|---------------------|----------------------|
| ------------- | ------------- | -------------------- | ------------------------------- |
| `id` | `BIGINT` | `PK`, `AI` | 类型唯一ID |
| `type_name` | `VARCHAR(50)` | `UNIQUE`, `NOT NULL` | 字典类型名(如: `user_status` |
| `description` | `TEXT` | | 类型描述 |
#### `dictionary_items` - 字典条目表
| 字段名 | 类型 | 约束 | 描述 |
|---------------|----------------|----------------------|----------------------|
| ------------ | -------------- | ---------------- | --------------------------- |
| `id` | `BIGINT` | `PK`, `AI` | 条目唯一ID |
| `type_id` | `BIGINT` | `NOT NULL`, `FK` | 关联到`dictionary_types.id` |
| `key` | `VARCHAR(50)` | `NOT NULL` | 键 (程序中使用) |
| `value` | `VARCHAR(255)` | `NOT NULL` | 值 (UI中显示) |
| `sort_order` | `INT` | `DEFAULT 0` | 排序字段 |
*复合唯一键: `(type_id, key)`*
_复合唯一键: `(type_id, key)`_
#### `tags` - 标签表
| 字段名 | 类型 | 约束 | 描述 |
|--------|---------------|---------------------|------------|
| ------ | ------------- | -------------------- | ---------- |
| `id` | `BIGINT` | `PK`, `AI` | 标签唯一ID |
| `name` | `VARCHAR(50)` | `UNIQUE`, `NOT NULL` | 标签名 |
#### `user_tags` - 用户标签关联表
| 字段名 | 类型 | 约束 | 描述 |
|-----------|----------|----------|------------|
| --------- | -------- | ---------- | ---------- |
| `user_id` | `BIGINT` | `PK`, `FK` | 关联用户ID |
| `tag_id` | `BIGINT` | `PK`, `FK` | 关联标签ID |
@ -145,6 +156,7 @@ erDiagram
**Base URL**: `/api/v1`
**通用错误响应结构**:
```json
{
"code": 40001, // 详细业务错误码
@ -156,6 +168,7 @@ erDiagram
### 3.1. Auth - 认证接口 (`/auth`)
#### `POST /register` - 用户注册
- **权限**: Public
- **请求体 (`application/json`)**:
| 名称 | 类型 | 必填 | 校验规则 | 描述 |
@ -165,7 +178,11 @@ erDiagram
| `password` | string | 是 | min:8, max:100, 必须包含大小写字母和数字 | 密码 |
- **成功响应 (201 Created)**:
```json
{ "code": 0, "message": "User registered successfully.", "data": { "id": 1, "username": "newuser", "email": "..." } }
{
"code": 0,
"message": "User registered successfully.",
"data": { "id": 1, "username": "newuser", "email": "..." }
}
```
- **异常响应**:
| HTTP 码 | 业务码 | 原因 |
@ -174,6 +191,7 @@ erDiagram
| 409 | 40901 | 用户名或邮箱已被占用 |
#### `POST /login` - 用户登录
- **权限**: Public
- **请求体 (`application/json`)**:
| 名称 | 类型 | 必填 | 校验规则 | 描述 |
@ -191,14 +209,18 @@ erDiagram
| 401 | 40102 | 账户被禁用或未激活 |
---
### 3.2. Users - 用户接口 (`/users`)
*除特殊说明外,均需认证*
_除特殊说明外均需认证_
#### `GET /me` - 获取当前用户信息
- **权限**: Authenticated
- **成功响应 (200 OK)**: `data` 包含当前用户详细信息、关联的角色和权限列表。
#### `GET /` - 获取用户列表
- **权限**: `read:users`
- **查询参数**:
| 名称 | 类型 | 必填 | 描述 |
@ -209,6 +231,7 @@ erDiagram
- **成功响应 (200 OK)**: `data` 包含 `items` (用户列表) 和 `pagination` (分页信息)。
#### `PUT /{userId}/status` - 更新用户状态
- **权限**: `update:user_status`
- **请求体**: `{ "status": "active" }` (status 必须是字典中 `user_status` 类型的值)
- **成功响应 (200 OK)**: 返回更新后的用户信息。
@ -219,25 +242,31 @@ erDiagram
| 404 | 40401 | 指定用户不存在 |
#### `POST /{userId}/tags` - 为用户打标签
- **权限**: `update:user_tags`
- **请求体**: `{ "tagIds": [1, 2, 3] }`
- **成功响应 (204 No Content)**.
---
### 3.3. Roles - 角色接口 (`/roles`)
*所有接口均需 `manage:roles` 权限*
_所有接口均需 `manage:roles` 权限_
#### `GET /` - 获取角色列表
- **描述**: 以树形结构返回所有角色。
- **成功响应 (200 OK)**: `data` 是一个包含 `children` 属性的树形数组。
#### `POST /` - 创建新角色
- **请求体**: `{ "name": "editor", "description": "...", "parentId": 1, "permissionIds": [101, 102] }`
- **成功响应 (201 Created)**: `data` 包含新创建的角色信息。
- **异常响应 (409 Conflict)**: 角色名已存在。
---
*其他模块Organizations, Dictionaries, Tags的API将遵循类似的详细设计模式提供完整的增删改查接口明确定义权限、请求体、校验规则和所有可能的成功/异常响应。*
_其他模块Organizations, Dictionaries, Tags的API将遵循类似的详细设计模式提供完整的增删改查接口明确定义权限、请求体、校验规则和所有可能的成功/异常响应。_
# 补充说明

View File

@ -3,9 +3,11 @@
## 引言/概述
### 项目背景
构建一个集成化的个人网站平台,涵盖内容创作、知识管理、生活记录、实用工具等多个维度,旨在打造一个功能完整、用户体验优秀的个人数字空间。
### 核心价值
- **知识管理中心**:统一管理个人笔记、博客、阅读内容
- **生活记录平台**:记录和分享个人生活点滴
- **实用工具集**:集成常用的个人效率工具
@ -14,12 +16,14 @@
## 目标
### 主要目标
1. **建立完整的个人数字资产管理体系**
2. **提供便捷的内容创作和发布平台**
3. **构建实用的个人效率工具集**
4. **实现智能化的知识管理和检索**
### 可衡量目标
- 支持多种内容格式Markdown、富文本、思维导图、画板
- 实现秒级内容搜索响应
- 支持10+种实用工具集成
@ -38,7 +42,9 @@
### 1. 基础用户系统模块
#### 1.1 字典管理子系统
**功能描述**:维护系统中使用的各类数据字典
- **地区字典**:省份、城市、区县三级联动
- **分类字典**:菜单类别、标签类别、文件类型等
- **组织字典**:部门类型、角色类型、权限类型
@ -50,7 +56,9 @@
- 前端下拉框、选项等数据应能通过API动态获取字典。
#### 1.2 角色权限子系统
**功能描述**基于RBAC模型的权限管理体系
- **角色管理**
- 树形结构的角色层级
- 角色继承机制
@ -72,7 +80,9 @@
- 角色的树形结构应能正确地在前端展示和操作。
#### 1.3 组织架构子系统
**功能描述**:管理用户组织关系
- **组织结构**
- 树形组织架构
- 支持多级嵌套
@ -87,7 +97,9 @@
- 管理员可以根据组织架构筛选和管理用户。
#### 1.4 用户管理子系统
**功能描述**:完整的用户生命周期管理
- **用户注册**
- 邮箱注册验证
- 手机号注册(可选)
@ -115,7 +127,9 @@
### 2. 内容管理系统模块
#### 2.1 笔记管理子系统
**功能描述**:个人知识管理和笔记系统
- **笔记结构**
- 树形文件夹结构
- 无限层级嵌套
@ -144,7 +158,9 @@
- 分享的笔记链接可以设置有效期和密码。
#### 2.2 博客发布子系统
**功能描述**:将笔记转化为公开博客
- **发布机制**
- 笔记一键发布为博客
- 博客独立存储(修改笔记不影响已发布博客)
@ -172,7 +188,9 @@
- 评论支持层级回复,并有新评论通知。
#### 2.3 AI集成子系统
**功能描述**AI增强的内容创作和知识管理
- **内容创作辅助**
- AI写作建议
- 文本润色和优化
@ -191,7 +209,9 @@
### 3. 个人空间模块
#### 3.1 生活日志子系统
**功能描述**:记录和分享个人生活
- **内容类型**
- 文字日志
- 图片分享(支持多图)
@ -209,7 +229,9 @@
- 访客记录
#### 3.2 社交互动子系统
**功能描述**:与访客的互动功能
- **互动功能**
- 点赞系统
- 评论功能
@ -223,14 +245,18 @@
### 4. 阅读管理模块
#### 4.1 电子书管理子系统
**功能描述**:个人电子书库管理
- **格式支持**
- PDF、EPUB、MOBI、TXT等
- 在线阅读器
- 进度同步
#### 4.2 阅读社区子系统
**功能描述**:阅读交流和分享
- **分享功能**
- 读书笔记分享
- 书评发布
@ -239,7 +265,9 @@
### 5. 实用工具模块
#### 5.1 密码管理子系统
**功能描述**:个人密码安全管理
- **密码存储**
- 加密存储
- 分类管理
@ -250,21 +278,27 @@
- 同步功能
#### 5.2 书签同步子系统
**功能描述**:跨设备书签管理
- **同步功能**
- 浏览器书签导入/导出
- 实时同步
- 冲突解决
#### 5.3 第三方平台同步子系统
**功能描述**:整合各平台数据
- **Bilibili收藏同步**
- 收藏视频同步
- 分类管理
- 观看进度
#### 5.4 文件管理子系统
**功能描述**:个人云存储和媒体中心
- **存储功能**
- NAS集成
- 文件上传下载
@ -280,7 +314,9 @@
- 断点续传
#### 5.5 信息聚合子系统
**功能描述**:热点信息和内容聚合
- **新闻聚合**
- 多源新闻抓取
- 分类展示
@ -318,6 +354,7 @@
## 关键用户交互流程 (Key User Flows)
### 流程一:新用户注册与激活
1. **访问首页**: 用户访问网站,点击"注册"按钮。
2. **填写信息**: 跳转至注册页面,要求输入用户名、邮箱和密码(密码需二次确认)。
3. **前端校验**: 实时校验用户名和邮箱是否已被占用,密码是否符合复杂度要求。
@ -327,6 +364,7 @@
7. **激活验证**: 后端验证Token有效性将用户状态更新为`active`,并引导用户至登录页面,提示"激活成功"。
### 流程二:从笔记到博客的发布
1. **创建笔记**: 用户在笔记系统中创建并编辑一篇笔记内容可以是Markdown、富文本等。
2. **发起发布**: 在笔记编辑页面,用户点击"发布为博客"按钮。
3. **配置博客信息**: 弹窗或新页面要求用户填写博客的URL slug、选择分类、添加标签、设置封面图等。
@ -342,22 +380,26 @@
## 技术架构需求
### 后端技术栈
- **框架**Elysia + Bun.js
- **数据库**MySQL (主) + Redis (缓存) + Elasticsearch (搜索)
- **对象存储**支持本地存储、阿里云OSS、自建NAS
- **消息队列**Redis/RabbitMQ处理异步任务
### 前端技术栈
- **Web端**Vue.js/React + TypeScript
- **移动端**PWA或React Native
- **浏览器插件**Manifest V3
### 基础设施
- **部署**Docker + Docker Compose
- **监控**:日志收集、性能监控、错误追踪
- **安全**HTTPS、数据加密、访问控制
### API设计原则
- **RESTful风格**: 使用标准的HTTP方法 (GET, POST, PUT, DELETE, PATCH)。
- **版本控制**: API URL中应包含版本号`/api/v1/...`
- **统一响应格式**: 所有响应遵循 `{ "code": 0, "message": "success", "data": {} }` 结构。
@ -368,16 +410,19 @@
## 非功能性需求
### 性能要求
- **响应时间**:页面加载<2s接口响应<500ms
- **并发支持**支持1000+并发用户
- **可用性**99.9%系统可用性
### 安全要求
- **数据加密**:敏感数据加密存储和传输
- **访问控制**:完善的认证和授权机制
- **审计日志**:关键操作日志记录
### 扩展性要求
- **模块化设计**:支持功能模块独立部署
- **API设计**RESTful API支持版本控制
- **数据库**:支持读写分离和分库分表
@ -385,24 +430,28 @@
## 开发优先级
### 第一期核心基础MVP
1. 基础用户系统(用户管理、角色权限)
2. 笔记系统核心功能
3. 基础博客发布
4. 系统基础架构
### 第二期:内容增强
1. 完整的博客系统
2. 个人空间功能
3. 基础工具(密码管理、书签)
4. 搜索优化
### 第三期:高级功能
1. 阅读管理系统
2. 文件管理系统
3. AI集成功能
4. 第三方平台同步
### 第四期:生态完善
1. 移动端应用
2. 浏览器插件
3. 高级分析功能
@ -411,11 +460,13 @@
## 风险与挑战
### 技术风险
- **数据迁移**:大量历史数据的迁移和同步
- **性能优化**:大文件上传和处理
- **第三方集成**API变更和限制
### 产品风险
- **功能复杂度**:避免功能过于复杂影响用户体验
- **数据安全**:个人敏感数据的安全保护
- **兼容性**:跨浏览器和设备兼容
@ -423,16 +474,19 @@
## 成功指标
### 用户指标
- 日活跃用户数
- 用户留存率
- 功能使用率
### 技术指标
- 系统响应时间
- 错误率控制
- 数据备份完整性
### 业务指标
- 内容创作量
- 用户满意度
- 功能完成度
@ -440,16 +494,19 @@
## 后续规划
### 短期目标6个月内
- 完成第一期功能开发
- 系统稳定性优化
- 基础功能测试
### 中期目标1年内
- 完成主要功能模块
- 移动端支持
- 性能优化
### 长期目标1年以上
- AI功能深度集成
- 开放API生态
- 多语言支持

View File

@ -17,7 +17,7 @@
为确保项目质量,我们设定以下可量化的关键技术指标:
| 类别 | 指标项 | 目标值 | 备注 |
|--------------|------------------------------|------------------------------------------------|----------------------------------------------|
| ------------ | -------------------------- | ------------------------------------------ | ---------------------------------- |
| **性能** | API 平均响应时间 | < 200ms (95th percentile) | 针对核心数据读写操作 |
| | 复杂查询/搜索响应时间 | < 800ms | 如全文搜索聚合分析 |
| | 页面首次内容绘制 (FCP) | < 1.5s | 核心页面的加载性能 |
@ -56,7 +56,7 @@
## 3. 技术选型与论证 (Technology Stack Selection & Justification)
| 领域 | 技术选型 | 选型论证 |
|----------------|-----------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| -------------- | ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **后端运行时** | **Bun.js** | 极高的执行效率,内置打包器、测试器、包管理器,提供了现代、一体化的开发体验,与 Elysia.js 完美契合。 |
| **后端框架** | **Elysia.js** | 基于 Bun 设计性能卓越。提供端到端的类型安全Type-Safe开发体验极佳插件生态丰富非常适合构建高性能、类型健壮的 API 服务。 |
| **前端框架** | **Vue.js / React** | 两者均为业界领先的声明式 UI 框架拥有强大的生态系统和组件库。选择其一可快速构建复杂、交互丰富的单页应用SPA。最终选择可根据个人偏好决定。 |

View File

@ -5,15 +5,19 @@
## 1. 引言
### 1.1. 文档目的
本文档基于《产品需求文档 (PRD)》和《概要设计》,旨在将项目需求拆分为具体、可执行的开发任务,并将其组织成一个以核心功能模块为导向、分阶段的开发计划。本文档是项目执行阶段的核心路线图。
### 1.2. 计划结构
本计划遵循迭代式增量开发模型,将整个项目划分为多个主要阶段。**此版本已根据 `main.md` 的功能列表进行重组**,每个阶段聚焦于一个完整的功能模块。
---
## 阶段一: 项目初始化与基础设施
**目标**: 搭建项目骨架,配置开发环境和规范,建立 CI/CD 基础流程。这是后续所有开发工作的基础。
- [ ] **1.1. 项目脚手架**: 初始化 Elysia + Bun + TypeScript 项目,配置 `tsconfig.json` 和路径别名。
- [ ] **1.2. 代码规范**: 配置 ESLint 和 Prettier确保代码风格和质量一致。
- [ ] **1.3. 配置文件管理**: 建立 `src/config` 目录管理数据库、JWT、日志等配置支持环境变量。
@ -25,7 +29,9 @@
---
## 阶段二: 基础用户系统
**目标**: 实现一个完整的、支持RBAC的用户中心包含用户、角色、权限、组织和字典等核心功能。
- [ ] **2.1. 数据库设计**: 设计并创建 `users`, `roles`, `permissions`, `organizations`, `dictionaries` 及相关联的表。
- [ ] **2.2. 用户认证 API**:
- [ ] `POST /api/v1/auth/register`: 实现用户注册(含数据校验、密码哈希)。
@ -42,7 +48,9 @@
---
## 阶段三: 笔记与博客系统
**目标**: 构建平台的内容核心,支持从私有笔记到公开博客的完整流程,并集成搜索和社交功能。
- [ ] **3.1. 数据库设计**: 设计 `notes`, `posts`, `tags`, `categories`, `comments` 及相关关联表。
- [ ] **3.2. 笔记核心 API**:
- [ ] 实现笔记的 CRUD (创建/读取/更新/删除)。
@ -65,7 +73,9 @@
---
## 阶段四: 个人空间
**目标**: 开发一个用于记录和分享个人生活点滴的模块。
- [ ] **4.1. 数据库设计**: 设计 `life_logs` 表,支持文本、图片/视频链接、位置、心情等。
- [ ] **4.2. 生活日志 CRUD API**: 实现生活日志的增删改查。
- [ ] **4.3. 时间线 API**: `GET /api/v1/space/timeline` 按时间线获取日志列表。
@ -74,7 +84,9 @@
---
## 阶段五: 阅读系统
**目标**: 构建个人电子书库,支持在线阅读、批注和智能解读。
- [ ] **5.1. 数据库设计**: 设计 `ebooks`, `annotations` (批注) 表。
- [ ] **5.2. 电子书 API**: 实现电子书文件的上传、元数据解析和列表管理。
- [ ] **5.3. 阅读功能 API**: 实现阅读时添加/查看批注、记录和同步阅读进度的功能。
@ -83,7 +95,9 @@
---
## 阶段六: 综合工具集
**目标**: 集成一系列实用工具,提升平台的附加价值和用户粘性。
- [ ] **6.1. 密码与书签管理**:
- [ ] 数据库设计 `passwords`, `bookmarks` 表,关键字段加密。
- [ ] 实现密码管理器的安全 CRUD API。
@ -103,7 +117,9 @@
---
## 阶段七: 高级功能与生态完善
**目标**: 引入AI、实时通知等高级功能并通过跨平台应用完善生态。最后对系统进行加固和优化确保长期稳定。
- [ ] **7.1. AI 功能深度集成**:
- [ ] `POST /api/v1/ai/summary`: 对给定文本生成摘要。
- [ ] `POST /api/v1/ai/polish`: 对给定文本进行润色。

View File

@ -5,13 +5,17 @@
## 1. 引言
### 1.1. 文档目的
本概要设计文档旨在为"星撰"个人综合平台项目定义一个完整的软件开发生命周期SDLC框架。它将作为项目从规划、设计、实现到部署和维护的最高指导性文件确保所有开发活动遵循标准化的软件工程最佳实践。
### 1.2. 项目概述
"星撰"是一个高度集成的个人数字化中枢,其核心功能、用户故事及非功能性需求已在《个人网站综合平台产品需求文档 (PRD)》中详细定义。本项目旨在将该PRD转化为一个稳定、可扩展、高质量的软件产品。
### 1.3. 范围
本文档覆盖范围包括:
- 项目开发模型的选定。
- 系统的高层体系结构设计。
- 各阶段(设计、开发、测试、部署)的规划和规范。
@ -22,25 +26,29 @@
## 2. 项目规划与管理
### 2.1. 开发模型
本项目采用 **迭代式增量开发模型 (Iterative and Incremental Development)**
- **迭代式**: 将开发过程划分为多个短周期的迭代,每个迭代都包含需求分析、设计、编码、测试的完整流程。
- **增量式**: 每个迭代都会产出一个可测试、可交付的软件增量。产品功能将分阶段见PRD中的优先级规划逐步构建和完善。
**优势**: 此模型能够快速交付核心功能MVP及时获取反馈灵活应对需求变化并有效控制项目风险。
### 2.2. 项目里程碑
项目将按照PRD中的优先级划分为四个主要里程碑阶段
| 里程碑 | 名称 | 核心交付物 | 目标 |
|--------|--------------|------------------------------------------------------|------------------------------------|
| ------ | ------------------ | ------------------------------------------------------- | -------------------------------- |
| M1 | **核心基础 (MVP)** | 基础用户系统、笔记核心功能、基础博客发布、CI/CD流程建立 | 验证核心架构,跑通开发部署全流程 |
| M2 | **内容增强** | 完整博客系统、个人空间、基础工具、搜索引擎集成 | 完善内容生态,提升用户体验 |
| M3 | **高级功能** | 阅读管理、文件管理、AI功能集成、第三方平台同步 | 扩展平台能力,引入智能化 |
| M4 | **生态完善** | 移动端应用、浏览器插件、高级分析功能、性能深度优化 | 构建跨平台生态,实现长期稳定运营 |
### 2.3. 风险管理
| 风险类别 | 风险描述 | 可能性 | 影响 | 应对策略 |
|--------------|----------------------------------------|--------|------|------------------------------------------------------------------------|
| ------------ | ---------------------------------- | ------ | ---- | ---------------------------------------------------------- |
| **技术风险** | 第三方API变更如B站、QQ音乐 | 中 | 中 | 封装Adapter层隔离变化设计优雅降级机制。 |
| | 新技术引入Bun/Elysia的未知问题 | 低 | 中 | 保持对社区的关注,构建完善的测试体系以快速发现问题。 |
| **进度风险** | 个人项目时间投入不稳定 | 高 | 高 | 严格遵循任务清单,将大任务分解为小任务,利用碎片时间完成。 |
@ -51,6 +59,7 @@
## 3. 系统设计
### 3.1. 系统架构
系统采用分层、模块化的架构,实现前后端分离。
```mermaid
@ -130,13 +139,16 @@ graph TD
AuthService --> OAuth
ContentService --> AI_API
```
* **客户端层**: 负责用户交互和数据展示。
* **服务端层**: 核心业务逻辑处理中心。通过API网关统一入口内部按业务垂直划分为多个服务模块。
* **数据与存储层**: 持久化存储数据,提供缓存和搜索能力。
* **第三方服务**: 集成外部服务以完成特定功能。
- **客户端层**: 负责用户交互和数据展示。
- **服务端层**: 核心业务逻辑处理中心。通过API网关统一入口内部按业务垂直划分为多个服务模块。
- **数据与存储层**: 持久化存储数据,提供缓存和搜索能力。
- **第三方服务**: 集成外部服务以完成特定功能。
### 3.2. 模块划分
系统功能将按以下模块进行开发,每个模块对应`src/controllers`, `src/services`下的独立子目录。
1. **`core`**: 核心模块,包括用户、角色、权限、组织、字典等。
2. **`content`**: 内容模块,包括笔记、博客、评论、分类、标签等。
3. **`space`**: 个人空间模块,包括生活日志、社交互动。
@ -145,7 +157,9 @@ graph TD
6. **`system`**: 系统模块,包括健康检查、监控、配置管理。
### 3.3. 详细设计规划
本概要设计完成后,将对每个模块进行详细设计,产出物包括:
- **数据库设计文档**: E-R图、表结构定义字段、类型、约束、索引、数据字典。
- **API接口设计文档**: 使用Swagger/OpenAPI规范定义每个端点的URL、HTTP方法、请求参数、响应体结构及错误码。
- **UI/UX设计稿**: 针对核心页面和流程,制作线框图或高保真原型。
@ -155,6 +169,7 @@ graph TD
## 4. 实现与编码
### 4.1. 开发环境与工具
- **IDE**: Visual Studio Code
- **语言**: TypeScript
- **运行时**: Bun.js
@ -163,12 +178,15 @@ graph TD
- **代码检查与格式化**: ESLint / Prettier
### 4.2. 编码规范
- 严格遵守项目已定义的注释、命名、代码风格规范。
- 所有业务逻辑必须在 `services` 层实现,`controllers` 层只负责路由和数据校验。
- 禁止在代码中硬编码配置项(如密钥、端口),所有配置通过环境变量或配置文件注入。
### 4.3. 版本控制策略
采用 **Gitflow工作流** 的简化版:
- `main`: 主分支,存放稳定、可发布的代码。每个里程碑完成后合并。
- `develop`: 开发分支,集成了所有已完成的功能。
- `feat/feature-name`: 功能分支,每个新功能或任务都在此分支开发,完成后合并到 `develop`
@ -179,12 +197,14 @@ graph TD
## 5. 测试策略
### 5.1. 测试层次
- **单元测试**: 使用 `Vitest``services``utils` 中的核心函数进行测试,目标覆盖率 > 90%。
- **接口测试 (集成测试)**: 使用 `supertest` 或Elysia的内置测试工具对每个API端点进行测试验证其与数据库、缓存的交互是否正确。
- **端到端测试 (系统测试)**: 使用 `Playwright``Cypress` 对关键用户流程(如注册登录、发布博客)进行自动化测试。
- **性能测试**: 使用 `autocannon` 对核心API进行压力测试确保其满足技术指标。
### 5.2. 测试执行
- 所有代码提交前,必须在本地通过相关单元测试和接口测试。
- CI/CD流水线将在每次向 `develop``main` 分支合并代码时,自动运行全量测试用例。测试不通过则禁止合并。
@ -193,17 +213,21 @@ graph TD
## 6. 部署与运维
### 6.1. 部署流程 (CI/CD)
使用 **GitHub Actions** 自动化构建、测试和部署流程。
1. **Push to `feat/*`**: 触发ESLint检查和单元测试。
2. **Merge to `develop`**: 触发全量测试构建Docker镜像并推送到镜像仓库然后部署到 **Staging (预发布)** 环境。
3. **Merge to `main`**: 触发全量测试构建生产Docker镜像并部署到 **Production (生产)** 环境。
### 6.2. 基础设施
- **运行环境**: Docker容器。
- **容器编排**: Docker Compose (初期) / Kubernetes (未来扩展)。
- **数据库/缓存**: 使用云服务商提供的托管服务或在Docker中自建。
### 6.3. 运维监控
- **日志**: 使用 `pino` 记录结构化日志并聚合到统一的日志管理平台如ELK Stack或Loki
- **监控与告警**: 使用 `Prometheus` 收集应用指标,`Grafana` 进行可视化展示并针对关键指标如API错误率、延迟设置告警。

View File

@ -1,7 +1,9 @@
# QQ邮箱配置指南
## 🚨 问题原因
错误 `550 The "From" header is missing or invalid` 是因为QQ邮箱要求
1. **From字段的邮箱地址必须与SMTP认证用户名完全一致**
2. **From字段格式必须符合RFC5322标准**
@ -41,6 +43,7 @@ EMAIL_REPLY_TO=your_qq_email@qq.com
### 第三步:替换为你的真实信息
**示例配置:**
```env
SMTP_HOST=smtp.qq.com
SMTP_PORT=587
@ -73,16 +76,21 @@ bun run src/tests/demo/emailDemo.ts your_receive_email@example.com
## 🔧 常见问题
### Q: 为什么要用授权码而不是QQ密码
A: QQ邮箱的安全策略第三方应用必须使用授权码
### Q: 授权码在哪里生成?
A: QQ邮箱设置 → 账户 → 开启IMAP/SMTP服务时生成
### Q: 为什么From地址必须与SMTP_USER一致
A: QQ邮箱的反欺诈机制防止伪造发件人
### Q: 可以使用其他邮箱服务吗?
A: 可以修改SMTP_HOST即可
- 163邮箱`smtp.163.com`
- Gmail`smtp.gmail.com`
- 企业邮箱:根据提供商配置

View File

@ -3,11 +3,7 @@
* 运行方式: bun run quick-email-test.ts your@email.com
*/
import {
initializeEmailService,
sendEmail,
closeEmailService
} from './src/plugins/email/email.service';
import { initializeEmailService, sendEmail, closeEmailService } from './src/plugins/email/email.service';
async function quickTest() {
const testEmail = process.argv[2];
@ -36,7 +32,7 @@ async function quickTest() {
<h2>🎉 </h2>
<p></p>
<p><small>发送时间: ${new Date().toLocaleString('zh-CN')}</small></p>
`
`,
});
if (result.success) {
@ -47,7 +43,6 @@ async function quickTest() {
console.log('❌ 邮件发送失败');
console.log(`💥 错误: ${result.error}`);
}
} catch (error) {
console.log('💥 执行失败:', error);
} finally {

View File

@ -18,20 +18,6 @@ import { plugins } from '@/plugins/index';
// 格式化路由
import { formatRoute } from '@/utils/formatRoute';
/**
*
* @description
*/
class AuthenticationError extends Error {
constructor(message: string, code = 500) {
super(message);
this.name = 'AuthenticationError';
if (code === 401) {
this.name = 'Unauthorized';
}
}
}
/**
* Elysia应用实例
* @description

View File

@ -7,7 +7,6 @@
* @description JWT密钥和过期时间token配置
*/
/**
* JWT基础配置
* @property {string} secret - JWT签名密钥

View File

@ -28,9 +28,11 @@ export const tags = {
permission: 'Permission',
/** 验证码相关接口 */
captcha: 'Captcha',
/** 字典管理接口 */
dict: 'Dict',
} as const;
/**
*
*/
export type ApiTag = typeof tags[keyof typeof tags];
export type ApiTag = (typeof tags)[keyof typeof tags];

View File

@ -14,14 +14,16 @@
import { customType } from 'drizzle-orm/mysql-core';
// 写入读取是将bigint转化为string
export const bigintString = customType({
export const bigintString = customType<{ data: string; driverData: bigint }>({
dataType() {
return 'bigint';
},
fromDriver(value) { // 数据库 -> JS
return value?.toString(); // 处理 null 值
fromDriver(value) {
// 数据库 -> JS
return value?.toString();
},
toDriver(value) { // JS -> 数据库
toDriver(value) {
// JS -> 数据库
return BigInt(value as string); // 确保写入时为数字类型
}
},
});

View File

@ -1,288 +1,323 @@
import { mysqlTable, mysqlSchema, AnyMySqlColumn, index, primaryKey, unique, varchar, text, int, json, datetime, tinyint, date } from "drizzle-orm/mysql-core"
import { sql } from "drizzle-orm"
import { bigintString as bigint } from "./customType"
import {
mysqlTable,
index,
primaryKey,
unique,
varchar,
int,
json,
timestamp,
text,
datetime,
tinyint,
date,
} from 'drizzle-orm/mysql-core';
import { sql } from 'drizzle-orm';
import { bigintString as bigint } from './customType';
export const sysDictItems = mysqlTable("sys_dict_items", {
id: bigint({ mode: "number" }).notNull(),
typeId: bigint("type_id", { mode: "number" }).notNull(),
itemKey: varchar("item_key", { length: 50 }).notNull(),
itemValue: varchar("item_value", { length: 200 }).notNull(),
label: varchar({ length: 100 }).notNull(),
labelEn: varchar("label_en", { length: 200 }),
description: text(),
pid: bigint({ mode: "number" }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
cssClass: varchar("css_class", { length: 50 }),
color: varchar({ length: 50 }),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_key").on(table.itemKey),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.typeId, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type_id").on(table.typeId),
primaryKey({ columns: [table.id], name: "sys_dict_items_id"}),
unique("uk_type_key").on(table.typeId, table.itemKey, table.deletedAt),
]);
export const sysDictTypes = mysqlTable("sys_dict_types", {
id: bigint({ mode: "number" }).notNull(),
export const sysDict = mysqlTable(
'sys_dict',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 50 }).notNull(),
name: varchar({ length: 100 }).notNull(),
description: text(),
pid: bigint({ mode: "number" }),
path: varchar({ length: 500 }),
value: varchar({ length: 200 }),
description: varchar({ length: 500 }),
icon: varchar({ length: 100 }),
pid: bigint({ mode: 'number' }),
level: int().default(1).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
isSystem: tinyint("is_system").default(0).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
isSystem: tinyint('is_system').default(0).notNull(),
color: varchar({ length: 20 }),
extra: json(),
createdAt: timestamp('created_at', { mode: 'string' }).defaultNow().notNull(),
updatedAt: timestamp('updated_at', { mode: 'string' }).defaultNow().onUpdateNow().notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_system").on(table.isSystem),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_dict_types_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_level').on(table.level),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.sortOrder),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_dict_id' }),
unique('uk_code').on(table.code),
],
);
export const sysOperationLogs = mysqlTable("sys_operation_logs", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }),
export const sysOperationLogs = mysqlTable(
'sys_operation_logs',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }),
username: varchar({ length: 100 }),
module: varchar({ length: 50 }).notNull(),
action: varchar({ length: 50 }).notNull(),
target: varchar({ length: 200 }),
targetId: bigint("target_id", { mode: "number" }),
requestData: text("request_data"),
responseData: text("response_data"),
targetId: bigint('target_id', { mode: 'number' }),
requestData: text('request_data'),
responseData: text('response_data'),
status: varchar({ length: 20 }).notNull(),
ip: varchar({ length: 45 }),
userAgent: varchar("user_agent", { length: 200 }),
duration: bigint({ mode: "number" }),
errorMsg: text("error_msg"),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
userAgent: varchar('user_agent', { length: 200 }),
duration: bigint({ mode: 'number' }),
errorMsg: text('error_msg'),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_ip").on(table.ip),
index("idx_module_action").on(table.module, table.action),
index("idx_status").on(table.status),
index("idx_target").on(table.targetId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_operation_logs_id"}),
]);
index('idx_created_at').on(table.createdAt),
index('idx_ip').on(table.ip),
index('idx_module_action').on(table.module, table.action),
index('idx_status').on(table.status),
index('idx_target').on(table.targetId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_operation_logs_id' }),
],
);
export const sysOrganizations = mysqlTable("sys_organizations", {
id: bigint({ mode: "number" }).notNull(),
export const sysOrganizations = mysqlTable(
'sys_organizations',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 100 }).notNull(),
name: varchar({ length: 200 }).notNull(),
fullName: varchar("full_name", { length: 200 }),
fullName: varchar('full_name', { length: 200 }),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
type: varchar({ length: 20 }),
status: varchar({ length: 20 }).default('active').notNull(),
sortOrder: int("sort_order").default(0).notNull(),
leaderId: bigint("leader_id", { mode: "number" }),
sortOrder: int('sort_order').default(0).notNull(),
leaderId: bigint('leader_id', { mode: 'number' }),
address: varchar({ length: 200 }),
phone: varchar({ length: 50 }),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_leader_id").on(table.leaderId),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type").on(table.type),
primaryKey({ columns: [table.id], name: "sys_organizations_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_leader_id').on(table.leaderId),
index('idx_name').on(table.name),
index('idx_path').on(table.path),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
index('idx_type').on(table.type),
primaryKey({ columns: [table.id], name: 'sys_organizations_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysPermissions = mysqlTable("sys_permissions", {
id: bigint({ mode: "number" }).notNull(),
export const sysPermissions = mysqlTable(
'sys_permissions',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 100 }).notNull(),
name: varchar({ length: 100 }).notNull(),
type: varchar({ length: 20 }).notNull(),
resource: varchar({ length: 50 }),
action: varchar({ length: 50 }),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
meta: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_pid").on(table.pid),
index("idx_resource_action").on(table.resource, table.action),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
index("idx_type").on(table.type),
primaryKey({ columns: [table.id], name: "sys_permissions_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_pid').on(table.pid),
index('idx_resource_action').on(table.resource, table.action),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
index('idx_type').on(table.type),
primaryKey({ columns: [table.id], name: 'sys_permissions_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysRolePermissions = mysqlTable("sys_role_permissions", {
id: bigint({ mode: "number" }).notNull(),
roleId: bigint("role_id", { mode: "number" }).notNull(),
permissionId: bigint("permission_id", { mode: "number" }).notNull(),
isHalf: tinyint("is_half").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysRolePermissions = mysqlTable(
'sys_role_permissions',
{
id: bigint({ mode: 'number' }).notNull(),
roleId: bigint('role_id', { mode: 'number' }).notNull(),
permissionId: bigint('permission_id', { mode: 'number' }).notNull(),
isHalf: tinyint('is_half').default(0).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_is_half").on(table.isHalf),
index("idx_permission_id").on(table.permissionId),
index("idx_role_id").on(table.roleId),
primaryKey({ columns: [table.id], name: "sys_role_permissions_id"}),
unique("uk_role_permission").on(table.roleId, table.permissionId),
]);
index('idx_is_half').on(table.isHalf),
index('idx_permission_id').on(table.permissionId),
index('idx_role_id').on(table.roleId),
primaryKey({ columns: [table.id], name: 'sys_role_permissions_id' }),
unique('uk_role_permission').on(table.roleId, table.permissionId),
],
);
export const sysRoles = mysqlTable("sys_roles", {
id: bigint({ mode: "number" }).notNull(),
export const sysRoles = mysqlTable(
'sys_roles',
{
id: bigint({ mode: 'number' }).notNull(),
code: varchar({ length: 50 }).notNull(),
name: varchar({ length: 100 }).notNull(),
description: text(),
pid: bigint({ mode: "number" }),
pid: bigint({ mode: 'number' }),
path: varchar({ length: 500 }),
level: int().default(1).notNull(),
sortOrder: int("sort_order").default(0).notNull(),
sortOrder: int('sort_order').default(0).notNull(),
status: varchar({ length: 20 }).default('active').notNull(),
isSystem: tinyint("is_system").default(0).notNull(),
permissionsSnapshot: json("permissions_snapshot"),
isSystem: tinyint('is_system').default(0).notNull(),
permissionsSnapshot: json('permissions_snapshot'),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_system").on(table.isSystem),
index("idx_name").on(table.name),
index("idx_path").on(table.path),
index("idx_pid").on(table.pid),
index("idx_sort").on(table.pid, table.sortOrder),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_roles_id"}),
unique("uk_code").on(table.code, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_is_system').on(table.isSystem),
index('idx_name').on(table.name),
index('idx_path').on(table.path),
index('idx_pid').on(table.pid),
index('idx_sort').on(table.pid, table.sortOrder),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_roles_id' }),
unique('uk_code').on(table.code, table.deletedAt),
],
);
export const sysTags = mysqlTable("sys_tags", {
id: bigint({ mode: "number" }).notNull(),
export const sysTags = mysqlTable(
'sys_tags',
{
id: bigint({ mode: 'number' }).notNull(),
name: varchar({ length: 50 }).notNull(),
type: varchar({ length: 50 }).default('user'),
color: varchar({ length: 50 }),
description: text(),
usageCount: int("usage_count").default(0).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
usageCount: int('usage_count').default(0).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
},
(table) => [
index("idx_deleted_at").on(table.deletedAt),
index("idx_name").on(table.name),
index("idx_type").on(table.type),
index("idx_usage_count").on(table.usageCount),
primaryKey({ columns: [table.id], name: "sys_tags_id"}),
unique("uk_name_type").on(table.name, table.type, table.deletedAt),
]);
index('idx_deleted_at').on(table.deletedAt),
index('idx_name').on(table.name),
index('idx_type').on(table.type),
index('idx_usage_count').on(table.usageCount),
primaryKey({ columns: [table.id], name: 'sys_tags_id' }),
unique('uk_name_type').on(table.name, table.type, table.deletedAt),
],
);
export const sysUserOrganizations = mysqlTable("sys_user_organizations", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
organizationId: bigint("organization_id", { mode: "number" }).notNull(),
isPrimary: tinyint("is_primary").default(0).notNull(),
export const sysUserOrganizations = mysqlTable(
'sys_user_organizations',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
organizationId: bigint('organization_id', { mode: 'number' }).notNull(),
isPrimary: tinyint('is_primary').default(0).notNull(),
position: varchar({ length: 100 }),
joinedAt: datetime("joined_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
joinedAt: datetime('joined_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_is_primary").on(table.isPrimary),
index("idx_joined_at").on(table.joinedAt),
index("idx_organization_id").on(table.organizationId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_organizations_id"}),
unique("uk_user_org").on(table.userId, table.organizationId),
]);
index('idx_is_primary').on(table.isPrimary),
index('idx_joined_at').on(table.joinedAt),
index('idx_organization_id').on(table.organizationId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_organizations_id' }),
unique('uk_user_org').on(table.userId, table.organizationId),
],
);
export const sysUserRoles = mysqlTable("sys_user_roles", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
roleId: bigint("role_id", { mode: "number" }).notNull(),
expiredAt: datetime("expired_at", { mode: 'string'}),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysUserRoles = mysqlTable(
'sys_user_roles',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
roleId: bigint('role_id', { mode: 'number' }).notNull(),
expiredAt: datetime('expired_at', { mode: 'string' }),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_expired_at").on(table.expiredAt),
index("idx_role_id").on(table.roleId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_roles_id"}),
unique("uk_user_role").on(table.userId, table.roleId),
]);
index('idx_created_at').on(table.createdAt),
index('idx_expired_at').on(table.expiredAt),
index('idx_role_id').on(table.roleId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_roles_id' }),
unique('uk_user_role').on(table.userId, table.roleId),
],
);
export const sysUserTags = mysqlTable("sys_user_tags", {
id: bigint({ mode: "number" }).notNull(),
userId: bigint("user_id", { mode: "number" }).notNull(),
tagId: bigint("tag_id", { mode: "number" }).notNull(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
export const sysUserTags = mysqlTable(
'sys_user_tags',
{
id: bigint({ mode: 'number' }).notNull(),
userId: bigint('user_id', { mode: 'number' }).notNull(),
tagId: bigint('tag_id', { mode: 'number' }).notNull(),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_tag_id").on(table.tagId),
index("idx_user_id").on(table.userId),
primaryKey({ columns: [table.id], name: "sys_user_tags_id"}),
unique("uk_user_tag").on(table.userId, table.tagId),
]);
index('idx_created_at').on(table.createdAt),
index('idx_tag_id').on(table.tagId),
index('idx_user_id').on(table.userId),
primaryKey({ columns: [table.id], name: 'sys_user_tags_id' }),
unique('uk_user_tag').on(table.userId, table.tagId),
],
);
export const sysUsers = mysqlTable("sys_users", {
id: bigint({ mode: "number" }).notNull(),
export const sysUsers = mysqlTable(
'sys_users',
{
id: bigint({ mode: 'number' }).notNull(),
username: varchar({ length: 50 }).notNull(),
email: varchar({ length: 100 }).notNull(),
mobile: varchar({ length: 20 }),
passwordHash: varchar("password_hash", { length: 255 }).notNull(),
passwordHash: varchar('password_hash', { length: 255 }).notNull(),
avatar: varchar({ length: 255 }),
nickname: varchar({ length: 100 }),
status: varchar({ length: 20 }).default('active').notNull(),
@ -290,28 +325,33 @@ export const sysUsers = mysqlTable("sys_users", {
// you can use { mode: 'date' }, if you want to have Date as type for this column
birthday: date({ mode: 'string' }),
bio: varchar({ length: 500 }),
loginCount: int("login_count").default(0).notNull(),
lastLoginAt: datetime("last_login_at", { mode: 'string'}),
lastLoginIp: varchar("last_login_ip", { length: 45 }),
failedAttempts: int("failed_attempts").default(0).notNull(),
lockedUntil: datetime("locked_until", { mode: 'string'}),
isRoot: tinyint("is_root").default(0).notNull(),
loginCount: int('login_count').default(0).notNull(),
lastLoginAt: datetime('last_login_at', { mode: 'string' }),
lastLoginIp: varchar('last_login_ip', { length: 45 }),
failedAttempts: int('failed_attempts').default(0).notNull(),
lockedUntil: datetime('locked_until', { mode: 'string' }),
isRoot: tinyint('is_root').default(0).notNull(),
extra: json(),
createdBy: bigint("created_by", { mode: "number" }),
createdAt: datetime("created_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
updatedBy: bigint("updated_by", { mode: "number" }),
updatedAt: datetime("updated_at", { mode: 'string'}).default(sql`(CURRENT_TIMESTAMP)`).notNull(),
deletedAt: datetime("deleted_at", { mode: 'string'}),
createdBy: bigint('created_by', { mode: 'number' }),
createdAt: datetime('created_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
updatedBy: bigint('updated_by', { mode: 'number' }),
updatedAt: datetime('updated_at', { mode: 'string' })
.default(sql`(CURRENT_TIMESTAMP)`)
.notNull(),
deletedAt: datetime('deleted_at', { mode: 'string' }),
version: int().default(1).notNull(),
},
(table) => [
index("idx_created_at").on(table.createdAt),
index("idx_deleted_at").on(table.deletedAt),
index("idx_is_root").on(table.isRoot),
index("idx_last_login").on(table.lastLoginAt),
index("idx_mobile").on(table.mobile),
index("idx_status").on(table.status),
primaryKey({ columns: [table.id], name: "sys_users_id"}),
unique("uk_email").on(table.email, table.deletedAt),
unique("uk_username").on(table.username, table.deletedAt),
]);
index('idx_created_at').on(table.createdAt),
index('idx_deleted_at').on(table.deletedAt),
index('idx_is_root').on(table.isRoot),
index('idx_last_login').on(table.lastLoginAt),
index('idx_mobile').on(table.mobile),
index('idx_status').on(table.status),
primaryKey({ columns: [table.id], name: 'sys_users_id' }),
unique('uk_email').on(table.email, table.deletedAt),
unique('uk_username').on(table.username, table.deletedAt),
],
);

View File

@ -8,8 +8,22 @@
*/
import { Elysia } from 'elysia';
import { RegisterSchema, ActivateSchema, LoginSchema, RefreshSchema, ResetPasswordRequestSchema, ResetPasswordConfirmSchema } from './auth.schema';
import { RegisterResponsesSchema, ActivateResponsesSchema, LoginResponsesSchema, RefreshResponsesSchema, ResetPasswordRequestResponsesSchema, ResetPasswordConfirmResponsesSchema } from './auth.response';
import {
RegisterSchema,
ActivateSchema,
LoginSchema,
RefreshSchema,
ResetPasswordRequestSchema,
ResetPasswordConfirmSchema,
} from './auth.schema';
import {
RegisterResponsesSchema,
ActivateResponsesSchema,
LoginResponsesSchema,
RefreshResponsesSchema,
ResetPasswordRequestResponsesSchema,
ResetPasswordConfirmResponsesSchema,
} from './auth.response';
import { authService } from './auth.service';
import { tags } from '@/constants/swaggerTags';
@ -25,10 +39,7 @@ export const authController = new Elysia()
* @param body RegisterRequest
* @returns RegisterSuccessResponse | RegisterErrorResponse
*/
.post(
'/register',
({ body, set }) => authService.register(body),
{
.post('/register', ({ body }) => authService.register(body), {
body: RegisterSchema,
detail: {
summary: '用户注册',
@ -37,8 +48,7 @@ export const authController = new Elysia()
operationId: 'registerUser',
},
response: RegisterResponsesSchema,
}
)
})
/**
*
@ -47,10 +57,7 @@ export const authController = new Elysia()
* @param body ActivateRequest
* @returns ActivateSuccessResponse | ActivateErrorResponse
*/
.post(
'/activate',
({ body, set }) => authService.activate(body),
{
.post('/activate', ({ body }) => authService.activate(body), {
body: ActivateSchema,
detail: {
summary: '邮箱激活',
@ -59,8 +66,7 @@ export const authController = new Elysia()
operationId: 'activateUser',
},
response: ActivateResponsesSchema,
}
)
})
/**
*
@ -69,10 +75,7 @@ export const authController = new Elysia()
* @param body LoginRequest
* @returns LoginSuccessResponse | LoginErrorResponse
*/
.post(
'/login',
({ body, set }) => authService.login(body),
{
.post('/login', ({ body }) => authService.login(body), {
body: LoginSchema,
detail: {
summary: '用户登录',
@ -81,8 +84,7 @@ export const authController = new Elysia()
operationId: 'loginUser',
},
response: LoginResponsesSchema,
}
)
})
/**
* Token刷新接口
@ -91,10 +93,7 @@ export const authController = new Elysia()
* @param body RefreshRequest
* @returns RefreshSuccessResponse | RefreshErrorResponse
*/
.post(
'/refresh',
({ body, set }) => authService.refresh(body),
{
.post('/refresh', ({ body }) => authService.refresh(body), {
body: RefreshSchema,
detail: {
summary: 'Token刷新',
@ -103,8 +102,7 @@ export const authController = new Elysia()
operationId: 'refreshToken',
},
response: RefreshResponsesSchema,
}
)
})
/**
*
@ -113,10 +111,7 @@ export const authController = new Elysia()
* @param body ResetPasswordRequestRequest
* @returns ResetPasswordRequestSuccessResponse | ResetPasswordRequestErrorResponse
*/
.post(
'/password/reset-request',
({ body, set }) => authService.resetPasswordRequest(body),
{
.post('/password/reset-request', ({ body }) => authService.resetPasswordRequest(body), {
body: ResetPasswordRequestSchema,
detail: {
summary: '找回密码',
@ -125,8 +120,7 @@ export const authController = new Elysia()
operationId: 'resetPasswordRequest',
},
response: ResetPasswordRequestResponsesSchema,
}
)
})
/**
*
@ -135,10 +129,7 @@ export const authController = new Elysia()
* @param body ResetPasswordConfirmRequest
* @returns ResetPasswordConfirmSuccessResponse | ResetPasswordConfirmErrorResponse
*/
.post(
'/password/reset-confirm',
({ body, set }) => authService.resetPasswordConfirm(body),
{
.post('/password/reset-confirm', ({ body }) => authService.resetPasswordConfirm(body), {
body: ResetPasswordConfirmSchema,
detail: {
summary: '重置密码',
@ -147,5 +138,4 @@ export const authController = new Elysia()
operationId: 'resetPasswordConfirm',
},
response: ResetPasswordConfirmResponsesSchema,
}
);
});

View File

@ -17,36 +17,38 @@ import { responseWrapperSchema } from '@/utils/responseFormate';
* @description Controller中定义所有可能的响应格式
*/
export const RegisterResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 邮箱地址 */
email: t.String({
description: '邮箱地址',
examples: ['user@example.com']
examples: ['user@example.com'],
}),
/** 账号状态 */
status: t.String({
description: '账号状态',
examples: ['pending', 'active']
examples: ['pending', 'active'],
}),
/** 创建时间 */
createdAt: t.String({
description: '创建时间',
examples: ['2024-12-19T10:30:00Z']
})
})),
examples: ['2024-12-19T10:30:00Z'],
}),
}),
),
};
/** 用户注册成功响应数据类型 */
export type RegisterResponsesType = Static<typeof RegisterResponsesSchema[200]>;
export type RegisterResponsesType = Static<(typeof RegisterResponsesSchema)[200]>;
// ========== 邮箱激活相关响应格式 ==========
@ -55,42 +57,44 @@ export type RegisterResponsesType = Static<typeof RegisterResponsesSchema[200]>;
* @description Controller中定义所有可能的响应格式
*/
export const ActivateResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 邮箱地址 */
email: t.String({
description: '邮箱地址',
examples: ['user@example.com']
examples: ['user@example.com'],
}),
/** 账号状态 */
status: t.String({
description: '账号状态',
examples: ['active']
examples: ['active'],
}),
/** 激活时间 */
updatedAt: t.String({
description: '激活时间',
examples: ['2024-12-19T10:30:00Z']
examples: ['2024-12-19T10:30:00Z'],
}),
/** 激活成功标识 */
activated: t.Boolean({
description: '是否已激活',
examples: [true]
})
})),
examples: [true],
}),
}),
),
};
/** 邮箱激活成功响应数据类型 */
export type ActivateSuccessType = Static<typeof ActivateResponsesSchema[200]>;
export type ActivateSuccessType = Static<(typeof ActivateResponsesSchema)[200]>;
// ========== 用户登录相关响应格式 ==========
@ -99,68 +103,70 @@ export type ActivateSuccessType = Static<typeof ActivateResponsesSchema[200]>;
* @description Controller中定义所有可能的响应格式
*/
export const LoginResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 用户基本信息 */
user: t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 邮箱地址 */
email: t.String({
description: '邮箱地址',
examples: ['user@example.com']
examples: ['user@example.com'],
}),
/** 账号状态 */
status: t.String({
description: '账号状态',
examples: ['active']
examples: ['active'],
}),
/** 最后登录时间 */
lastLoginAt: t.Union([t.String(), t.Null()], {
description: '最后登录时间',
examples: ['2024-12-19T10:30:00Z', null]
})
examples: ['2024-12-19T10:30:00Z', null],
}),
}),
/** 认证令牌信息 */
tokens: t.Object({
/** 访问令牌 */
accessToken: t.String({
description: 'JWT访问令牌',
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'],
}),
/** 刷新令牌 */
refreshToken: t.String({
description: 'JWT刷新令牌',
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'],
}),
/** 令牌类型 */
tokenType: t.String({
description: '令牌类型',
examples: ['Bearer']
examples: ['Bearer'],
}),
/** 过期时间(秒) */
expiresIn: t.String({
description: '访问令牌过期时间(秒)',
examples: [7200, 86400]
examples: [7200, 86400],
}),
/** 刷新令牌过期时间(秒) */
refreshExpiresIn: t.String({
description: '刷新令牌过期时间(秒)',
examples: [2592000]
})
})
})),
examples: [2592000],
}),
}),
}),
),
};
/** 用户登录成功响应数据类型 */
export type LoginSuccessType = Static<typeof LoginResponsesSchema[200]>;
export type LoginSuccessType = Static<(typeof LoginResponsesSchema)[200]>;
// ========== Token刷新相关响应格式 ==========
@ -169,45 +175,47 @@ export type LoginSuccessType = Static<typeof LoginResponsesSchema[200]>;
* @description Controller中定义所有可能的响应格式
*/
export const RefreshResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 认证令牌信息 */
tokens: t.Object({
/** 访问令牌 */
accessToken: t.String({
description: 'JWT访问令牌',
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'],
}),
/** 刷新令牌 */
refreshToken: t.String({
description: 'JWT刷新令牌',
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'],
}),
/** 令牌类型 */
tokenType: t.String({
description: '令牌类型',
examples: ['Bearer']
examples: ['Bearer'],
}),
/** 过期时间(秒) */
expiresIn: t.String({
description: '访问令牌过期时间(秒)',
examples: [7200, 86400]
examples: [7200, 86400],
}),
/** 刷新令牌过期时间(秒) */
refreshExpiresIn: t.String({
description: '刷新令牌过期时间(秒)',
examples: [2592000]
})
examples: [2592000],
}),
}),
/** 刷新时间 */
refreshedAt: t.String({
description: '令牌刷新时间',
examples: ['2024-12-19T10:30:00Z']
})
})),
examples: ['2024-12-19T10:30:00Z'],
}),
}),
),
};
/** Token刷新成功响应数据类型 */
export type RefreshSuccessType = Static<typeof RefreshResponsesSchema[200]>;
export type RefreshSuccessType = Static<(typeof RefreshResponsesSchema)[200]>;
// ========== 找回密码相关响应格式 ==========
@ -216,37 +224,39 @@ export type RefreshSuccessType = Static<typeof RefreshResponsesSchema[200]>;
* @description Controller中定义所有可能的响应格式
*/
export const ResetPasswordRequestResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 邮箱地址 */
email: t.String({
description: '发送重置邮件的邮箱地址',
examples: ['user@example.com', 'admin@company.com']
examples: ['user@example.com', 'admin@company.com'],
}),
/** 发送状态 */
sent: t.Boolean({
description: '邮件发送状态',
examples: [true]
examples: [true],
}),
/** 发送时间 */
sentAt: t.String({
description: '邮件发送时间',
examples: ['2024-12-19T10:30:00Z']
examples: ['2024-12-19T10:30:00Z'],
}),
/** 重置链接有效期(分钟) */
expiresIn: t.Number({
description: '重置链接有效期(分钟)',
examples: [30, 60]
examples: [30, 60],
}),
/** 提示信息 */
message: t.String({
description: '操作提示信息',
examples: ['重置邮件已发送,请查收邮箱']
})
})),
examples: ['重置邮件已发送,请查收邮箱'],
}),
}),
),
};
/** 找回密码成功响应数据类型 */
export type ResetPasswordRequestSuccessType = Static<typeof ResetPasswordRequestResponsesSchema[200]>;
export type ResetPasswordRequestSuccessType = Static<(typeof ResetPasswordRequestResponsesSchema)[200]>;
// ========== 重置密码相关响应格式 ==========
@ -255,39 +265,41 @@ export type ResetPasswordRequestSuccessType = Static<typeof ResetPasswordRequest
* @description Controller中定义所有可能的响应格式
*/
export const ResetPasswordConfirmResponsesSchema = {
200: responseWrapperSchema(t.Object({
200: responseWrapperSchema(
t.Object({
/** 用户ID */
id: t.String({
description: '用户IDbigint类型以字符串形式返回防止精度丢失',
examples: ['1', '2', '3']
examples: ['1', '2', '3'],
}),
/** 用户名 */
username: t.String({
description: '用户名',
examples: ['admin', 'testuser']
examples: ['admin', 'testuser'],
}),
/** 邮箱地址 */
email: t.String({
description: '邮箱地址',
examples: ['user@example.com']
examples: ['user@example.com'],
}),
/** 密码更新时间 */
updatedAt: t.String({
description: '密码更新时间',
examples: ['2024-12-19T10:30:00Z']
examples: ['2024-12-19T10:30:00Z'],
}),
/** 重置成功标识 */
reset: t.Boolean({
description: '密码重置是否成功',
examples: [true]
examples: [true],
}),
/** 提示信息 */
message: t.String({
description: '操作提示信息',
examples: ['密码重置成功,请使用新密码登录']
})
})),
examples: ['密码重置成功,请使用新密码登录'],
}),
}),
),
};
/** 重置密码成功响应数据类型 */
export type ResetPasswordConfirmSuccessType = Static<typeof ResetPasswordConfirmResponsesSchema[200]>;
export type ResetPasswordConfirmSuccessType = Static<(typeof ResetPasswordConfirmResponsesSchema)[200]>;

View File

@ -19,34 +19,34 @@ export const RegisterSchema = t.Object({
minLength: 2,
maxLength: 50,
description: '用户名2-50字符',
examples: ['root', 'testuser']
examples: ['root', 'testuser'],
}),
/** 邮箱地址对应sys_users.email */
email: t.String({
format: 'email',
maxLength: 100,
description: '邮箱地址',
examples: ['x71291@outlook.com']
examples: ['x71291@outlook.com'],
}),
/** 密码6-50字符 */
password: t.String({
minLength: 6,
maxLength: 50,
description: '密码6-50字符',
examples: ['password123']
examples: ['password123'],
}),
/** 图形验证码 */
captcha: t.String({
minLength: 4,
maxLength: 6,
description: '图形验证码',
examples: ['a1b2']
examples: ['a1b2'],
}),
/** 验证码会话ID */
captchaId: t.String({
description: '验证码会话ID',
examples: ['cap']
})
examples: ['cap'],
}),
});
/**
@ -59,8 +59,8 @@ export const ActivateSchema = t.Object({
minLength: 10,
maxLength: 1000,
description: '邮箱激活令牌JWT格式24小时有效',
examples: ['eyJhbGciOiJIUzI1NiI']
})
examples: ['eyJhbGciOiJIUzI1NiI'],
}),
});
/**
@ -73,33 +73,39 @@ export const LoginSchema = t.Object({
minLength: 2,
maxLength: 100,
description: '用户名/邮箱地址100字符',
examples: ['root', 'testuser', 'x71291@outlook.com']
examples: ['root', 'testuser', 'x71291@outlook.com'],
}),
/** 图形验证码(可选) */
captcha: t.Optional(t.String({
captcha: t.Optional(
t.String({
minLength: 4,
maxLength: 6,
description: '图形验证码,登录失败次数过多时需要',
examples: ['a1b2']
})),
examples: ['a1b2'],
}),
),
/** 密码6-50字符 */
password: t.String({
minLength: 6,
maxLength: 50,
description: '密码6-50字符',
examples: ['password123']
examples: ['password123'],
}),
/** 验证码会话ID可选 */
captchaId: t.Optional(t.String({
captchaId: t.Optional(
t.String({
description: '验证码会话ID与captcha配对使用',
examples: ['cap']
})),
examples: ['cap'],
}),
),
/** 是否记住登录状态 */
rememberMe: t.Optional(t.Boolean({
rememberMe: t.Optional(
t.Boolean({
description: '是否记住登录状态影响token过期时间',
examples: [true, false],
default: false
}))
default: false,
}),
),
});
/**
@ -112,8 +118,8 @@ export const RefreshSchema = t.Object({
minLength: 10,
maxLength: 1000,
description: '刷新令牌JWT格式用于获取新的访问令牌',
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...']
})
examples: ['eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'],
}),
});
/**
@ -126,20 +132,20 @@ export const ResetPasswordRequestSchema = t.Object({
format: 'email',
maxLength: 100,
description: '注册时使用的邮箱地址',
examples: ['user@example.com', 'admin@company.com']
examples: ['user@example.com', 'admin@company.com'],
}),
/** 图形验证码 */
captcha: t.String({
minLength: 4,
maxLength: 6,
description: '图形验证码',
examples: ['a1b2', '1234']
examples: ['a1b2', '1234'],
}),
/** 验证码会话ID */
captchaId: t.String({
description: '验证码会话ID',
examples: ['cap_123', 'captcha_session']
})
examples: ['cap_123', 'captcha_session'],
}),
});
/**
@ -152,22 +158,22 @@ export const ResetPasswordConfirmSchema = t.Object({
minLength: 10,
maxLength: 1000,
description: '重置密码令牌JWT格式30分钟有效',
examples: ['eyJhbGciOiJIUzI1NiI']
examples: ['eyJhbGciOiJIUzI1NiI'],
}),
/** 新密码6-50字符 */
newPassword: t.String({
minLength: 6,
maxLength: 50,
description: '新密码6-50字符',
examples: ['newpassword123']
examples: ['newpassword123'],
}),
/** 确认新密码,必须与新密码一致 */
confirmPassword: t.String({
minLength: 6,
maxLength: 50,
description: '确认新密码,必须与新密码一致',
examples: ['newpassword123']
})
examples: ['newpassword123'],
}),
});
/** 用户注册请求类型 */

View File

@ -15,16 +15,30 @@
import bcrypt from 'bcrypt';
import { eq, sql } from 'drizzle-orm';
import { db } from '@/plugins/drizzle/drizzle.service';
import { sysUsers } from '@/eneities';
import { sysUsers } from '@/eneities/index';
import { captchaService } from '@/modules/captcha/captcha.service';
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 { DistributedLockService, LOCK_KEYS } from '@/utils/distributedLock';
import type { RegisterRequest, ActivateRequest, LoginRequest, RefreshRequest, ResetPasswordRequestRequest, ResetPasswordConfirmRequest } from './auth.schema';
import type {
RegisterRequest,
ActivateRequest,
LoginRequest,
RefreshRequest,
ResetPasswordRequestRequest,
ResetPasswordConfirmRequest,
} from './auth.schema';
import { successResponse, errorResponse, BusinessError } from '@/utils/responseFormate';
import type { ActivateSuccessType, LoginSuccessType, RegisterResponsesType, RefreshSuccessType, ResetPasswordRequestSuccessType, ResetPasswordConfirmSuccessType } from './auth.response';
import type {
ActivateSuccessType,
LoginSuccessType,
RegisterResponsesType,
RefreshSuccessType,
ResetPasswordRequestSuccessType,
ResetPasswordConfirmSuccessType,
} from './auth.response';
import { TOKEN_TYPES } from '@/type/jwt.type';
/**
@ -51,7 +65,7 @@ export class AuthService {
ttl: 60, // 注册可能需要较长时间(邮件发送等)
timeout: 15000,
autoRenew: true,
renewInterval: 20000 // 20秒续期一次
renewInterval: 20000, // 20秒续期一次
});
try {
@ -71,7 +85,7 @@ export class AuthService {
const newUser = await this.createUser({
username,
email,
passwordHash
passwordHash,
});
// 6. 发送激活邮件
@ -79,14 +93,16 @@ export class AuthService {
Logger.info(`用户注册成功:${newUser.id} - ${newUser.username}`);
return successResponse({
return successResponse(
{
id: newUser.id,
username: newUser.username,
email: newUser.email,
status: newUser.status,
createdAt: newUser.createdAt
}, '用户注册成功,请查收激活邮件');
createdAt: newUser.createdAt,
},
'用户注册成功,请查收激活邮件',
);
} finally {
// 释放锁
await lock.release();
@ -101,14 +117,11 @@ export class AuthService {
private async validateCaptcha(captcha: string, captchaId: string): Promise<void> {
const result = await captchaService.verifyCaptcha({
captchaId,
captchaCode: captcha
captchaCode: captcha,
});
if (!result.data?.valid) {
throw new BusinessError(
result.data?.message || '验证码验证失败',
400
);
throw new BusinessError(result.data?.message || '验证码验证失败', 400);
}
}
@ -117,7 +130,8 @@ export class AuthService {
* @param username
*/
private async checkUsernameExists(username: string): Promise<void> {
const existingUser = await db().select({ id: sysUsers.id })
const existingUser = await db()
.select({ id: sysUsers.id })
.from(sysUsers)
.where(eq(sysUsers.username, username))
.limit(1);
@ -132,7 +146,8 @@ export class AuthService {
* @param email
*/
private async checkEmailExists(email: string): Promise<void> {
const existingUser = await db().select({ id: sysUsers.id })
const existingUser = await db()
.select({ id: sysUsers.id })
.from(sysUsers)
.where(eq(sysUsers.email, email))
.limit(1);
@ -156,11 +171,7 @@ export class AuthService {
* @param userData
* @returns Promise<CreatedUser>
*/
private async createUser(userData: {
username: string;
email: string;
passwordHash: string;
}): Promise<{
private async createUser(userData: { username: string; email: string; passwordHash: string }): Promise<{
id: string;
username: string;
email: string;
@ -177,16 +188,17 @@ export class AuthService {
username,
email,
passwordHash,
status: 'pending' // 新注册用户状态为待激活
status: 'pending', // 新注册用户状态为待激活
});
// 查询刚创建的用户信息
const [newUser] = await db().select({
const [newUser] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
status: sysUsers.status,
createdAt: sysUsers.createdAt
createdAt: sysUsers.createdAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, userId))
@ -203,7 +215,7 @@ export class AuthService {
username: newUser!.username,
email: newUser!.email,
status: newUser!.status,
createdAt: newUser!.createdAt
createdAt: newUser!.createdAt,
};
}
@ -213,7 +225,7 @@ export class AuthService {
* @returns Promise<ActivateSuccessResponse>
*/
public async activate(request: ActivateRequest): Promise<ActivateSuccessType> {
Logger.info(`邮箱激活请求开始处理`);
Logger.info('邮箱激活请求开始处理');
const { token } = request;
@ -228,7 +240,7 @@ export class AuthService {
key: `${LOCK_KEYS.EMAIL_ACTIVATE}:${tokenPayload.userId}`,
ttl: 30,
timeout: 10000,
autoRenew: true
autoRenew: true,
});
try {
@ -248,15 +260,17 @@ export class AuthService {
Logger.info(`邮箱激活成功:${user.id} - ${user.username}`);
return successResponse({
return successResponse(
{
id: updatedUser.id,
username: updatedUser.username,
email: updatedUser.email,
status: updatedUser.status,
updatedAt: updatedUser.updatedAt,
activated: true
}, '邮箱激活成功');
activated: true,
},
'邮箱激活成功',
);
} finally {
// 释放锁
await lock.release();
@ -276,13 +290,14 @@ export class AuthService {
createdAt: string;
updatedAt: string;
}> {
const [user] = await db().select({
const [user] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
status: sysUsers.status,
createdAt: sysUsers.createdAt,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, userId))
@ -298,7 +313,7 @@ export class AuthService {
email: user.email,
status: user.status,
createdAt: user.createdAt,
updatedAt: user.updatedAt
updatedAt: user.updatedAt,
};
}
@ -308,7 +323,10 @@ export class AuthService {
* @param status
* @returns Promise<UpdatedUser>
*/
private async updateUserStatus(userId: string, status: string): Promise<{
private async updateUserStatus(
userId: string,
status: string,
): Promise<{
id: string;
username: string;
email: string;
@ -316,19 +334,21 @@ export class AuthService {
updatedAt: string;
}> {
// 更新用户状态
await db().update(sysUsers)
await db()
.update(sysUsers)
.set({
status: status,
})
.where(eq(sysUsers.id, BigInt(userId)));
// 查询更新后的用户信息
const [updatedUser] = await db().select({
const [updatedUser] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
status: sysUsers.status,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(userId)))
@ -343,7 +363,7 @@ export class AuthService {
username: updatedUser!.username,
email: updatedUser!.email,
status: updatedUser!.status,
updatedAt: updatedUser!.updatedAt
updatedAt: updatedUser!.updatedAt,
};
}
@ -363,7 +383,7 @@ export class AuthService {
key: `${LOCK_KEYS.USER_LOGIN}:${identifier}`,
ttl: 15, // 登录操作通常很快
timeout: 8000,
autoRenew: false // 短期操作不需要续期
autoRenew: false, // 短期操作不需要续期
});
try {
@ -382,12 +402,15 @@ export class AuthService {
this.checkAccountStatus(user);
// 5. 生成JWT令牌
const tokens = jwtService.generateTokens({
const tokens = jwtService.generateTokens(
{
id: user.id,
username: user.username,
email: user.email,
status: user.status
}, rememberMe);
status: user.status,
},
rememberMe,
);
// 6. 更新最后登录时间
await this.updateLastLoginTime(user.id);
@ -397,17 +420,19 @@ export class AuthService {
Logger.info(`用户登录成功:${user.id} - ${user.username}`);
return successResponse({
return successResponse(
{
user: {
id: user.id,
username: user.username,
email: user.email,
status: user.status,
lastLoginAt: user.lastLoginAt
lastLoginAt: user.lastLoginAt,
},
tokens
}, '登录成功');
tokens,
},
'登录成功',
);
} finally {
// 释放锁
await lock.release();
@ -431,17 +456,16 @@ export class AuthService {
const isEmail = identifier.includes('@');
// 构建查询条件
const whereCondition = isEmail
? eq(sysUsers.email, identifier)
: eq(sysUsers.username, identifier);
const whereCondition = isEmail ? eq(sysUsers.email, identifier) : eq(sysUsers.username, identifier);
const [user] = await db().select({
const [user] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
status: sysUsers.status,
passwordHash: sysUsers.passwordHash,
lastLoginAt: sysUsers.lastLoginAt
lastLoginAt: sysUsers.lastLoginAt,
})
.from(sysUsers)
.where(whereCondition)
@ -457,7 +481,7 @@ export class AuthService {
email: user.email,
status: user.status,
passwordHash: user.passwordHash,
lastLoginAt: user.lastLoginAt
lastLoginAt: user.lastLoginAt,
};
}
@ -496,10 +520,11 @@ export class AuthService {
* @param userId ID
*/
private async updateLastLoginTime(userId: string): Promise<void> {
await db().update(sysUsers)
await db()
.update(sysUsers)
.set({
lastLoginAt: sql`NOW()`, // 使用 MySQL 的 NOW() 函数
loginCount: sql`${sysUsers.loginCount} + 1`
loginCount: sql`${sysUsers.loginCount} + 1`,
})
.where(eq(sysUsers.id, BigInt(userId)));
}
@ -529,10 +554,9 @@ export class AuthService {
<h2>${username}</h2>
<p>使</p>
<p>使</p>
`
`,
});
// Logger.info(`激活成功邮件发送成功:${email}`);
} catch (error) {
// 邮件发送失败不影响激活流程,只记录日志
Logger.warn(`激活成功邮件发送失败:${email}, 错误:${error}`);
@ -561,7 +585,7 @@ export class AuthService {
<a href="http://localhost:3000/activate?token=${encodeURIComponent(activationTokenPayload)}"></a>
<p>24</p>
<p></p>
`
`,
});
Logger.info(`激活邮件发送成功:${email}`);
} catch (error) {
@ -576,7 +600,7 @@ export class AuthService {
* @returns Promise<RefreshSuccessResponse>
*/
public async refresh(request: RefreshRequest): Promise<RefreshSuccessType> {
Logger.info(`Token刷新请求开始处理`);
Logger.info('Token刷新请求开始处理');
const { refreshToken } = request;
@ -585,7 +609,7 @@ export class AuthService {
key: `${LOCK_KEYS.TOKEN_REFRESH}:${refreshToken}`,
ttl: 10, // Token刷新操作很快
timeout: 5000,
autoRenew: false // 短期操作不需要续期
autoRenew: false, // 短期操作不需要续期
});
try {
@ -609,16 +633,18 @@ export class AuthService {
id: user.id,
username: user.username,
email: user.email,
status: user.status
status: user.status,
});
// 5. 记录刷新日志
await this.recordRefreshLog(user.id);
return successResponse({
tokens
}, 'Token刷新成功');
return successResponse(
{
tokens,
},
'Token刷新成功',
);
} finally {
// 释放锁
await lock.release();
@ -651,7 +677,7 @@ export class AuthService {
key: `${LOCK_KEYS.PASSWORD_RESET}:${email}`,
ttl: 30,
timeout: 10000,
autoRenew: true
autoRenew: true,
});
try {
@ -672,14 +698,16 @@ export class AuthService {
Logger.info(`找回密码邮件发送成功:${user.id} - ${user.email}`);
return successResponse({
return successResponse(
{
email: user.email,
sent: true,
sentAt: new Date().toISOString(),
expiresIn: 30, // 30分钟有效期
message: '重置邮件已发送,请查收邮箱'
}, '重置邮件已发送,请查收邮箱');
message: '重置邮件已发送,请查收邮箱',
},
'重置邮件已发送,请查收邮箱',
);
} finally {
// 释放锁
await lock.release();
@ -698,11 +726,12 @@ export class AuthService {
email: string;
status: string;
}> {
const [user] = await db().select({
const [user] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
status: sysUsers.status
status: sysUsers.status,
})
.from(sysUsers)
.where(eq(sysUsers.email, email))
@ -716,7 +745,7 @@ export class AuthService {
id: user.id!.toString(),
username: user.username,
email: user.email,
status: user.status
status: user.status,
};
}
@ -754,7 +783,7 @@ export class AuthService {
<p></p>
<p><br></p>
</div>
`
`,
};
await emailService.sendEmail(emailContent);
@ -787,7 +816,7 @@ export class AuthService {
key: `${LOCK_KEYS.PASSWORD_RESET}:${tokenPayload.userId}`,
ttl: 30,
timeout: 10000,
autoRenew: true
autoRenew: true,
});
try {
@ -808,15 +837,17 @@ export class AuthService {
Logger.info(`密码重置成功:${user.id} - ${user.username}`);
return successResponse({
return successResponse(
{
id: updatedUser.id,
username: updatedUser.username,
email: updatedUser.email,
updatedAt: updatedUser.updatedAt,
reset: true,
message: '密码重置成功,请使用新密码登录'
}, '密码重置成功,请使用新密码登录');
message: '密码重置成功,请使用新密码登录',
},
'密码重置成功,请使用新密码登录',
);
} finally {
// 释放锁
await lock.release();
@ -829,24 +860,29 @@ export class AuthService {
* @param newPasswordHash
* @returns Promise<更新后的用户信息>
*/
private async updateUserPassword(userId: string, newPasswordHash: string): Promise<{
private async updateUserPassword(
userId: string,
newPasswordHash: string,
): Promise<{
id: string;
username: string;
email: string;
updatedAt: string;
}> {
await db().update(sysUsers)
await db()
.update(sysUsers)
.set({
passwordHash: newPasswordHash,
})
.where(eq(sysUsers.id, BigInt(userId)));
// 查询更新后的用户信息
const [updatedUser] = await db().select({
const [updatedUser] = await db()
.select({
id: sysUsers.id,
username: sysUsers.username,
email: sysUsers.email,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(userId)))
@ -860,7 +896,7 @@ export class AuthService {
id: updatedUser.id!.toString(),
username: updatedUser.username,
email: updatedUser.email,
updatedAt: updatedUser.updatedAt
updatedAt: updatedUser.updatedAt,
};
}
@ -896,7 +932,7 @@ export class AuthService {
<p></p>
<p><br></p>
</div>
`
`,
};
await emailService.sendEmail(emailContent);

View File

@ -18,6 +18,7 @@
#### 1.1 正常流程测试
**测试用例**: 成功注册新用户
- **请求参数**:
```json
{
@ -38,16 +39,19 @@
#### 1.2 异常流程测试
**测试用例**: 用户名已存在
- **请求参数**: 使用已存在的用户名
- **预期响应**: 400 Bad Request
- **错误信息**: "用户名已存在"
**测试用例**: 邮箱已被注册
- **请求参数**: 使用已注册的邮箱
- **预期响应**: 400 Bad Request
- **错误信息**: "邮箱已被注册"
**测试用例**: 验证码错误
- **请求参数**: 错误的验证码
- **预期响应**: 400 Bad Request
- **错误信息**: "验证码验证失败"
@ -57,6 +61,7 @@
#### 2.1 正常流程测试
**测试用例**: 成功激活用户邮箱
- **请求参数**:
```json
{
@ -71,6 +76,7 @@
#### 2.2 异常流程测试
**测试用例**: 无效的激活令牌
- **请求参数**: 无效或过期的令牌
- **预期响应**: 400 Bad Request
- **错误信息**: "激活令牌无效或已过期"
@ -80,6 +86,7 @@
#### 3.1 正常流程测试
**测试用例**: 用户名登录成功
- **请求参数**:
```json
{
@ -94,6 +101,7 @@
- 登录日志记录
**测试用例**: 邮箱登录成功
- **请求参数**:
```json
{
@ -106,16 +114,19 @@
#### 3.2 异常流程测试
**测试用例**: 用户名不存在
- **请求参数**: 不存在的用户名
- **预期响应**: 404 Not Found
- **错误信息**: "用户不存在"
**测试用例**: 密码错误
- **请求参数**: 错误的密码
- **预期响应**: 401 Unauthorized
- **错误信息**: "用户名或密码错误"
**测试用例**: 账号未激活
- **请求参数**: 未激活用户的凭据
- **预期响应**: 403 Forbidden
- **错误信息**: "账号未激活,请先激活邮箱"
@ -125,6 +136,7 @@
#### 4.1 正常流程测试
**测试用例**: 成功刷新令牌
- **请求参数**:
```json
{
@ -139,6 +151,7 @@
#### 4.2 异常流程测试
**测试用例**: 无效的刷新令牌
- **请求参数**: 无效或过期的刷新令牌
- **预期响应**: 401 Unauthorized
- **错误信息**: "刷新令牌无效或已过期"
@ -148,6 +161,7 @@
#### 5.1 正常流程测试
**测试用例**: 成功发送重置邮件
- **请求参数**:
```json
{
@ -165,16 +179,19 @@
#### 5.2 异常流程测试
**测试用例**: 邮箱未注册
- **请求参数**: 未注册的邮箱地址
- **预期响应**: 404 Not Found
- **错误信息**: "该邮箱未注册"
**测试用例**: 验证码错误
- **请求参数**: 错误的验证码
- **预期响应**: 400 Bad Request
- **错误信息**: "验证码验证失败"
**测试用例**: 账号未激活
- **请求参数**: 未激活用户的邮箱
- **预期响应**: 403 Forbidden
- **错误信息**: "账号未激活,请先激活邮箱"
@ -184,6 +201,7 @@
#### 6.1 正常流程测试
**测试用例**: 成功重置密码
- **请求参数**:
```json
{
@ -202,21 +220,25 @@
#### 6.2 异常流程测试
**测试用例**: 重置令牌无效
- **请求参数**: 无效或过期的重置令牌
- **预期响应**: 400 Bad Request
- **错误信息**: "重置令牌无效或已过期"
**测试用例**: 密码不一致
- **请求参数**: 新密码和确认密码不一致
- **预期响应**: 400 Bad Request
- **错误信息**: "两次输入的密码不一致"
**测试用例**: 密码长度不足
- **请求参数**: 新密码少于6字符
- **预期响应**: 400 Bad Request
- **错误信息**: "密码长度不符合要求"
**测试用例**: 账号未激活
- **请求参数**: 未激活用户的重置令牌
- **预期响应**: 403 Forbidden
- **错误信息**: "账号未激活,请先激活邮箱"
@ -228,15 +250,18 @@
### 1. 输入验证边界
**测试用例**: 用户名长度边界
- 最小长度: 2字符
- 最大长度: 50字符
- 超出范围应返回400错误
**测试用例**: 邮箱格式验证
- 有效邮箱格式应通过验证
- 无效邮箱格式应返回400错误
**测试用例**: 密码强度要求
- 最小长度: 6字符
- 最大长度: 50字符
- 超出范围应返回400错误
@ -244,20 +269,24 @@
### 2. 并发测试
**测试用例**: 并发注册
- 同时使用相同用户名注册
- 应只有一个成功,其他失败
**测试用例**: 并发登录
- 同一用户同时登录
- 应都能成功,但刷新令牌会失效
### 3. 性能测试
**测试用例**: 大量用户注册
- 测试系统在高并发下的表现
- 验证数据库连接池和缓存性能
**测试用例**: 邮件发送性能
- 测试邮件服务的并发处理能力
- 验证邮件队列机制
@ -266,30 +295,36 @@
### 1. 密码安全
**测试用例**: 密码加密存储
- 验证密码是否使用bcrypt加密
- 确认原始密码不在数据库中
**测试用例**: 密码强度验证
- 测试弱密码的拒绝机制
- 验证密码复杂度要求
### 2. 令牌安全
**测试用例**: JWT令牌验证
- 验证令牌签名和过期时间
- 测试令牌篡改检测
**测试用例**: 令牌刷新安全
- 验证刷新令牌的一次性使用
- 测试令牌泄露防护
### 3. 输入安全
**测试用例**: SQL注入防护
- 测试特殊字符输入
- 验证参数化查询
**测试用例**: XSS防护
- 测试恶意脚本输入
- 验证输出转义

View File

@ -40,10 +40,8 @@ describe('认证模块测试', () => {
// 清理测试数据和关闭连接
try {
// 删除测试用户
await drizzleService.db.delete(sysUsers)
.where(eq(sysUsers.username, 'testuser'));
await drizzleService.db.delete(sysUsers)
.where(eq(sysUsers.email, 'test@example.com'));
await drizzleService.db.delete(sysUsers).where(eq(sysUsers.username, 'testuser'));
await drizzleService.db.delete(sysUsers).where(eq(sysUsers.email, 'test@example.com'));
await redisService.close();
await drizzleService.close();
@ -55,19 +53,20 @@ describe('认证模块测试', () => {
beforeEach(async () => {
// 每个测试前生成新的验证码
try {
const captchaResponse = await testApp
.handle(new Request('http://localhost/api/captcha/generate', {
const captchaResponse = await testApp.handle(
new Request('http://localhost/api/captcha/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
type: 'image',
length: 4,
expireTime: 300
expireTime: 300,
}),
}));
}),
);
if (captchaResponse.status === 200) {
const captchaResult = await captchaResponse.json() as any;
const captchaResult = (await captchaResponse.json()) as any;
captchaId = captchaResult.data.id;
// 模拟已知验证码在实际测试中可能需要直接从Redis获取
validCaptchaCode = 'TEST';
@ -82,8 +81,8 @@ describe('认证模块测试', () => {
type: 'image',
image: 'test-image-data',
expireTime: Date.now() + 300000,
createdAt: Date.now()
})
createdAt: Date.now(),
}),
);
}
} catch (error) {
@ -100,18 +99,19 @@ describe('认证模块测试', () => {
email: 'test@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.message).toBe('用户注册成功');
expect(result.data).toBeDefined();
@ -129,31 +129,33 @@ describe('认证模块测试', () => {
email: 'existing@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
await testApp
.handle(new Request('http://localhost/api/auth/register', {
await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(firstPayload),
}));
}),
);
// 重新生成验证码
try {
const captchaResponse = await testApp
.handle(new Request('http://localhost/api/captcha/generate', {
const captchaResponse = await testApp.handle(
new Request('http://localhost/api/captcha/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
type: 'image',
length: 4,
expireTime: 300
expireTime: 300,
}),
}));
}),
);
if (captchaResponse.status === 200) {
const captchaResult = await captchaResponse.json() as any;
const captchaResult = (await captchaResponse.json()) as any;
captchaId = captchaResult.data.id;
validCaptchaCode = 'TEST';
@ -167,8 +169,8 @@ describe('认证模块测试', () => {
type: 'image',
image: 'test-image-data',
expireTime: Date.now() + 300000,
createdAt: Date.now()
})
createdAt: Date.now(),
}),
);
}
} catch (error) {
@ -182,18 +184,19 @@ describe('认证模块测试', () => {
email: 'different@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(duplicatePayload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('USERNAME_EXISTS');
expect(result.message).toBe('用户名已存在');
expect(result.data).toBeNull();
@ -205,18 +208,19 @@ describe('认证模块测试', () => {
email: 'test@example.com', // 使用之前注册的邮箱
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(duplicateEmailPayload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('EMAIL_EXISTS');
expect(result.message).toBe('邮箱已被注册');
expect(result.data).toBeNull();
@ -228,18 +232,19 @@ describe('认证模块测试', () => {
email: 'newuser2@example.com',
password: 'password123',
captcha: 'WRONG',
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('CAPTCHA_ERROR');
expect(result.message).toContain('验证码');
expect(result.data).toBeNull();
@ -251,18 +256,19 @@ describe('认证模块测试', () => {
email: 'newuser3@example.com',
password: 'password123',
captcha: 'TEST',
captchaId: 'nonexistent-captcha-id'
captchaId: 'nonexistent-captcha-id',
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('CAPTCHA_ERROR');
expect(result.data).toBeNull();
});
@ -275,15 +281,16 @@ describe('认证模块测试', () => {
email: 'test@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -294,15 +301,16 @@ describe('认证模块测试', () => {
email: 'test@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -313,15 +321,16 @@ describe('认证模块测试', () => {
email: 'invalid-email', // 无效邮箱格式
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -332,15 +341,16 @@ describe('认证模块测试', () => {
email: 'test@example.com',
password: '12345', // 5个字符小于最小长度6
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -351,15 +361,16 @@ describe('认证模块测试', () => {
email: 'test@example.com',
password: 'password123',
captcha: '123', // 3个字符小于最小长度4
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -370,15 +381,16 @@ describe('认证模块测试', () => {
// 缺少 email
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -391,15 +403,16 @@ describe('认证模块测试', () => {
email: 'min2@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
});
@ -410,15 +423,16 @@ describe('认证模块测试', () => {
email: 'max2@example.com',
password: 'password123',
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
});
@ -429,15 +443,16 @@ describe('认证模块测试', () => {
email: 'minpass2@example.com',
password: '123456', // 6个字符正好等于最小长度
captcha: validCaptchaCode,
captchaId: captchaId
captchaId: captchaId,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/register', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/register', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
});
@ -473,7 +488,8 @@ describe('认证模块测试', () => {
// 创建一个pending状态的测试用户
try {
// 先检查用户是否存在
const existingUser = await drizzleService.db.select({ id: sysUsers.id })
const existingUser = await drizzleService.db
.select({ id: sysUsers.id })
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(testUserId)))
.limit(1);
@ -495,8 +511,7 @@ describe('认证模块测试', () => {
afterEach(async () => {
// 清理测试用户
try {
await drizzleService.db.delete(sysUsers)
.where(eq(sysUsers.id, BigInt(testUserId)));
await drizzleService.db.delete(sysUsers).where(eq(sysUsers.id, BigInt(testUserId)));
} catch (error) {
// 忽略清理错误
}
@ -504,18 +519,19 @@ describe('认证模块测试', () => {
it('应该成功激活用户邮箱', async () => {
const payload: ActivateRequest = {
token: validActivationToken
token: validActivationToken,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.message).toBe('邮箱激活成功');
expect(result.data).toBeDefined();
@ -529,18 +545,19 @@ describe('认证模块测试', () => {
it('Token格式无效应返回400错误', async () => {
const payload: ActivateRequest = {
token: 'invalid-token-format'
token: 'invalid-token-format',
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('INVALID_ACTIVATION_TOKEN');
expect(result.message).toContain('令牌');
expect(result.data).toBeNull();
@ -548,18 +565,19 @@ describe('认证模块测试', () => {
it('Token为空应返回400错误', async () => {
const payload: ActivateRequest = {
token: ''
token: '',
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('INVALID_ACTIVATION_TOKEN');
expect(result.data).toBeNull();
});
@ -568,22 +586,23 @@ describe('认证模块测试', () => {
const invalidToken = JSON.stringify({
// 缺少必要字段
userId: testUserId,
tokenType: 'wrong-type'
tokenType: 'wrong-type',
});
const payload: ActivateRequest = {
token: invalidToken
token: invalidToken,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('INVALID_ACTIVATION_TOKEN');
expect(result.data).toBeNull();
});
@ -604,18 +623,19 @@ describe('认证模块测试', () => {
});
const payload: ActivateRequest = {
token: expiredToken
token: expiredToken,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('INVALID_ACTIVATION_TOKEN');
expect(result.message).toContain('过期');
expect(result.data).toBeNull();
@ -637,18 +657,19 @@ describe('认证模块测试', () => {
});
const payload: ActivateRequest = {
token: nonExistentUserToken
token: nonExistentUserToken,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(404);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('USER_NOT_FOUND');
expect(result.message).toBe('用户不存在');
expect(result.data).toBeNull();
@ -656,29 +677,32 @@ describe('认证模块测试', () => {
it('账号已激活应返回409错误', async () => {
// 先激活用户
await drizzleService.db.update(sysUsers)
await drizzleService.db
.update(sysUsers)
.set({ status: 'active' })
.where(eq(sysUsers.id, BigInt(testUserId)));
const payload: ActivateRequest = {
token: validActivationToken
token: validActivationToken,
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(409);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('ALREADY_ACTIVATED');
expect(result.message).toBe('账号已经激活');
expect(result.data).toBeNull();
// 恢复为pending状态便于其他测试
await drizzleService.db.update(sysUsers)
await drizzleService.db
.update(sysUsers)
.set({ status: 'pending' })
.where(eq(sysUsers.id, BigInt(testUserId)));
});
@ -686,42 +710,45 @@ describe('认证模块测试', () => {
it('缺少Token参数应返回400错误', async () => {
const payload = {}; // 缺少token字段
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
it('Token长度过短应返回400错误', async () => {
const payload: ActivateRequest = {
token: 'short' // 长度小于10
token: 'short', // 长度小于10
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
it('Token长度过长应返回400错误', async () => {
const payload: ActivateRequest = {
token: 'a'.repeat(1001) // 长度超过1000
token: 'a'.repeat(1001), // 长度超过1000
};
const response = await testApp
.handle(new Request('http://localhost/api/auth/activate', {
const response = await testApp.handle(
new Request('http://localhost/api/auth/activate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});

View File

@ -16,10 +16,7 @@ export const captchaController = new Elysia()
*
* @route POST /api/captcha/generate
*/
.post(
'/generate',
({ body }) => captchaService.generateCaptcha(body),
{
.post('/generate', ({ body }) => captchaService.generateCaptcha(body), {
body: GenerateCaptchaSchema,
detail: {
summary: '生成验证码',
@ -27,17 +24,13 @@ export const captchaController = new Elysia()
tags: [tags.captcha],
},
response: { 200: responseWrapperSchema(t.Any()) },
}
)
})
/**
*
* @route POST /api/captcha/verify
*/
.post(
'/verify',
({ body }) => captchaService.verifyCaptcha(body),
{
.post('/verify', ({ body }) => captchaService.verifyCaptcha(body), {
body: VerifyCaptchaSchema,
detail: {
summary: '验证验证码',
@ -45,22 +38,17 @@ export const captchaController = new Elysia()
tags: [tags.captcha],
},
response: { 200: responseWrapperSchema(t.Any()) },
}
)
})
/**
*
* @route POST /api/captcha/cleanup
*/
.post(
'/cleanup',
() => captchaService.cleanupExpiredCaptchas(),
{
.post('/cleanup', () => captchaService.cleanupExpiredCaptchas(), {
detail: {
summary: '清理过期验证码',
description: '清理Redis中已过期的验证码数据',
tags: [tags.captcha],
},
response: { 200: responseWrapperSchema(t.Any()) },
}
);
});

View File

@ -11,43 +11,49 @@ import { t, type Static } from 'elysia';
* Schema
*/
export const GenerateCaptchaSchema = t.Object({
type: t.Optional(t.Union([
t.Literal('image'),
t.Literal('sms'),
t.Literal('email')
], {
type: t.Optional(
t.Union([t.Literal('image'), t.Literal('sms'), t.Literal('email')], {
description: '验证码类型',
examples: ['image', 'sms', 'email'],
default: 'image'
})),
width: t.Optional(t.Number({
default: 'image',
}),
),
width: t.Optional(
t.Number({
minimum: 100,
maximum: 400,
description: '验证码图片宽度',
examples: [200],
default: 200
})),
height: t.Optional(t.Number({
default: 200,
}),
),
height: t.Optional(
t.Number({
minimum: 40,
maximum: 100,
description: '验证码图片高度',
examples: [60],
default: 60
})),
length: t.Optional(t.Number({
default: 60,
}),
),
length: t.Optional(
t.Number({
minimum: 4,
maximum: 8,
description: '验证码长度',
examples: [4],
default: 4
})),
expireTime: t.Optional(t.Number({
default: 4,
}),
),
expireTime: t.Optional(
t.Number({
minimum: 60,
maximum: 1800,
description: '验证码过期时间(秒)',
examples: [300],
default: 300
}))
default: 300,
}),
),
});
/**
@ -57,18 +63,20 @@ export const VerifyCaptchaSchema = t.Object({
captchaId: t.String({
minLength: 1,
description: '验证码ID',
examples: ['captcha_1234567890']
examples: ['captcha_1234567890'],
}),
captchaCode: t.String({
minLength: 4,
maxLength: 8,
description: '用户输入的验证码',
examples: ['1234']
examples: ['1234'],
}),
scene: t.Optional(t.String({
scene: t.Optional(
t.String({
description: '验证场景',
examples: ['login', 'register', 'reset_password']
}))
examples: ['login', 'register', 'reset_password'],
}),
),
});
/**
@ -81,7 +89,7 @@ export const CaptchaDataSchema = t.Object({
image: t.Optional(t.String({ description: 'Base64图片数据' })),
expireTime: t.Number({ description: '过期时间戳' }),
scene: t.Optional(t.String({ description: '验证场景' })),
createdAt: t.Number({ description: '创建时间戳' })
createdAt: t.Number({ description: '创建时间戳' }),
});
/**
@ -91,7 +99,7 @@ export const CaptchaGenerateResponseSchema = t.Object({
id: t.String({ description: '验证码ID' }),
image: t.String({ description: 'Base64编码的验证码图片' }),
expireTime: t.Number({ description: '过期时间戳' }),
type: t.String({ description: '验证码类型' })
type: t.String({ description: '验证码类型' }),
});
// 导出TypeScript类型

View File

@ -11,7 +11,7 @@ import type {
GenerateCaptchaRequest,
VerifyCaptchaRequest,
CaptchaData,
CaptchaGenerateResponse
CaptchaGenerateResponse,
} from './captcha.schema';
import { Logger } from '@/plugins/logger/logger.service';
import { redisService } from '@/plugins/redis/redis.service';
@ -24,13 +24,7 @@ export class CaptchaService {
* @returns Promise<GenerateCaptchaSuccessResponse>
*/
async generateCaptcha(body: GenerateCaptchaRequest) {
const {
type = 'image',
width = 200,
height = 60,
length = 4,
expireTime = 300
} = body;
const { type = 'image', width = 200, height = 60, length = 4, expireTime = 300 } = body;
// 生成验证码ID
const captchaId = `captcha_${randomBytes(16).toString('hex')}`;
@ -39,7 +33,7 @@ export class CaptchaService {
const code = this.generateRandomCode(length);
// 计算过期时间
const expireTimestamp = Date.now() + (expireTime * 1000);
const expireTimestamp = Date.now() + expireTime * 1000;
let imageData: string | undefined;
@ -55,7 +49,7 @@ export class CaptchaService {
type,
image: imageData,
expireTime: expireTimestamp,
createdAt: Date.now()
createdAt: Date.now(),
};
// 存储到Redis
@ -69,7 +63,7 @@ export class CaptchaService {
id: captchaId,
image: imageData || '',
expireTime: expireTimestamp,
type
type,
};
return successResponse(responseData);
@ -106,9 +100,7 @@ export class CaptchaService {
// 验证成功后删除验证码,防止重复使用
await redisService.del(redisKey);
Logger.info(`验证码验证成功:${captchaId}`);
return successResponse(
{ valid: true }, '验证码验证成功'
);
return successResponse({ valid: true }, '验证码验证成功');
} else {
throw new BusinessError('验证码错误', 400);
}
@ -214,9 +206,7 @@ export class CaptchaService {
}
Logger.info(`清理过期验证码完成,共清理 ${cleanedCount}`);
return successResponse(
{ cleanedCount }, '清理完成'
);
return successResponse({ cleanedCount }, '清理完成');
}
}

View File

@ -45,18 +45,19 @@ describe('Captcha API', () => {
width: 200,
height: 60,
length: 4,
expireTime: 300
expireTime: 300,
};
const response = await app
.handle(new Request('http://localhost/api/captcha/generate', {
const response = await app.handle(
new Request('http://localhost/api/captcha/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.data.id).toBeDefined();
expect(result.data.image).toBeDefined();
@ -71,15 +72,16 @@ describe('Captcha API', () => {
it('应该使用默认参数生成验证码', async () => {
const payload = {};
const response = await app
.handle(new Request('http://localhost/api/captcha/generate', {
const response = await app.handle(
new Request('http://localhost/api/captcha/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.data.type).toBe('image');
expect(result.data.image).toMatch(/^data:image\/png;base64,/);
@ -90,15 +92,16 @@ describe('Captcha API', () => {
width: 50, // 小于最小值100
height: 20, // 小于最小值40
length: 2, // 小于最小值4
expireTime: 30 // 小于最小值60
expireTime: 30, // 小于最小值60
};
const response = await app
.handle(new Request('http://localhost/api/captcha/generate', {
const response = await app.handle(
new Request('http://localhost/api/captcha/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -109,18 +112,19 @@ describe('Captcha API', () => {
const payload: VerifyCaptchaRequest = {
captchaId: 'nonexistent_captcha_id',
captchaCode: '1234',
scene: 'login'
scene: 'login',
};
const response = await app
.handle(new Request('http://localhost/api/captcha/verify', {
const response = await app.handle(
new Request('http://localhost/api/captcha/verify', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.data.valid).toBe(false);
expect(result.data.message).toContain('验证码不存在或已过期');
@ -132,12 +136,13 @@ describe('Captcha API', () => {
captchaCode: '123', // 长度小于4
};
const response = await app
.handle(new Request('http://localhost/api/captcha/verify', {
const response = await app.handle(
new Request('http://localhost/api/captcha/verify', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
}));
}),
);
expect(response.status).toBe(400);
});
@ -145,14 +150,15 @@ describe('Captcha API', () => {
describe('POST /api/captcha/cleanup', () => {
it('应该成功清理过期验证码', async () => {
const response = await app
.handle(new Request('http://localhost/api/captcha/cleanup', {
const response = await app.handle(
new Request('http://localhost/api/captcha/cleanup', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
}));
}),
);
expect(response.status).toBe(200);
const result = await response.json() as any;
const result = (await response.json()) as any;
expect(result.code).toBe('SUCCESS');
expect(result.data.cleanedCount).toBeGreaterThanOrEqual(0);
});

View File

@ -0,0 +1,35 @@
/**
* @file Controller层实现
* @author AI Assistant
* @date 2024-12-19
* @lastEditor AI Assistant
* @lastEditTime 2025-01-07
* @description
*/
import { Elysia } from 'elysia';
import { dictService } from './dict.service';
import { CreateDictSchema } from './dict.schema';
import { CreateDictResponsesSchema } from './dict.response';
import { tags } from '@/constants/swaggerTags';
/**
*
* @description HTTP请求
*/
export const dictController = new Elysia()
/**
*
* @route POST /api/dict
* @description
*/
.post('/', ({ body }) => dictService.createDict(body), {
body: CreateDictSchema,
detail: {
summary: '创建字典项',
description: '创建字典项接口,需要提供字典代码、名称等基本信息',
tags: [tags.dict],
operationId: 'createDict',
},
response: CreateDictResponsesSchema,
});

View File

@ -0,0 +1,338 @@
# 字典模块业务逻辑文档
## 模块概述
字典模块提供系统字典的管理功能支持树形结构的字典数据CRUD操作。字典数据用于存储系统配置、状态选项、分类信息等静态数据。
## 数据库设计
### 表结构sys_dict
```sql
CREATE TABLE `sys_dict` (
`id` BIGINT NOT NULL COMMENT '主键ID',
`code` VARCHAR(50) NOT NULL COMMENT '字典代码,唯一标识',
`name` VARCHAR(100) NOT NULL COMMENT '字典名称',
`value` VARCHAR(200) NULL COMMENT '字典值(叶子节点才有值)',
`description` VARCHAR(500) NULL COMMENT '字典描述',
`icon` VARCHAR(100) NULL COMMENT '图标CSS类名或图标路径',
`pid` BIGINT NULL DEFAULT 0 COMMENT '父级ID0表示顶级',
`level` INT NOT NULL DEFAULT 1 COMMENT '层级深度1为顶级',
`sort_order` INT NOT NULL DEFAULT 0 COMMENT '排序号',
`status` VARCHAR(20) NOT NULL DEFAULT 'active' COMMENT '状态active-启用inactive-禁用',
`is_system` BOOLEAN NOT NULL DEFAULT FALSE COMMENT '是否系统字典',
`color` VARCHAR(20) NULL COMMENT '颜色标识',
`extra` JSON NULL COMMENT '扩展字段',
`created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_code` (`code`),
KEY `idx_pid` (`pid`),
KEY `idx_level` (`level`),
KEY `idx_status` (`status`),
KEY `idx_sort` (`sort_order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='系统字典表';
```
## 接口设计
### 1. 创建字典项接口 (POST /api/dict)
#### 业务逻辑
1. **参数验证**
- 验证必填字段code、name
- 验证code唯一性全局唯一
- 验证name在同级下的唯一性
- 验证pid的有效性如果指定了父级
- 验证level深度不超过10层
2. **业务规则**
- 默认pid为0顶级字典
- 默认level为1顶级
- 默认status为'active'
- 默认is_system为false
- 默认sort_order为0
- 如果有父级level = 父级level + 1
- 如果指定了父级需要验证父级是否存在且状态为active
3. **数据处理**
- code转换为小写并去除两端空格
- name去除两端空格
- description去除两端空格
- 自动计算level如果指定了pid
- 自动生成sort_order同级最大sort_order + 1
4. **错误处理**
- code已存在409 Conflict
- name在同级下已存在409 Conflict
- 父级不存在404 Not Found
- 父级状态非active400 Bad Request
- level超过10层400 Bad Request
#### 性能考虑
1. **数据库索引**
- code字段有唯一索引查询快速
- pid字段有索引支持父子关系查询
- level字段有索引支持层级查询
2. **并发控制**
- 使用分布式锁防止code重复创建
- 使用数据库事务确保数据一致性
#### 安全考虑
1. **输入验证**
- 防止SQL注入使用参数化查询
- 防止XSS对输入进行转义
- 限制字段长度:防止过长的输入
2. **权限控制**
- 需要管理员权限
- 系统字典只能由超级管理员创建
#### 缓存策略
1. **缓存失效**
- 创建字典项后,清除相关缓存
- 清除父级字典的缓存
- 清除完整字典树缓存
## 2. 获取字典项内容接口 (GET /api/dict/:id)
#### 业务逻辑
1. **参数验证**
- 验证id格式bigint
- 验证id是否存在
2. **查询逻辑**
- 根据id查询字典项
- 只返回状态为active的字典项
- 包含完整的字典项信息
3. **错误处理**
- 字典项不存在404 Not Found
- 字典项状态非active404 Not Found
#### 缓存策略
1. **缓存读取**
- 优先从Redis缓存读取
- 缓存未命中时从数据库查询
- 查询结果写入缓存
## 3. 获取完整字典树接口 (GET /api/dict/tree)
#### 业务逻辑
1. **查询参数**
- status过滤状态可选
- is_system是否系统字典可选
2. **查询逻辑**
- 查询所有符合条件的字典项
- 按level和sort_order排序
- 构建树形结构
3. **树形构建**
- 使用递归算法构建树
- 只包含状态为active的字典项
- 按sort_order排序
#### 性能考虑
1. **缓存策略**
- 完整字典树缓存到Redis
- 缓存时间1小时
- 支持按条件过滤的缓存
2. **查询优化**
- 使用单次查询获取所有数据
- 在应用层构建树形结构
## 4. 获取指定字典树接口 (GET /api/dict/tree/:code)
#### 业务逻辑
1. **参数验证**
- 验证code格式
- 验证code是否存在
2. **查询逻辑**
- 根据code查找字典项
- 获取该字典项的所有子级
- 构建子树结构
3. **错误处理**
- 字典项不存在404 Not Found
- 字典项状态非active404 Not Found
#### 缓存策略
1. **缓存键设计**
- 使用code作为缓存键的一部分
- 支持条件过滤的缓存
## 5. 更新字典项内容接口 (PUT /api/dict/:id)
#### 业务逻辑
1. **参数验证**
- 验证id格式和存在性
- 验证更新字段的有效性
- 验证code唯一性如果更新code
- 验证name在同级下的唯一性如果更新name
2. **业务规则**
- 系统字典只能由超级管理员更新
- 不能更新已删除的字典项
- 更新code时需要检查是否被其他字典项引用
3. **级联更新**
- 如果更新level需要更新所有子级的level
- 如果更新status可以选择是否级联更新子级
#### 缓存策略
1. **缓存失效**
- 更新后清除相关缓存
- 清除父级和子级的缓存
## 6. 字典项排序接口 (PUT /api/dict/sort)
#### 业务逻辑
1. **参数验证**
- 验证排序数据的完整性
- 验证字典项的存在性
2. **排序逻辑**
- 支持同级内的排序
- 支持跨级移动(改变父级)
- 自动重新计算level和sort_order
3. **事务处理**
- 使用数据库事务确保排序的一致性
- 支持批量排序操作
## 7. 删除字典项接口 (DELETE /api/dict/:id)
#### 业务逻辑
1. **软删除**
- 不物理删除数据
- 将status设置为'inactive'
- 保留数据完整性
2. **依赖检查**
- 检查是否有其他字典项引用
- 检查是否有业务数据引用
- 如果有依赖,不允许删除
3. **级联处理**
- 可以选择是否级联删除子级
- 默认不级联删除
#### 缓存策略
1. **缓存失效**
- 删除后清除相关缓存
- 清除父级和子级的缓存
## 缓存机制
### Redis缓存设计
1. **缓存键命名**
- 完整字典树:`dict:tree:all`
- 指定字典树:`dict:tree:{code}`
- 单个字典项:`dict:item:{id}`
- 字典项列表:`dict:list:{conditions}`
2. **缓存时间**
- 字典树1小时
- 单个字典项30分钟
- 字典项列表15分钟
3. **缓存失效策略**
- 写入操作后主动失效
- 定时刷新机制
- 内存不足时LRU淘汰
### 缓存一致性
1. **写入策略**
- 先更新数据库,再失效缓存
- 使用分布式锁防止并发问题
2. **读取策略**
- 先读缓存,缓存未命中读数据库
- 数据库查询结果写入缓存
## 错误码定义
| 错误码 | 说明 | HTTP状态码 |
| -------- | ---------------------- | ---------- |
| DICT_001 | 字典代码已存在 | 409 |
| DICT_002 | 字典名称在同级下已存在 | 409 |
| DICT_003 | 父级字典不存在 | 404 |
| DICT_004 | 父级字典状态非active | 400 |
| DICT_005 | 字典层级超过限制 | 400 |
| DICT_006 | 字典项不存在 | 404 |
| DICT_007 | 字典项状态非active | 404 |
| DICT_008 | 系统字典权限不足 | 403 |
| DICT_009 | 字典项被引用,无法删除 | 400 |
| DICT_010 | 排序数据无效 | 400 |
## 性能优化建议
1. **数据库优化**
- 合理使用索引
- 避免N+1查询问题
- 使用批量操作
2. **缓存优化**
- 合理设置缓存时间
- 使用缓存预热
- 实现缓存穿透保护
3. **应用层优化**
- 使用连接池
- 实现请求限流
- 优化树形构建算法
## 测试策略
1. **单元测试**
- 测试所有业务逻辑方法
- 测试边界条件和异常情况
- 测试缓存机制
2. **集成测试**
- 测试完整的API接口
- 测试数据库操作
- 测试Redis缓存
3. **性能测试**
- 测试大量数据的处理能力
- 测试并发访问性能
- 测试缓存命中率
## 部署注意事项
1. **环境配置**
- 确保Redis服务可用
- 配置数据库连接池
- 设置合适的日志级别
2. **监控告警**
- 监控API响应时间
- 监控缓存命中率
- 监控数据库连接数
3. **备份策略**
- 定期备份字典数据
- 备份Redis缓存数据
- 制定数据恢复方案

View File

@ -0,0 +1,130 @@
/**
* @file
* @author AI Assistant
* @date 2024-12-19
* @lastEditor AI Assistant
* @lastEditTime 2025-01-07
* @description
*/
import { t, type Static } from 'elysia';
import { responseWrapperSchema } from '@/utils/responseFormate';
/**
*
*/
export const CreateDictSuccessSchema = t.Object({
id: t.String({
description: '字典项IDbigint类型以字符串返回防止精度丢失',
examples: ['1', '2', '100'],
}),
code: t.String({
description: '字典代码',
examples: ['user_status'],
}),
name: t.String({
description: '字典名称',
examples: ['用户状态'],
}),
value: t.Optional(
t.String({
description: '字典值',
examples: ['active'],
}),
),
description: t.Optional(
t.String({
description: '字典描述',
examples: ['用户状态字典'],
}),
),
icon: t.Optional(
t.String({
description: '图标',
examples: ['icon-user'],
}),
),
pid: t.String({
description: '父级IDbigint类型以字符串返回',
examples: ['0', '1'],
}),
level: t.Number({
description: '层级深度',
examples: [1, 2],
}),
sortOrder: t.Number({
description: '排序号',
examples: [0, 1, 10],
}),
status: t.String({
description: '状态',
examples: ['active', 'inactive'],
}),
isSystem: t.Boolean({
description: '是否系统字典',
examples: [true, false],
}),
color: t.Optional(
t.String({
description: '颜色标识',
examples: ['#1890ff'],
}),
),
extra: t.Optional(
t.Record(t.String(), t.Any(), {
description: '扩展字段',
examples: [{ key1: 'value1' }],
}),
),
createdAt: t.String({
description: '创建时间',
examples: ['2024-12-19T10:30:00Z'],
}),
updatedAt: t.String({
description: '更新时间',
examples: ['2024-12-19T10:30:00Z'],
}),
});
/**
*
* @description Controller中定义所有可能的响应格式
*/
export const CreateDictResponsesSchema = {
200: responseWrapperSchema(CreateDictSuccessSchema),
409: responseWrapperSchema(
t.Object({
error: t.String({
description: '唯一性冲突',
examples: ['字典代码已存在', '字典名称在同级下已存在'],
}),
}),
),
400: responseWrapperSchema(
t.Object({
error: t.String({
description: '参数错误',
examples: ['参数校验失败', '父级字典状态非active', '字典层级超过限制'],
}),
}),
),
404: responseWrapperSchema(
t.Object({
error: t.String({
description: '资源不存在',
examples: ['父级字典不存在'],
}),
}),
),
500: responseWrapperSchema(
t.Object({
error: t.String({
description: '服务器错误',
examples: ['内部服务器错误'],
}),
}),
),
};
/** 创建字典项成功响应数据类型 */
export type CreateDictSuccessType = Static<(typeof CreateDictResponsesSchema)[200]>;

View File

@ -0,0 +1,371 @@
/**
* @file Schema定义
* @author AI Assistant
* @date 2024-12-19
* @lastEditor AI Assistant
* @lastEditTime 2025-01-07
* @description Schema
*/
import { t, type Static } from 'elysia';
/**
* Schema
* @description
*/
export const CreateDictSchema = t.Object({
/** 字典代码,唯一标识 */
code: t.Transform(t.String({
minLength: 1,
maxLength: 50,
description: '字典代码,全局唯一标识,自动转换为小写并去除两端空格',
examples: ['user_status', 'order_type', 'system_config'],
}))
.Decode((value: string) => value.trim().toLowerCase())
.Encode((value: string) => value),
/** 字典名称 */
name: t.Transform(t.String({
minLength: 1,
maxLength: 100,
description: '字典名称,同级下唯一,自动去除两端空格',
examples: ['用户状态', '订单类型', '系统配置'],
}))
.Decode((value: string) => value.trim().toLowerCase())
.Encode((value: string) => value),
/** 字典值(叶子节点才有值) */
value: t.Optional(
t
.String({
maxLength: 200,
description: '字典值,叶子节点才有值,自动去除两端空格',
examples: ['active', 'inactive', 'pending'],
})
),
/** 字典描述 */
description: t.Optional(
t
.String({
maxLength: 500,
description: '字典描述,自动去除两端空格',
examples: ['用户状态字典,包含激活、禁用、待审核等状态'],
})
),
/** 图标CSS类名或图标路径 */
icon: t.Optional(
t
.String({
maxLength: 100,
description: '图标CSS类名或图标路径自动去除两端空格',
examples: ['icon-user', 'icon-order', '/icons/config.png'],
})
),
/** 父级ID0表示顶级 */
pid: t.Optional(
t.Union(
[
t.Literal('0'),
t.String({
pattern: '^[1-9]\\d*$',
description: '父级字典IDBigint字符串形式',
}),
],
{
description: '父级ID0表示顶级字典',
examples: ['0', '1', '2'],
},
),
),
/** 排序号 */
sortOrder: t.Optional(
t.Number({
minimum: 0,
maximum: 999999,
description: '排序号,同级内排序使用',
examples: [0, 1, 10, 100],
}),
),
/** 状态active-启用inactive-禁用 */
status: t.Optional(
t
.Union([t.Literal('active'), t.Literal('inactive')], {
description: '字典状态默认active',
examples: ['active', 'inactive'],
default: 'active',
})
),
/** 是否系统字典 */
isSystem: t.Optional(
t
.Boolean({
description: '是否系统字典系统字典只能由超级管理员创建默认false',
examples: [true, false],
default: false,
})
),
/** 颜色标识 */
color: t.Optional(
t
.String({
maxLength: 20,
description: '颜色标识,用于前端显示,自动去除两端空格',
examples: ['#1890ff', '#52c41a', '#faad14', '#f5222d'],
})
),
/** 扩展字段 */
extra: t.Optional(
t.Record(t.String(), t.Any(), {
description: '扩展字段JSON格式',
examples: [{ key1: 'value1', key2: 'value2' }],
}),
),
});
/** 创建字典项请求参数类型 */
export type CreateDictRequest = Static<typeof CreateDictSchema>;
/**
* Schema
* @description ID获取字典项的请求参数验证规则
*/
export const GetDictByIdSchema = t.Object({
/** 字典项ID */
id: t.String({
pattern: '^[1-9]\\d*$',
description: '字典项ID必须是正整数',
examples: ['1', '2', '100'],
}),
});
/** 获取字典项请求参数类型 */
export type GetDictByIdRequest = Static<typeof GetDictByIdSchema>;
/**
* Schema
* @description
*/
export const GetDictTreeQuerySchema = t.Object({
/** 状态过滤 */
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive'), t.Literal('all')], {
description: '状态过滤条件',
examples: ['active', 'inactive', 'all'],
}),
),
/** 是否系统字典过滤 */
isSystem: t.Optional(
t.Union([t.Literal('true'), t.Literal('false'), t.Literal('all')], {
description: '是否系统字典过滤条件',
examples: ['true', 'false', 'all'],
}),
),
});
/** 获取完整字典树查询参数类型 */
export type GetDictTreeQueryRequest = Static<typeof GetDictTreeQuerySchema>;
/**
* Schema
* @description code获取指定字典树的请求参数验证规则
*/
export const GetDictTreeByCodeSchema = t.Object({
/** 字典代码 */
code: t.String({
minLength: 1,
maxLength: 50,
description: '字典代码,用于查找指定的字典树',
examples: ['user_status', 'order_type', 'system_config'],
}),
/** 状态过滤 */
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive'), t.Literal('all')], {
description: '状态过滤条件',
examples: ['active', 'inactive', 'all'],
}),
),
/** 是否系统字典过滤 */
isSystem: t.Optional(
t.Union([t.Literal('true'), t.Literal('false'), t.Literal('all')], {
description: '是否系统字典过滤条件',
examples: ['true', 'false', 'all'],
}),
),
});
/** 获取指定字典树请求参数类型 */
export type GetDictTreeByCodeRequest = Static<typeof GetDictTreeByCodeSchema>;
/**
* Schema
* @description
*/
export const UpdateDictSchema = t.Object({
/** 字典代码,唯一标识 */
code: t.Optional(
t.String({
minLength: 1,
maxLength: 50,
description: '字典代码,全局唯一标识,自动转换为小写',
examples: ['user_status', 'order_type', 'system_config'],
}),
),
/** 字典名称 */
name: t.Optional(
t.String({
minLength: 1,
maxLength: 100,
description: '字典名称,同级下唯一',
examples: ['用户状态', '订单类型', '系统配置'],
}),
),
/** 字典值(叶子节点才有值) */
value: t.Optional(
t.String({
maxLength: 200,
description: '字典值,叶子节点才有值',
examples: ['active', 'inactive', 'pending'],
}),
),
/** 字典描述 */
description: t.Optional(
t.String({
maxLength: 500,
description: '字典描述信息',
examples: ['用户状态字典,包含激活、禁用、待审核等状态'],
}),
),
/** 图标CSS类名或图标路径 */
icon: t.Optional(
t.String({
maxLength: 100,
description: '图标CSS类名或图标路径',
examples: ['icon-user', 'icon-order', '/icons/config.png'],
}),
),
/** 父级ID0表示顶级 */
pid: t.Optional(
t.Union(
[
t.Literal(0),
t.String({
pattern: '^[1-9]\\d*$',
description: '父级字典ID必须是正整数',
}),
],
{
description: '父级ID0表示顶级字典',
examples: [0, '1', '2'],
},
),
),
/** 排序号 */
sortOrder: t.Optional(
t.Number({
minimum: 0,
maximum: 999999,
description: '排序号,同级内排序使用',
examples: [0, 1, 10, 100],
}),
),
/** 状态active-启用inactive-禁用 */
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive')], {
description: '字典状态',
examples: ['active', 'inactive'],
}),
),
/** 是否系统字典 */
isSystem: t.Optional(
t.Boolean({
description: '是否系统字典,系统字典只能由超级管理员创建',
examples: [true, false],
}),
),
/** 颜色标识 */
color: t.Optional(
t.String({
maxLength: 20,
description: '颜色标识,用于前端显示',
examples: ['#1890ff', '#52c41a', '#faad14', '#f5222d'],
}),
),
/** 扩展字段 */
extra: t.Optional(
t.Record(t.String(), t.Any(), {
description: '扩展字段JSON格式',
examples: [{ key1: 'value1', key2: 'value2' }],
}),
),
});
/** 更新字典项请求参数类型 */
export type UpdateDictRequest = Static<typeof UpdateDictSchema>;
/**
* Schema
* @description
*/
export const SortDictSchema = t.Object({
/** 排序项列表 */
items: t.Array(
t.Object({
/** 字典项ID */
id: t.String({
pattern: '^[1-9]\\d*$',
description: '字典项ID',
examples: ['1', '2', '100'],
}),
/** 新的父级ID */
pid: t.Union(
[
t.Literal(0),
t.String({
pattern: '^[1-9]\\d*$',
description: '父级字典ID',
}),
],
{
description: '新的父级ID0表示顶级',
examples: [0, '1', '2'],
},
),
/** 新的排序号 */
sortOrder: t.Number({
minimum: 0,
maximum: 999999,
description: '新的排序号',
examples: [0, 1, 10, 100],
}),
}),
{
minItems: 1,
maxItems: 100,
description: '排序项列表至少包含一个项目最多100个',
},
),
});
/** 字典项排序请求参数类型 */
export type SortDictRequest = Static<typeof SortDictSchema>;
/**
* Schema
* @description
*/
export const DeleteDictSchema = t.Object({
/** 字典项ID */
id: t.String({
pattern: '^[1-9]\\d*$',
description: '字典项ID必须是正整数',
examples: ['1', '2', '100'],
}),
/** 是否级联删除子级 */
cascade: t.Optional(
t.Boolean({
description: '是否级联删除子级字典项',
examples: [true, false],
}),
),
});
/** 删除字典项请求参数类型 */
export type DeleteDictRequest = Static<typeof DeleteDictSchema>;

View File

@ -0,0 +1,127 @@
/**
* @file Service层实现
* @author AI Assistant
* @date 2024-12-19
* @lastEditor AI Assistant
* @lastEditTime 2025-01-07
* @description
*/
import { Logger } from '@/plugins/logger/logger.service';
import { db } from '@/plugins/drizzle/drizzle.service';
import { sysDict } from '@/eneities';
import { eq, and, max } from 'drizzle-orm';
import { successResponse, BusinessError } from '@/utils/responseFormate';
import { nextId } from '@/utils/snowflake';
import type { CreateDictRequest } from './dict.schema';
import type { CreateDictSuccessType } from './dict.response';
/**
*
* @description
*/
export class DictService {
/**
*
* @param body
* @returns Promise<CreateDictSuccessType>
* @throws BusinessError
*/
public async createDict(body: CreateDictRequest): Promise<CreateDictSuccessType> {
// 1. code唯一性校验
const existCode = await db().select({id: sysDict.id}).from(sysDict).where(eq(sysDict.code, body.code)).limit(1);
if (existCode.length > 0) {
throw new BusinessError(`字典代码已存在: ${body.code}`, 409);
}
// 2. name同级唯一性校验
const pid = body.pid || '0';
const existName = await db().select({id: sysDict.id}).from(sysDict).where(and(eq(sysDict.name, body.name), eq(sysDict.pid, pid))).limit(1);
if (existName.length > 0) {
throw new BusinessError(`字典名称已存在: ${body.name}`, 409);
}
// 3. 父级校验与层级处理
let level = 1;
if (pid !== '0') {
const parent = await db().select().from(sysDict).where(eq(sysDict.id, pid)).limit(1);
if (parent.length === 0) {
throw new BusinessError(`父级字典不存在: ${pid}`, 404);
}
if (parent[0]!.status !== 'active') {
throw new BusinessError(`父级字典状态非active: ${pid}`, 400);
}
level = parent[0]!.level + 1;
if (level > 10) {
throw new BusinessError(`字典层级超过限制: ${level}`, 400);
}
}
// 4. sortOrder处理同级最大+1
let sortOrder = 0;
if (body.sortOrder !== undefined) {
sortOrder = body.sortOrder;
} else {
const maxSort = await db()
.select({ maxSort: max(sysDict.sortOrder) })
.from(sysDict)
.where(eq(sysDict.pid, pid));
sortOrder = (maxSort[0]?.maxSort ?? 0) + 1;
}
// 5. 数据写入
const dictId = nextId();
await db()
.insert(sysDict)
.values([
{
id: dictId.toString(),
code: body.code,
name: body.name,
value: body.value ?? null,
description: body.description ?? null,
icon: body.icon ?? null,
pid: BigInt(pid),
level,
sortOrder,
status: body.status,
isSystem: body.isSystem ? 1 : 0,
color: body.color ?? null,
extra: body.extra ?? {},
},
] as any);
// 6. 查询刚插入的数据
const insertedArr = await db().select().from(sysDict).where(eq(sysDict.id, dictId.toString())).limit(1);
if (!insertedArr || insertedArr.length === 0) {
throw new BusinessError('创建字典项失败', 500);
}
const inserted = insertedArr[0]!;
// 7. 返回统一响应
return successResponse(
{
id: String(inserted.id),
code: inserted.code,
name: inserted.name,
value: inserted.value,
description: inserted.description,
icon: inserted.icon,
pid: String(inserted.pid),
level: inserted.level,
sortOrder: inserted.sortOrder,
status: inserted.status,
isSystem: Boolean(inserted.isSystem),
color: inserted.color,
extra: inserted.extra,
createdAt: inserted.createdAt,
updatedAt: inserted.updatedAt,
},
'创建字典项成功',
);
}
}
// 导出单例实例
export const dictService = new DictService();

View File

@ -98,8 +98,12 @@ class HealthService {
/** 系统整体状态 */
const overallStatus = this.determineOverallStatus([
mysqlStatus.status === 'fulfilled' ? mysqlStatus.value : { status: 'unhealthy', error: 'Connection failed' },
redisStatus.status === 'fulfilled' ? redisStatus.value : { status: 'unhealthy', error: 'Connection failed' },
mysqlStatus.status === 'fulfilled'
? mysqlStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
redisStatus.status === 'fulfilled'
? redisStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
]);
const responseTime = Date.now() - startTime;
@ -115,8 +119,14 @@ class HealthService {
version: process.env.npm_package_version || '1.0.0',
environment: process.env.NODE_ENV || 'development',
components: {
mysql: mysqlStatus.status === 'fulfilled' ? mysqlStatus.value : { status: 'unhealthy', error: 'Connection failed' },
redis: redisStatus.status === 'fulfilled' ? redisStatus.value : { status: 'unhealthy', error: 'Connection failed' },
mysql:
mysqlStatus.status === 'fulfilled'
? mysqlStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
redis:
redisStatus.status === 'fulfilled'
? redisStatus.value
: { status: 'unhealthy', error: 'Connection failed' },
},
},
};
@ -266,7 +276,7 @@ class HealthService {
* @returns
*/
private determineOverallStatus(components: ComponentStatus[]): 'healthy' | 'unhealthy' | 'degraded' {
const healthyCount = components.filter(c => c.status === 'healthy').length;
const healthyCount = components.filter((c) => c.status === 'healthy').length;
const totalCount = components.length;
if (healthyCount === totalCount) {

View File

@ -13,6 +13,7 @@ import { userController } from './user/user.controller';
import { testController } from './test/test.controller';
import { captchaController } from './captcha/captcha.controller';
import { authController } from './auth/auth.controller';
import { dictController } from './dict/dict.controller';
/**
* - API
@ -35,4 +36,6 @@ export const controllers = new Elysia({
// 认证接口
.group('/auth', (app) => app.use(authController))
// 验证码接口
.group('/captcha', (app) => app.use(captchaController));
.group('/captcha', (app) => app.use(captchaController))
// 字典接口
.group('/dict', (app) => app.use(dictController));

View File

@ -0,0 +1,267 @@
# 创建用户接口业务逻辑文档
## 接口基本信息
- **接口名称**: 创建用户接口
- **请求方法**: POST
- **接口路径**: `/users`
- **权限要求**: 需要 `user:create` 权限
- **优先级**: P0
## 需求描述
管理员创建新用户,可直接设置角色、组织等信息。支持批量创建用户,可预设用户角色和组织,支持直接激活状态。
## 设计原因
- 管理员需要批量创建用户
- 可预设用户角色和组织
- 支持直接激活状态
- 提供完整的用户信息设置
## 接口参数
```typescript
{
username: string; // 用户名必填3-50字符字母开头仅包含字母数字下划线
email: string; // 邮箱地址,必填,需符合邮箱格式
password: string; // 密码必填8-100字符必须包含大小写字母和数字
mobile?: string; // 手机号可选11位数字
nickname?: string; // 昵称可选1-50字符
status?: string; // 用户状态可选默认active可选值active/inactive/locked
gender?: number; // 性别可选0-未知1-男2-女
birthday?: string; // 生日可选ISO 8601格式
bio?: string; // 个人简介可选最大500字符
roleIds?: number[]; // 角色ID数组可选
organizationIds?: Array<{
id: number;
isPrimary: boolean; // 是否主要组织
position?: string; // 职位,可选
}>; // 组织信息,可选
tagIds?: number[]; // 标签ID数组可选
sendNotification?: boolean; // 是否发送通知邮件可选默认false
}
```
## 业务逻辑流程
### 1. 权限验证
- 检查当前用户是否具有 `user:create` 权限
- 如果没有权限返回403错误
### 2. 参数验证
- 验证必填字段username、email
- 验证字段格式:
- username: 3-50字符字母开头仅包含字母数字下划线
- email: 符合邮箱格式
- mobile: 11位数字如果提供
- 验证唯一性:
- username 在系统中唯一
- email 在系统中唯一
- mobile 在系统中唯一(如果提供)
- password从配置文件获取使用默认密码
### 3. 数据预处理
- username: 转换为小写并去除两端空格
- email: 转换为小写并去除两端空格
- mobile: 去除空格和特殊字符
- nickname: 去除两端空格
- bio: 去除两端空格
### 4. 密码处理
- 使用 bcrypt 加密密码成本因子为12从配置文件获取
- 生成密码哈希值
### 5. 事务处理
使用数据库事务确保数据一致性:
#### 5.1 创建用户记录
```sql
INSERT INTO sys_users (
username, email, password_hash, mobile, nickname,
status, gender, birthday, bio, created_by, updated_by
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
```
#### 5.2 分配角色如果提供roleIds
```sql
INSERT INTO sys_user_roles (user_id, role_id, created_by) VALUES (?, ?, ?)
```
#### 5.3 分配组织如果提供organizationIds
```sql
INSERT INTO sys_user_organizations (
user_id, organization_id, is_primary, position, created_by
) VALUES (?, ?, ?, ?, ?)
```
#### 5.4 分配标签如果提供tagIds
```sql
INSERT INTO sys_user_tags (user_id, tag_id, created_by) VALUES (?, ?, ?)
```
### 6. 后续处理
- 如果 sendNotification 为 true发送欢迎邮件异步处理
- 记录操作日志到 sys_operation_logs 表
- 清除相关缓存(用户列表缓存等)
## 响应格式
### 成功响应 (201 Created)
```json
{
"code": 0,
"message": "创建成功",
"data": {
"id": "1234567890",
"username": "new_user",
"email": "new@example.com",
"mobile": "13800138000",
"nickname": "新用户",
"status": "active",
"gender": 1,
"birthday": "1990-01-01",
"bio": "个人简介",
"createdAt": "2024-01-01T12:00:00Z",
"updatedAt": "2024-01-01T12:00:00Z"
}
}
```
### 错误响应
#### 400 Bad Request - 参数错误
```json
{
"code": 400,
"message": "用户名格式不正确",
"data": null
}
```
#### 403 Forbidden - 权限不足
```json
{
"code": 403,
"message": "权限不足",
"data": null
}
```
#### 409 Conflict - 资源冲突
```json
{
"code": 409,
"message": "用户名已被占用",
"data": null
}
```
## 安全考虑
### 1. 权限控制
- 只有具有 `user:create` 权限的用户才能创建用户
- 记录创建者信息,便于审计
### 2. 数据验证
- 严格的参数格式验证
- 唯一性检查防止重复数据
- 密码强度要求
### 3. 事务安全
- 使用数据库事务确保数据一致性
- 如果任何步骤失败,回滚所有操作
### 4. 分布式锁
- 在检查用户名和邮箱唯一性时使用分布式锁
- 防止并发创建导致的重复数据
## 性能考虑
### 1. 数据库优化
- 在 username、email、mobile 字段上建立唯一索引
- 使用批量插入减少数据库交互次数
### 2. 缓存策略
- 创建成功后清除用户列表缓存
- 清除相关角色和组织缓存
### 3. 异步处理
- 邮件发送使用异步队列处理
- 日志记录使用异步处理
## 错误处理
### 1. 业务错误
- 参数验证失败返回400错误
- 权限不足返回403错误
- 资源冲突返回409错误
### 2. 系统错误
- 数据库连接失败返回500错误
- 邮件服务失败:记录错误但不影响用户创建
- 缓存服务失败:记录错误但不影响主流程
## 测试用例
### 1. 正常创建
- 提供完整的用户信息
- 验证返回的用户数据正确
- 验证数据库中数据正确保存
### 2. 权限测试
- 无权限用户尝试创建应返回403错误
- 有权限用户创建:应成功
### 3. 参数验证
- 无效的用户名格式应返回400错误
- 无效的邮箱格式应返回400错误
- 弱密码应返回400错误
### 4. 唯一性测试
- 重复用户名应返回409错误
- 重复邮箱应返回409错误
- 重复手机号应返回409错误
### 5. 事务测试
- 创建过程中数据库异常:应回滚所有操作
- 部分数据插入失败:应回滚所有操作
## 注意事项
1. **分布式锁使用**:在检查唯一性时必须使用分布式锁
2. **事务边界**:整个创建过程必须在同一个事务中
3. **密码安全**密码必须使用bcrypt加密成本因子为12
4. **日志记录**:必须记录操作日志,包含操作者和操作内容
5. **缓存清理**:创建成功后必须清理相关缓存
6. **异步处理**:邮件发送等非关键操作使用异步处理
7. **错误处理**:必须处理所有可能的错误情况
8. **数据一致性**:确保用户、角色、组织、标签数据的一致性

View File

@ -10,47 +10,41 @@
import { t, type Static } from 'elysia';
import { createPaginationResponseSchema, createQuerySchema } from '@/utils/pagination';
/**
* Schema
* @description
*/
export const UserListQuerySchema = createQuerySchema(t.Object({
export const UserListQuerySchema = createQuerySchema(
t.Object({
// 用户特有参数
keyword: t.Optional(t.String({
keyword: t.Optional(
t.String({
minLength: 1,
maxLength: 100,
description: '搜索关键词,支持用户名、邮箱模糊搜索',
examples: ['admin', 'test@example.com']
})),
status: t.Optional(t.Union([
t.Literal('active'),
t.Literal('inactive'),
t.Literal('pending')
], {
examples: ['admin', 'test@example.com'],
}),
),
status: t.Optional(
t.Union([t.Literal('active'), t.Literal('inactive'), t.Literal('pending')], {
description: '用户状态筛选',
examples: ['active', 'inactive', 'pending']
})),
gender: t.Optional(t.Union([
t.Literal(0),
t.Literal(1),
t.Literal(2),
t.Literal('0'),
t.Literal('1'),
t.Literal('2'),
], {
examples: ['active', 'inactive', 'pending'],
}),
),
gender: t.Optional(
t.Union([t.Literal(0), t.Literal(1), t.Literal(2), t.Literal('0'), t.Literal('1'), t.Literal('2')], {
description: '性别筛选0-未知1-男2-女',
examples: [0, 1, 2]
})),
isRoot: t.Optional(t.Boolean({
examples: [0, 1, 2],
}),
),
isRoot: t.Optional(
t.Boolean({
description: '是否超级管理员筛选',
examples: [true, false]
}))
}));
examples: [true, false],
}),
),
}),
);
/** 用户列表查询参数类型 */
export type UserListQueryRequest = Static<typeof UserListQuerySchema>;

View File

@ -44,7 +44,7 @@ export class UserService {
status: sysUsers.status,
lastLoginAt: sysUsers.lastLoginAt,
createdAt: sysUsers.createdAt,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(eq(sysUsers.id, BigInt(userId)))
@ -52,17 +52,15 @@ export class UserService {
if (!user || user.length === 0) {
Logger.warn(`用户不存在:${userId}`);
throw new BusinessError(
`用户不存在:${userId}`,
404
);
throw new BusinessError(`用户不存在:${userId}`, 404);
}
const userData = user[0]!;
Logger.info(`获取用户信息成功:${userId} - ${userData.username}`);
return successResponse({
return successResponse(
{
id: userId, // 使用传入的字符串ID避免精度丢失
username: userData.username,
email: userData.email,
@ -72,8 +70,10 @@ export class UserService {
status: userData.status,
lastLoginAt: userData.lastLoginAt || null,
createdAt: userData.createdAt,
updatedAt: userData.updatedAt
}, '获取用户信息成功');
updatedAt: userData.updatedAt,
},
'获取用户信息成功',
);
}
/**
@ -94,7 +94,7 @@ export class UserService {
// 关键词搜索(用户名、邮箱模糊搜索)
if (keyword) {
conditions.push(
sql`(${sysUsers.username} LIKE ${`%${keyword}%`} OR ${sysUsers.email} LIKE ${`%${keyword}%`})`
sql`(${sysUsers.username} LIKE ${`%${keyword}%`} OR ${sysUsers.email} LIKE ${`%${keyword}%`})`,
);
}
@ -117,10 +117,14 @@ export class UserService {
conditions.push(sql`${sysUsers.deletedAt} IS NULL`);
// 构建排序
const orderBy = sortBy === 'username' ? sysUsers.username :
sortBy === 'email' ? sysUsers.email :
sortBy === 'updatedAt' ? sysUsers.updatedAt :
sysUsers.createdAt;
const orderBy =
sortBy === 'username'
? sysUsers.username
: sortBy === 'email'
? sysUsers.email
: sortBy === 'updatedAt'
? sysUsers.updatedAt
: sysUsers.createdAt;
const orderDirection = sortOrder === 'asc' ? asc : desc;
@ -151,7 +155,7 @@ export class UserService {
failedAttempts: sysUsers.failedAttempts,
isRoot: sysUsers.isRoot,
createdAt: sysUsers.createdAt,
updatedAt: sysUsers.updatedAt
updatedAt: sysUsers.updatedAt,
})
.from(sysUsers)
.where(and(...conditions))
@ -160,7 +164,7 @@ export class UserService {
.offset((page - 1) * pageSize);
// 转换数据格式
const userList: UserListItem[] = users.map(user => ({
const userList: UserListItem[] = users.map((user) => ({
id: user.id!.toString(), // 确保ID以字符串形式返回
username: user.username,
email: user.email,
@ -177,7 +181,7 @@ export class UserService {
failedAttempts: user.failedAttempts,
isRoot: user.isRoot === 1,
createdAt: user.createdAt,
updatedAt: user.updatedAt
updatedAt: user.updatedAt,
}));
// 计算分页信息
@ -185,10 +189,13 @@ export class UserService {
Logger.info(`获取用户列表成功:总数${total},当前页${page},每页${pageSize}`);
return successResponse({
return successResponse(
{
...pagination,
data: userList
}, '获取用户列表成功');
data: userList,
},
'获取用户列表成功',
);
}
}

View File

@ -18,6 +18,7 @@
#### 1.1 正常流程测试
**测试用例**: 成功获取当前用户信息
- **前置条件**: 用户已登录有有效的JWT Token
- **测试步骤**:
1. 发送GET请求到 `/api/users/me`
@ -49,6 +50,7 @@
#### 1.2 认证失败测试
**测试用例**: 未提供JWT Token
- **前置条件**: 无
- **测试步骤**:
1. 发送GET请求到 `/api/users/me`
@ -67,6 +69,7 @@
```
**测试用例**: JWT Token无效
- **前置条件**: 无
- **测试步骤**:
1. 发送GET请求到 `/api/users/me`
@ -87,6 +90,7 @@
#### 1.3 用户不存在测试
**测试用例**: 用户已被删除
- **前置条件**: 用户已登录,但数据库中该用户已被删除
- **测试步骤**:
1. 发送GET请求到 `/api/users/me`
@ -107,6 +111,7 @@
#### 1.4 边界情况测试
**测试用例**: 用户信息字段为空
- **前置条件**: 用户已登录,但用户信息中某些字段为空
- **测试步骤**:
1. 发送GET请求到 `/api/users/me`
@ -169,11 +174,9 @@ INSERT INTO sys_users (
```typescript
// 生成测试用的JWT Token
const testToken = jwt.sign(
{ userId: '1', username: 'testuser' },
process.env.JWT_SECRET || 'test-secret',
{ expiresIn: '1h' }
);
const testToken = jwt.sign({ userId: '1', username: 'testuser' }, process.env.JWT_SECRET || 'test-secret', {
expiresIn: '1h',
});
```
## 性能测试
@ -242,13 +245,14 @@ describe('User API', () => {
describe('GET /api/users/me', () => {
it('应该成功获取当前用户信息', async () => {
const response = await app
.handle(new Request('http://localhost/api/users/me', {
const response = await app.handle(
new Request('http://localhost/api/users/me', {
method: 'GET',
headers: {
'Authorization': `Bearer ${testToken}`
}
}));
Authorization: `Bearer ${testToken}`,
},
}),
);
expect(response.status).toBe(200);
const result = await response.json();
@ -257,10 +261,11 @@ describe('User API', () => {
});
it('应该处理认证失败', async () => {
const response = await app
.handle(new Request('http://localhost/api/users/me', {
method: 'GET'
}));
const response = await app.handle(
new Request('http://localhost/api/users/me', {
method: 'GET',
}),
);
expect(response.status).toBe(401);
});
@ -273,7 +278,7 @@ describe('User API', () => {
### 测试结果记录
| 测试用例 | 状态 | 执行时间 | 备注 |
|---------|------|----------|------|
| ---------------- | ---- | -------- | ---- |
| 正常获取用户信息 | ✅ | 50ms | 通过 |
| 未提供Token | ✅ | 30ms | 通过 |
| Token无效 | ✅ | 35ms | 通过 |

View File

@ -40,7 +40,8 @@ const app = new Elysia()
})
.get('/users/:id', async ({ db, params }) => {
// 根据ID查询用户
const user = await db.select()
const user = await db
.select()
.from(users)
.where(eq(users.id, parseInt(params.id)));
return user[0];

View File

@ -181,12 +181,14 @@ export class DrizzleService {
try {
this._connectionPool = await this.createConnection();
console.log(process.env.NODE_ENV, process.env.NODE_ENV === 'development')
console.log(process.env.NODE_ENV, process.env.NODE_ENV === 'development');
/** Drizzle数据库实例 */
this._db = drizzle(this._connectionPool, {
schema,
mode: 'default',
logger: process.env.NODE_ENV === 'development' ? {
logger:
process.env.NODE_ENV === 'development'
? {
logQuery: (query, params) => {
Logger.debug({
type: 'SQL_QUERY',
@ -194,7 +196,8 @@ export class DrizzleService {
params: params,
});
},
} : false,
}
: false,
});
this._isInitialized = true;

View File

@ -43,8 +43,7 @@ EMAIL_RETRY_DELAY=5000
import { Elysia } from 'elysia';
import { emailPlugin } from '@/plugins/email/email.plugins';
const app = new Elysia()
.use(emailPlugin)
const app = new Elysia().use(emailPlugin);
// ... 其他插件
```
@ -156,6 +155,7 @@ app.get('/email/health', async ({ emailService }) => {
发送自定义邮件。
**参数:**
- `options.to`: 收件人邮箱(字符串或数组)
- `options.subject`: 邮件主题
- `options.html`: HTML 内容
@ -170,6 +170,7 @@ app.get('/email/health', async ({ emailService }) => {
发送模板邮件。
**参数:**
- `options.to`: 收件人邮箱
- `options.template`: 模板类型
- `options.params`: 模板参数

View File

@ -129,11 +129,7 @@ export const emailPlugin = new Elysia({ name: 'email' })
/**
*
*/
async sendWelcomeEmail(options: {
to: string;
username: string;
nickname?: string;
}): Promise<EmailSendResult> {
async sendWelcomeEmail(options: { to: string; username: string; nickname?: string }): Promise<EmailSendResult> {
return await emailService.sendTemplateEmail({
to: options.to,
template: 'welcome',
@ -221,11 +217,7 @@ export type EmailServiceDecorator = {
resetCode: string;
expireTime: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: {
to: string;
username: string;
nickname?: string;
}): Promise<EmailSendResult>;
sendWelcomeEmail(options: { to: string; username: string; nickname?: string }): Promise<EmailSendResult>;
sendPasswordChangedEmail(options: {
to: string;
username: string;

View File

@ -107,7 +107,7 @@ export class EmailService {
private updateStatus(
status: EmailServiceStatus['status'],
transporterStatus: EmailServiceStatus['transporterStatus'],
error?: string
error?: string,
): void {
this._status = {
status,
@ -191,9 +191,7 @@ export class EmailService {
}
const fromName = emailConfig.fromName || '星撰系统';
const formattedFrom = fromAddress.includes('<')
? fromAddress
: `"${fromName}" <${fromAddress}>`;
const formattedFrom = fromAddress.includes('<') ? fromAddress : `"${fromName}" <${fromAddress}>`;
const mailOptions = {
from: formattedFrom,
@ -263,7 +261,7 @@ export class EmailService {
}
// 等待重试延迟
await new Promise(resolve => setTimeout(resolve, emailOptions.retryDelay));
await new Promise((resolve) => setTimeout(resolve, emailOptions.retryDelay));
}
}
@ -326,7 +324,7 @@ export class EmailService {
*/
private renderTemplate(
templateType: EmailTemplateType,
params: EmailTemplateParams
params: EmailTemplateParams,
): { subject: string; html: string; text: string } {
const template = emailTemplates[templateType];
const defaultParams = {

View File

@ -83,6 +83,14 @@ export const errorHandlerPlugin = (app: Elysia) =>
errors: error.message,
};
}
case 409: {
set.status = code;
return {
code: error.code,
message: '数据已存在,请勿重复操作',
errors: error.message,
};
}
default: {
// 处理 ElysiaCustomStatusResponse status抛出的异常
if (error?.constructor?.name === 'ElysiaCustomStatusResponse') {
@ -94,7 +102,13 @@ export const errorHandlerPlugin = (app: Elysia) =>
};
}
console.log('error ==================== \n', error, `\n ==================== error \n`, code, 'code ==============');
console.log(
'error ==================== \n',
error,
'\n ==================== error \n',
code,
'code ==============',
);
set.status = 500;
Logger.error(error as Error);
return {

View File

@ -25,20 +25,23 @@ export class JwtService {
type: TOKEN_TYPES.ACTIVATION,
},
jwtConfig.secret,
{ expiresIn: '1D' }
{ expiresIn: '1D' },
);
}
/**
* Token对
*/
generateTokens(userInfo: {
generateTokens(
userInfo: {
id: string;
username: string;
email: string;
nickname?: string;
status: string;
}, rememberMe = false) {
},
rememberMe = false,
) {
const userPayload = {
userId: userInfo.id,
username: userInfo.username,
@ -52,8 +55,8 @@ export class JwtService {
type: TOKEN_TYPES.ACCESS,
},
jwtConfig.secret,
{ expiresIn: '20M' }
)
{ expiresIn: '20M' },
);
const refreshToken = jwt.sign(
{
@ -61,8 +64,8 @@ export class JwtService {
type: TOKEN_TYPES.REFRESH,
},
jwtConfig.secret,
{ expiresIn: '14D' }
)
{ expiresIn: '14D' },
);
return {
accessToken,
@ -78,7 +81,7 @@ export class JwtService {
*/
verifyToken(token: string) {
try {
return jwt.verify(token, jwtConfig.secret) as JwtPayloadType
return jwt.verify(token, jwtConfig.secret) as JwtPayloadType;
} catch {
return { error: true } as JwtPayloadType;
}
@ -94,7 +97,7 @@ export class JwtService {
type: TOKEN_TYPES.PASSWORD_RESET,
},
jwtConfig.secret,
{ expiresIn: '30M' }
{ expiresIn: '30M' },
);
}
}

View File

@ -26,7 +26,7 @@ export const loggerPlugin = (app: Elysia) =>
.state('requestStart', null as [number, number] | null)
.state('color', null as string | null)
/** 请求拦截器 - 记录请求信息 */
.onRequest(({ store, request, server, path,}) => {
.onRequest(({ store, request, server, path }) => {
/** 记录请求开始时间 */
store.requestStart = process.hrtime();
/** 获取客户端IP信息 */

View File

@ -196,8 +196,7 @@ const formatMessage = (message: string | object): string => {
return message;
}
return JSON.stringify(message, (_, v) =>
typeof v === 'bigint' ? v.toString() : v, 2);
return JSON.stringify(message, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2);
};
/**

View File

@ -17,4 +17,3 @@ import { redisService } from './redis.service';
export const redisPlugin = new Elysia({ name: 'redis' }).onStart(async () => {
await redisService.initialize();
});

View File

@ -10,11 +10,7 @@
import { createClient } from 'redis';
import { redisConfig, getRedisUrl } from '@/config/redis.config';
import { Logger } from '@/plugins/logger/logger.service';
import type {
RedisConnectionStatus,
RedisConnectionInfo,
RedisHealthCheckResult
} from '@/type/redis.type';
import type { RedisConnectionStatus, RedisConnectionInfo, RedisHealthCheckResult } from '@/type/redis.type';
/**
* Redis服务类

View File

@ -10,7 +10,7 @@ import {
sendEmail,
sendTemplateEmail,
checkEmailServiceHealth,
closeEmailService
closeEmailService,
} from '@/plugins/email/email.service';
import { validateEmailConfig } from '@/config/email.config';
import type { EmailSendOptions, EmailTemplateSendOptions } from '@/type/email.type';
@ -188,7 +188,7 @@ async function main() {
// 等待一下再发送模板邮件
console.log('\n⏳ 等待2秒后发送模板邮件...');
await new Promise(resolve => setTimeout(resolve, 2000));
await new Promise((resolve) => setTimeout(resolve, 2000));
await demo.sendTemplateEmail(testEmail);
@ -196,7 +196,6 @@ async function main() {
console.log('✨ Demo执行完成请检查您的邮箱收件箱');
console.log('📬 如果没收到邮件,请检查垃圾邮件文件夹');
console.log('='.repeat(50));
} catch (error) {
console.log('💥 Demo执行过程中出现错误:', error);
} finally {

View File

@ -16,13 +16,13 @@ import {
sendTemplateEmail,
getEmailServiceStatus,
checkEmailServiceHealth,
closeEmailService
closeEmailService,
} from '@/plugins/email/email.service';
import { validateEmailConfig } from '@/config/email.config';
import type { EmailSendOptions, EmailTemplateSendOptions } from '@/type/email.type';
// 简单的延时函数
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
// 测试用的邮箱地址(请根据实际情况修改)
const TEST_EMAIL = 'x71291@outlook.com';
@ -95,7 +95,9 @@ describe('邮件服务测试', () => {
// 只在邮件配置有效时运行实际发送测试
const runSendTest = isEmailConfigValid ? it : it.skip;
runSendTest('应该能够发送简单文本邮件', async () => {
runSendTest(
'应该能够发送简单文本邮件',
async () => {
const emailOptions: EmailSendOptions = {
to: TEST_EMAIL,
subject: '测试邮件 - 简单文本',
@ -116,9 +118,13 @@ describe('邮件服务测试', () => {
} else {
console.warn('邮件发送失败:', result.error);
}
}, 10000); // 设置较长的超时时间
},
10000,
); // 设置较长的超时时间
runSendTest('应该能够发送带抄送的邮件', async () => {
runSendTest(
'应该能够发送带抄送的邮件',
async () => {
const emailOptions: EmailSendOptions = {
to: TEST_EMAIL,
cc: TEST_EMAIL, // 测试环境下抄送给同一个邮箱
@ -129,7 +135,9 @@ describe('邮件服务测试', () => {
const result = await sendEmail(emailOptions);
expect(result).toHaveProperty('success');
expect(result).toHaveProperty('sentAt');
}, 10000);
},
10000,
);
it('应该处理邮件发送错误', async () => {
const invalidEmailOptions: EmailSendOptions = {
@ -154,7 +162,9 @@ describe('邮件服务测试', () => {
describe('模板邮件功能', () => {
const runTemplateTest = isEmailConfigValid ? it : it.skip;
runTemplateTest('应该能够发送用户激活邮件', async () => {
runTemplateTest(
'应该能够发送用户激活邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'activation',
@ -177,9 +187,13 @@ describe('邮件服务测试', () => {
expect(result).toHaveProperty('messageId');
console.log('激活邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送密码重置邮件', async () => {
runTemplateTest(
'应该能够发送密码重置邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'passwordReset',
@ -201,9 +215,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('密码重置邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送欢迎邮件', async () => {
runTemplateTest(
'应该能够发送欢迎邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'welcome',
@ -222,9 +240,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('欢迎邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送密码修改通知邮件', async () => {
runTemplateTest(
'应该能够发送密码修改通知邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'passwordChanged',
@ -243,9 +265,13 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('密码修改通知邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
runTemplateTest('应该能够发送系统通知邮件', async () => {
runTemplateTest(
'应该能够发送系统通知邮件',
async () => {
const templateOptions: EmailTemplateSendOptions = {
to: TEST_EMAIL,
template: 'notification',
@ -265,7 +291,9 @@ describe('邮件服务测试', () => {
if (result.success) {
console.log('系统通知邮件发送成功:', result.messageId);
}
}, 10000);
},
10000,
);
it('应该处理无效模板类型', async () => {
const invalidTemplateOptions = {
@ -309,7 +337,9 @@ describe('邮件服务测试', () => {
describe('邮件服务性能测试', () => {
const runPerformanceTest = isEmailConfigValid ? it : it.skip;
runPerformanceTest('应该能够并发发送多封邮件', async () => {
runPerformanceTest(
'应该能够并发发送多封邮件',
async () => {
const emailPromises = [];
const emailCount = 3; // 限制并发数量以避免SMTP限制
@ -331,7 +361,9 @@ describe('邮件服务测试', () => {
expect(result).toHaveProperty('sentAt');
console.log(`邮件 ${index + 1} 发送结果:`, result.success ? '成功' : '失败');
});
}, 30000); // 更长的超时时间用于并发测试
},
30000,
); // 更长的超时时间用于并发测试
});
describe('邮件模板渲染测试', () => {

View File

@ -14,7 +14,7 @@ import { app } from '@/app';
describe('健康检查接口测试', () => {
beforeAll(async () => {
// 等待应用启动
await new Promise(resolve => setTimeout(resolve, 1000));
await new Promise((resolve) => setTimeout(resolve, 1000));
});
describe('GET /api/health', () => {
@ -297,7 +297,7 @@ describe('健康检查接口测试', () => {
const responses = await Promise.all(promises);
responses.forEach(res => {
responses.forEach((res) => {
expect(res.status).toBe(200);
});
});

View File

@ -13,7 +13,7 @@ import { Redis } from '@/utils/redis';
import { redisConfig } from '@/config/redis.config';
// 简单的延时函数
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
describe('Redis连接测试', () => {
let redis: Redis;

View File

@ -8,7 +8,6 @@
*/
import { describe, it, expect } from 'vitest';
import { setTimeout } from 'node:timers';
import { app } from '@/app';
describe('Swagger API文档测试', () => {

View File

@ -20,7 +20,7 @@ export const TOKEN_TYPES = {
/**
* Token类型定义
*/
export type TokenType = typeof TOKEN_TYPES[keyof typeof TOKEN_TYPES];
export type TokenType = (typeof TOKEN_TYPES)[keyof typeof TOKEN_TYPES];
/**
* JWT Token中的用户信息类型

View File

@ -1,4 +1,3 @@
/**
* Logger类的类型定义
*/

View File

@ -86,7 +86,7 @@ export class DistributedLockService {
// 使用 SET key value NX EX seconds 原子操作
const result = await redisService.client.set(lockKey, lockValue, {
NX: true, // 只有当 key 不存在时才设置
EX: ttl // 设置过期时间(秒)
EX: ttl, // 设置过期时间(秒)
});
if (result === 'OK') {
@ -136,7 +136,7 @@ export class DistributedLockService {
// 续期锁
renew: async (): Promise<boolean> => {
return await this.renewLock(lockKey, lockValue, ttl);
}
},
};
// 启动自动续期(仅在需要时)
@ -172,7 +172,6 @@ export class DistributedLockService {
}
return lock;
} catch (error) {
// 清理已创建的定时器和事件监听器
if (renewTimer) {
@ -208,7 +207,7 @@ export class DistributedLockService {
const result = await redisService.client.eval(luaScript, {
keys: [lockKey],
arguments: [lockValue]
arguments: [lockValue],
});
return result === 1;
@ -238,7 +237,7 @@ export class DistributedLockService {
const result = await redisService.client.eval(luaScript, {
keys: [lockKey],
arguments: [lockValue, ttl.toString()]
arguments: [lockValue, ttl.toString()],
});
return result === 1;
@ -291,7 +290,7 @@ export class DistributedLockService {
* @returns Promise<void>
*/
private static sleep(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
return new Promise((resolve) => setTimeout(resolve, ms));
}
}
@ -312,7 +311,7 @@ export const LOCK_KEYS = {
// 验证码生成锁
CAPTCHA_GENERATE: 'captcha:generate',
// 邮件发送锁
EMAIL_SEND: 'email:send'
EMAIL_SEND: 'email:send',
} as const;
/**
@ -330,7 +329,7 @@ export function withDistributedLock(lockKey: string, ttl: number = 30, timeout:
key: lockKey,
ttl,
timeout,
autoRenew: true
autoRenew: true,
});
try {

View File

@ -87,7 +87,7 @@ export function isTokenExpiringSoon(payload: JwtPayloadType, thresholdMinutes: n
const now = Math.floor(Date.now() / 1000);
const threshold = thresholdMinutes * 60;
return (payload.exp - now) <= threshold;
return payload.exp - now <= threshold;
}
/**

View File

@ -7,42 +7,47 @@
* @description Schema和工具函数
*/
import { t, type Static, type TSchema } from 'elysia';
import { t, type Static } from 'elysia';
/**
* Schema
*/
export const BasePaginationSchema = t.Object({
/** 页码从1开始 */
page: t.Optional(t.Number({
page: t.Optional(
t.Number({
minimum: 1,
description: '页码从1开始',
examples: [1, 2, 3],
default: 1
})),
default: 1,
}),
),
/** 每页大小最大100 */
pageSize: t.Optional(t.Number({
pageSize: t.Optional(
t.Number({
minimum: 1,
maximum: 100,
description: '每页大小最大100',
examples: [10, 20, 50],
default: 20
})),
default: 20,
}),
),
/** 排序字段 */
sortBy: t.Optional(t.String({
sortBy: t.Optional(
t.String({
description: '排序字段',
examples: ['createdAt', 'updatedAt', 'username', 'email'],
default: 'createdAt'
})),
default: 'createdAt',
}),
),
/** 排序方向 */
sortOrder: t.Optional(t.Union([
t.Literal('asc'),
t.Literal('desc')
], {
sortOrder: t.Optional(
t.Union([t.Literal('asc'), t.Literal('desc')], {
description: '排序方向',
examples: ['asc', 'desc'],
default: 'desc'
}))
default: 'desc',
}),
),
});
/**
@ -54,9 +59,9 @@ export const BasePaginationSchema = t.Object({
export const createQuerySchema = (customSchema: any) => {
return t.Object({
...BasePaginationSchema.properties,
...customSchema.properties
...customSchema.properties,
});
}
};
/**
*
@ -72,20 +77,20 @@ export const createPaginationResponseSchema = <T>(dataSchema: T) => {
/** 总记录数 */
total: t.Number({
description: '总记录数',
examples: [100, 250, 1000]
examples: [100, 250, 1000],
}),
/** 当前页码 */
page: t.Number({
description: '当前页码',
examples: [1, 2, 3]
examples: [1, 2, 3],
}),
/** 每页大小 */
pageSize: t.Number({
description: '每页大小',
examples: [10, 20, 50]
examples: [10, 20, 50],
}),
/** 数据列表 */
data: t.Array(dataSchema)
data: t.Array(dataSchema),
});
};
@ -110,7 +115,7 @@ export const calculatePagination = (total: number, page: number, pageSize: numbe
return {
total,
page,
pageSize
pageSize,
};
};
@ -124,6 +129,6 @@ export const normalizePaginationParams = (params: Partial<BasePaginationRequest>
page: Math.max(1, params.page || 1),
pageSize: Math.min(100, Math.max(1, params.pageSize || 20)),
sortBy: params.sortBy || 'createdAt',
sortOrder: params.sortOrder || 'desc'
sortOrder: params.sortOrder || 'desc',
};
};

View File

@ -7,7 +7,7 @@
* @description
*/
import Logger from "@/plugins/logger/logger.service";
import Logger from '@/plugins/logger/logger.service';
/**
*
@ -21,8 +21,8 @@ export const successResponse = (data: any, message: string = 'success') => {
message,
data,
timestamp: new Date().toISOString(),
}
}
};
};
export const errorResponse = (code: number, message: string, type: string, data: any = null) => {
const response = {
@ -31,10 +31,10 @@ export const errorResponse = (code: number, message: string, type: string, data:
data,
type,
timestamp: new Date().toISOString(),
}
};
Logger.warn(response);
return response
}
return response;
};
export class BusinessError extends Error {
public readonly code: number;

View File

@ -7,7 +7,7 @@
* @description ID生成器的单元测试ID生成
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { describe, it, expect, beforeEach } from 'vitest';
import { Snowflake, getSnowflake, nextId, parseId, createSnowflake, type SnowflakeConfig } from './snowflake';
describe('Snowflake ID Generator', () => {

View File

@ -49,7 +49,8 @@ export class Snowflake {
/** 数据中心ID左移位数 */
private static readonly DATACENTER_ID_SHIFT = Snowflake.SEQUENCE_BITS + Snowflake.WORKER_ID_BITS;
/** 时间戳左移位数 */
private static readonly TIMESTAMP_LEFT_SHIFT = Snowflake.SEQUENCE_BITS + Snowflake.WORKER_ID_BITS + Snowflake.DATACENTER_ID_BITS;
private static readonly TIMESTAMP_LEFT_SHIFT =
Snowflake.SEQUENCE_BITS + Snowflake.WORKER_ID_BITS + Snowflake.DATACENTER_ID_BITS;
/** 工作机器ID */
private readonly workerId: number;
@ -115,10 +116,11 @@ export class Snowflake {
this.lastTimestamp = timestamp;
// 生成雪花ID
const id = ((BigInt(timestamp - this.epoch) << BigInt(Snowflake.TIMESTAMP_LEFT_SHIFT)) |
const id =
(BigInt(timestamp - this.epoch) << BigInt(Snowflake.TIMESTAMP_LEFT_SHIFT)) |
(BigInt(this.datacenterId) << BigInt(Snowflake.DATACENTER_ID_SHIFT)) |
(BigInt(this.workerId) << BigInt(Snowflake.WORKER_ID_SHIFT)) |
BigInt(this.sequence));
BigInt(this.sequence);
return id;
}
@ -136,7 +138,9 @@ export class Snowflake {
createdAt: Date;
} {
const timestamp = Number((id >> BigInt(Snowflake.TIMESTAMP_LEFT_SHIFT)) & BigInt((1 << 41) - 1));
const datacenterId = Number((id >> BigInt(Snowflake.DATACENTER_ID_SHIFT)) & BigInt(Snowflake.MAX_DATACENTER_ID));
const datacenterId = Number(
(id >> BigInt(Snowflake.DATACENTER_ID_SHIFT)) & BigInt(Snowflake.MAX_DATACENTER_ID),
);
const workerId = Number((id >> BigInt(Snowflake.WORKER_ID_SHIFT)) & BigInt(Snowflake.MAX_WORKER_ID));
const sequence = Number(id & BigInt(Snowflake.MAX_SEQUENCE));

View File

@ -1,380 +0,0 @@
# M2 - 基础用户系统 - 开发任务计划
## 相关文件 (Relevant Files)
### 认证模块 (Auth)
- `src/modules/auth/auth.schema.ts` - 认证模块Schema定义
- `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.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.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.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.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.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.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.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.md` - 日志模块测试用例文档
### 备注 (Notes)
- 验证码功能已有captcha模块可直接集成
- 遵循Elysia开发规范每个接口都要有完整的5个文件
- 按照PRD优先级P0 > P1 > P2 顺序开发
## 任务 (Tasks)
### 🔐 认证模块 (Auth Module) - P0优先级
- [x] 1.0 POST /auth/register - 用户注册接口
- [x] 1.1 创建auth.schema.ts - 定义用户注册Schema
- [x] 1.2 创建auth.response.ts - 定义注册响应格式
- [x] 1.3 创建auth.service.ts - 实现注册业务逻辑
- [x] 1.4 创建auth.controller.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.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.md - 编写登录测试用例文档
- [x] 4.0 POST /auth/refresh - Token刷新接口
- [x] 4.1 扩展auth.schema.ts - 定义刷新Schema
- [x] 4.2 扩展auth.response.ts - 定义刷新响应格式
- [x] 4.3 扩展auth.service.ts - 实现刷新业务逻辑
- [x] 4.4 扩展auth.controller.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.md - 编写退出测试用例文档~~
- [x] 6.0 POST /auth/password/reset-request - 找回密码接口
- [x] 6.1 扩展auth.schema.ts - 定义找回密码Schema
- [x] 6.2 扩展auth.response.ts - 定义找回密码响应格式
- [x] 6.3 扩展auth.service.ts - 实现找回密码业务逻辑
- [x] 6.4 扩展auth.controller.ts - 实现找回密码路由
- [x] 6.5 扩展auth.test.md - 编写找回密码测试用例文档
- [x] 7.0 POST /auth/password/reset-confirm - 重置密码接口
- [x] 7.1 扩展auth.schema.ts - 定义重置密码Schema
- [x] 7.2 扩展auth.response.ts - 定义重置密码响应格式
- [x] 7.3 扩展auth.service.ts - 实现重置密码业务逻辑
- [x] 7.4 扩展auth.controller.ts - 实现重置密码路由
- [x] 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.md - 编写验证码测试用例文档
- [x] 9.0 检查认证模块 (Auth Module)那些接口需要加分布式锁,并加锁
### 👤 用户管理模块 (User Module) - P0优先级
- [x] 9.0 GET /users/me - 获取当前用户信息接口
- [x] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [x] 9.1 扩展user.schema.ts - 定义当前用户Schema
- [x] 9.2 扩展user.response.ts - 定义当前用户响应格式
- [x] 9.3 扩展user.service.ts - 实现当前用户业务逻辑
- [x] 9.4 更新user.controller.ts - 实现当前用户路由
- [x] 9.5 创建user.test.md - 编写当前用户测试用例文档
- [x] 10.0 GET /users - 用户列表查询接口
- [x] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [x] 10.1 扩展user.schema.ts - 定义用户列表Schema
- [x] 10.2 扩展user.response.ts - 定义用户列表响应格式
- [x] 10.3 扩展user.service.ts - 实现用户列表业务逻辑
- [x] 10.4 扩展user.controller.ts - 实现用户列表路由
- [x] 10.5 扩展user.test.md - 编写用户列表测试用例文档
- [ ] 11.0 POST /users - 创建用户接口
- [ ] 0.0 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写创建用户测试用例文档
- [ ] 12.0 PUT /users/{id} - 更新用户信息接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写更新用户测试用例文档
- [ ] 13.0 DELETE /users/{id} - 删除用户接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写删除用户测试用例文档
- [ ] 14.0 PUT /users/me/password - 修改密码接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写修改密码测试用例文档
- [ ] 15.0 GET /users/{id} - 用户详情接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写用户详情测试用例文档
- [ ] 16.0 POST /users/batch - 批量操作接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写批量操作测试用例文档
### 🎭 角色权限模块 (Role Module) - P0优先级
- [ ] 17.0 GET /roles - 角色列表接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 17.1 创建role.schema.ts - 定义角色Schema
- [ ] 17.2 创建role.response.ts - 定义角色响应格式
- [ ] 17.3 创建role.service.ts - 实现角色业务逻辑
- [ ] 17.4 创建role.controller.ts - 实现角色路由
- [ ] 17.5 创建role.test.md - 编写角色测试用例文档
- [ ] 18.0 POST /roles - 创建角色接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写创建角色测试用例文档
- [ ] 19.0 PUT /roles/{id} - 更新角色接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写更新角色测试用例文档
- [ ] 20.0 DELETE /roles/{id} - 删除角色接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写删除角色测试用例文档
- [ ] 21.0 GET /permissions - 权限列表接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写权限测试用例文档
- [ ] 22.0 POST /roles/{id}/permissions - 权限分配接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写权限分配测试用例文档
- [ ] 23.0 POST /users/{id}/roles - 用户角色分配接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写用户角色分配测试用例文档
### 🏢 组织架构模块 (Organization Module) - P1优先级
- [ ] 24.0 GET /organizations - 组织列表接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 24.1 创建organization.schema.ts - 定义组织Schema
- [ ] 24.2 创建organization.response.ts - 定义组织响应格式
- [ ] 24.3 创建organization.service.ts - 实现组织业务逻辑
- [ ] 24.4 创建organization.controller.ts - 实现组织路由
- [ ] 24.5 创建organization.test.md - 编写组织测试用例文档
- [ ] 25.0 POST /organizations - 创建组织接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写创建组织测试用例文档
- [ ] 26.0 PUT /organizations/{id} - 更新组织接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写更新组织测试用例文档
- [ ] 27.0 DELETE /organizations/{id} - 删除组织接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写删除组织测试用例文档
- [ ] 28.0 POST /users/{id}/organizations - 用户组织关系接口
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写用户组织关系测试用例文档
### 🗂️ 系统基础模块 (System Module) - P1优先级
- [ ] 29.0 字典类型管理 - CRUD /dict-types
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 29.1 创建dict.schema.ts - 定义字典类型Schema
- [ ] 29.2 创建dict.response.ts - 定义字典类型响应格式
- [ ] 29.3 创建dict.service.ts - 实现字典类型业务逻辑
- [ ] 29.4 创建dict.controller.ts - 实现字典类型路由
- [ ] 29.5 创建dict.test.md - 编写字典类型测试用例文档
- [ ] 30.0 字典项管理 - CRUD /dict-items
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写字典项测试用例文档
- [ ] 31.0 标签管理 - CRUD /tags
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写标签测试用例文档
- [ ] 32.0 操作日志 - GET /logs/operations
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写操作日志测试用例文档
- [ ] 33.0 登录日志 - GET /logs/logins
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 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.md - 编写登录日志测试用例文档
### 🔧 基础设施完善
- [ ] 34.0 JWT认证中间件
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 34.1 创建JWT认证插件
- [ ] 34.2 实现Token黑名单管理
- [ ] 34.3 实现RefreshToken机制
- [ ] 34.4 集成权限验证中间件
- [ ] 34.5 编写认证中间件测试
- [ ] 35.0 路由模块集成
- [ ] Before 整理输入此接口的逻辑必须等待用户确认后进行需要输入go才能进行下一步
- [ ] 35.1 更新src/modules/index.ts - 集成所有模块
- [ ] 35.2 更新src/app.ts - 注册所有路由
- [ ] 35.3 更新Swagger标签定义
- [ ] 35.4 完善API文档
- [ ] 35.5 集成测试验证
## 开发优先级说明
### 第一阶段P0基础认证和用户管理
- **认证模块**用户注册、激活、登录、刷新、退出任务1-5
- **用户管理模块**当前用户、用户列表、用户CRUD、密码管理任务9-14
- **完成目标**:具备基本的用户认证和管理功能
### 第二阶段P0角色权限系统
- **角色管理**角色CRUD、权限分配任务17-20
- **权限管理**权限列表、权限分配、用户角色分配任务21-23
- **完成目标**具备完整的RBAC权限控制体系
### 第三阶段P1扩展功能
- **密码管理**找回密码、重置密码任务6-7
- **验证码系统**图形验证码任务8
- **用户扩展**用户详情、批量操作任务15-16
- **组织架构**组织管理、用户组织关系任务24-28
### 第四阶段P1-P2系统完善
- **系统基础**字典、标签、日志管理任务29-33
- **基础设施**JWT中间件、路由集成任务34-35
- **完成目标**:系统功能完整,可投入生产使用
## 备注说明
1. **已完成部分**用户模块的Schema、Response、Service已基本完成可直接使用
2. **验证码集成**现有captcha模块可直接集成到认证流程中
3. **开发规范**严格按照Elysia开发规范每个接口都要有完整的5个子任务
4. **测试要求**:每个模块都要有完整的测试用例文档,确保功能正确性
5. **优先级管理**按照P0 > P1 > P2的顺序开发确保核心功能优先完成

View File

@ -3,9 +3,11 @@
## 1. 项目概述
### 1.1 项目背景
基于星撰个人综合平台的M2阶段需求开发完整的基础用户系统。该系统将为后续的博客系统、个人空间、阅读系统等功能模块提供统一的用户管理和权限控制基础。
### 1.2 项目目标
- 构建安全可靠的用户认证和授权体系
- 实现灵活的角色和权限管理
- 提供完整的用户生命周期管理
@ -13,7 +15,9 @@
- 为后续功能模块提供统一的用户服务
### 1.3 项目范围
本次开发包含以下核心模块:
- **认证模块**:注册、登录、激活、密码管理
- **用户管理模块**用户CRUD、信息管理、状态管理
- **角色权限模块**:角色管理、权限分配、权限验证
@ -25,8 +29,9 @@
### 2.1 核心功能清单
#### 2.1.1 认证模块 (Auth)
| 功能 | 优先级 | 状态 | 接口 |
|------|--------|------|------|
| ---------- | ------ | ------ | --------------------------------- |
| 用户注册 | P0 | 待开发 | POST /auth/register |
| 邮箱激活 | P0 | 待开发 | POST /auth/activate |
| 用户登录 | P0 | 待开发 | POST /auth/login |
@ -37,8 +42,9 @@
| 图形验证码 | P1 | 待开发 | GET /auth/captcha |
#### 2.1.2 用户管理模块 (User)
| 功能 | 优先级 | 状态 | 接口 |
|------|--------|------|------|
| ---------------- | ------ | ------ | ---------------------- |
| 获取当前用户信息 | P0 | 待开发 | GET /users/me |
| 用户列表查询 | P0 | 待开发 | GET /users |
| 创建用户 | P0 | 待开发 | POST /users |
@ -49,8 +55,9 @@
| 批量操作 | P2 | 待开发 | POST /users/batch |
#### 2.1.3 角色权限模块 (Role & Permission)
| 功能 | 优先级 | 状态 | 接口 |
|------|--------|------|------|
| ------------ | ------ | ------ | ---------------------------- |
| 角色列表 | P0 | 待开发 | GET /roles |
| 创建角色 | P0 | 待开发 | POST /roles |
| 更新角色 | P0 | 待开发 | PUT /roles/{id} |
@ -60,8 +67,9 @@
| 用户角色分配 | P0 | 待开发 | POST /users/{id}/roles |
#### 2.1.4 组织架构模块 (Organization)
| 功能 | 优先级 | 状态 | 接口 |
|------|--------|------|------|
| ------------ | ------ | ------ | ------------------------------ |
| 组织列表 | P1 | 待开发 | GET /organizations |
| 创建组织 | P1 | 待开发 | POST /organizations |
| 更新组织 | P1 | 待开发 | PUT /organizations/{id} |
@ -69,8 +77,9 @@
| 用户组织关系 | P1 | 待开发 | POST /users/{id}/organizations |
#### 2.1.5 系统基础模块 (System)
| 功能 | 优先级 | 状态 | 接口 |
|------|--------|------|------|
| ------------ | ------ | ------ | -------------------- |
| 字典类型管理 | P1 | 待开发 | CRUD /dict-types |
| 字典项管理 | P1 | 待开发 | CRUD /dict-items |
| 标签管理 | P1 | 待开发 | CRUD /tags |
@ -80,6 +89,7 @@
### 2.2 技术架构
#### 2.2.1 后端架构
- **框架**Elysia (Bun)
- **数据库**MySQL + Drizzle ORM
- **缓存**Redis
@ -89,11 +99,13 @@
- **API文档**Swagger
#### 2.2.2 数据存储策略
- **主数据**MySQL存储
- **缓存数据**Redis存储用户会话、验证码、权限缓存
- **文件存储**:本地存储 + 后续可扩展OSS
#### 2.2.3 安全策略
- **密码加密**bcrypt (cost=12)
- **JWT策略**AccessToken(2小时) + RefreshToken(7天)
- **权限控制**RBAC模型
@ -105,9 +117,11 @@
### 3.1 阶段划分
#### 第一阶段:基础认证系统 (1-2周)
**目标**:完成用户注册、登录、基础用户管理功能
**核心任务**
- 数据库表结构完善
- 用户注册/登录接口
- JWT认证中间件
@ -115,14 +129,17 @@
- 单元测试编写
**交付物**
- 可工作的用户注册登录系统
- 完整的API文档
- 基础测试用例
#### 第二阶段:角色权限系统 (1-2周)
**目标**完成RBAC权限控制体系
**核心任务**
- 角色管理功能
- 权限管理功能
- 权限验证中间件
@ -130,14 +147,17 @@
- 权限缓存机制
**交付物**
- 完整的RBAC系统
- 权限控制中间件
- 管理员操作界面接口
#### 第三阶段:系统完善 (1周)
**目标**:完善系统功能,优化性能
**核心任务**
- 组织架构管理
- 字典标签管理
- 操作日志记录
@ -145,6 +165,7 @@
- 安全加固
**交付物**
- 完整的用户系统
- 性能测试报告
- 部署文档
@ -152,7 +173,7 @@
### 3.2 里程碑计划
| 里程碑 | 时间节点 | 主要交付物 |
|--------|----------|------------|
| ------ | -------- | ------------------ |
| M2.1 | 第1周末 | 基础认证功能完成 |
| M2.2 | 第2周末 | 用户管理功能完成 |
| M2.3 | 第3周末 | 角色权限功能完成 |
@ -161,18 +182,21 @@
## 4. 质量保障
### 4.1 测试策略
- **单元测试**:覆盖率 > 80%
- **集成测试**:关键业务流程测试
- **性能测试**并发用户1000+
- **安全测试**OWASP Top 10检查
### 4.2 代码质量
- **代码规范**ESLint + Prettier
- **类型安全**TypeScript严格模式
- **代码审查**Pull Request必须审查
- **文档完善**:接口文档、部署文档
### 4.3 监控告警
- **API监控**:响应时间、错误率
- **数据库监控**:连接数、慢查询
- **缓存监控**Redis状态监控
@ -181,15 +205,17 @@
## 5. 风险评估
### 5.1 技术风险
| 风险 | 概率 | 影响 | 应对策略 |
|------|------|------|----------|
| -------------- | ---- | ---- | ---------------------------- |
| 数据库性能瓶颈 | 中 | 高 | 索引优化、查询优化 |
| JWT安全性问题 | 低 | 高 | RefreshToken轮转、黑名单机制 |
| 并发数据一致性 | 中 | 中 | 乐观锁、Redis锁 |
### 5.2 进度风险
| 风险 | 概率 | 影响 | 应对策略 |
|------|------|------|----------|
| ------------ | ---- | ---- | ------------------------ |
| 需求变更 | 中 | 中 | 敏捷开发、版本控制 |
| 技术难点 | 低 | 中 | 技术预研、备选方案 |
| 测试时间不足 | 中 | 高 | 并行开发测试、自动化测试 |
@ -197,18 +223,21 @@
## 6. 成功标准
### 6.1 功能指标
- ✅ 用户注册成功率 > 95%
- ✅ 登录响应时间 < 200ms
- ✅ 权限验证准确率 = 100%
- ✅ 密码安全强度符合规范
### 6.2 技术指标
- ✅ API可用性 > 99.9%
- ✅ 单元测试覆盖率 > 80%
- ✅ 代码质量评分 > 8.0
- ✅ 安全漏洞 = 0
### 6.3 用户体验指标
- ✅ 注册流程步骤 ≤ 3步
- ✅ 忘记密码找回成功率 > 90%
- ✅ 用户反馈满意度 > 85%
@ -216,18 +245,21 @@
## 7. 后续规划
### 7.1 功能扩展
- OAuth第三方登录微信、GitHub等
- 两步验证2FA
- 单点登录SSO
- 用户行为分析
### 7.2 性能优化
- 分库分表策略
- 缓存策略优化
- CDN接入
- 数据库读写分离
### 7.3 运维支持
- 容器化部署
- 监控体系完善
- 自动化运维

View File

@ -0,0 +1,390 @@
# M2 - 基础用户系统 - 开发任务计划
## 相关文件 (Relevant Files)
### 认证模块 (Auth)
- `src/modules/auth/auth.schema.ts` - 认证模块Schema定义
- `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.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.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.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.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.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.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.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.md` - 日志模块测试用例文档
### 备注 (Notes)
- 验证码功能已有captcha模块可直接集成
- 遵循Elysia开发规范每个接口都要有完整的5个文件
- 按照PRD优先级P0 > P1 > P2 顺序开发
## 任务 (Tasks)
### 🔐 认证模块 (Auth Module) - P0优先级
- [x] 1.0 POST /auth/register - 用户注册接口
- [x] 1.1 创建auth.schema.ts - 定义用户注册Schema
- [x] 1.2 创建auth.response.ts - 定义注册响应格式
- [x] 1.3 创建auth.service.ts - 实现注册业务逻辑
- [x] 1.4 创建auth.controller.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.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.md - 编写登录测试用例文档
- [x] 4.0 POST /auth/refresh - Token刷新接口
- [x] 4.1 扩展auth.schema.ts - 定义刷新Schema
- [x] 4.2 扩展auth.response.ts - 定义刷新响应格式
- [x] 4.3 扩展auth.service.ts - 实现刷新业务逻辑
- [x] 4.4 扩展auth.controller.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.md - 编写退出测试用例文档~~
- [x] 6.0 POST /auth/password/reset-request - 找回密码接口
- [x] 6.1 扩展auth.schema.ts - 定义找回密码Schema
- [x] 6.2 扩展auth.response.ts - 定义找回密码响应格式
- [x] 6.3 扩展auth.service.ts - 实现找回密码业务逻辑
- [x] 6.4 扩展auth.controller.ts - 实现找回密码路由
- [x] 6.5 扩展auth.test.md - 编写找回密码测试用例文档
- [x] 7.0 POST /auth/password/reset-confirm - 重置密码接口
- [x] 7.1 扩展auth.schema.ts - 定义重置密码Schema
- [x] 7.2 扩展auth.response.ts - 定义重置密码响应格式
- [x] 7.3 扩展auth.service.ts - 实现重置密码业务逻辑
- [x] 7.4 扩展auth.controller.ts - 实现重置密码路由
- [x] 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.md - 编写验证码测试用例文档
- [x] 9.0 检查认证模块 (Auth Module)那些接口需要加分布式锁,并加锁
### 👤 用户管理模块 (User Module) - P0优先级
- [x] 9.0 GET /users/me - 获取当前用户信息接口
- [x] Before 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [x] 9.1 扩展user.schema.ts - 定义当前用户Schema
- [x] 9.2 扩展user.response.ts - 定义当前用户响应格式
- [x] 9.3 扩展user.service.ts - 实现当前用户业务逻辑
- [x] 9.4 更新user.controller.ts - 实现当前用户路由
- [x] 9.5 创建user.test.md - 编写当前用户测试用例文档
- [x] 10.0 GET /users - 用户列表查询接口
- [x] 10.1 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [x] 10.2 扩展user.schema.ts - 定义用户列表Schema
- [x] 10.3 扩展user.response.ts - 定义用户列表响应格式
- [x] 10.4 扩展user.service.ts - 实现用户列表业务逻辑
- [x] 10.5 扩展user.controller.ts - 实现用户列表路由
- [x] 10.6 扩展user.test.md - 编写用户列表测试用例文档
- [ ] 11.0 POST /users - 创建用户接口
- [x] 11.1 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 11.2 扩展user.schema.ts - 定义创建用户Schema
- [ ] 11.3 扩展user.response.ts - 定义创建用户响应格式
- [ ] 11.4 扩展user.service.ts - 根据当前单个接口doc.md实现创建用户业务逻辑
- [ ] 11.5 扩展user.controller.ts - 实现创建用户路由
- [ ] 11.6 扩展user.test.md - 编写创建用户测试用例文档
- [ ] 12.0 PUT /users/{id} - 更新用户信息接口
- [ ] 12.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 12.1 扩展user.schema.ts - 定义更新用户Schema
- [ ] 12.2 扩展user.response.ts - 定义更新用户响应格式
- [ ] 12.3 扩展user.service.ts - 根据当前单个接口doc.md实现更新用户业务逻辑
- [ ] 12.4 扩展user.controller.ts - 实现更新用户路由
- [ ] 12.5 扩展user.test.md - 编写更新用户测试用例文档
- [ ] 13.0 DELETE /users/{id} - 删除用户接口
- [ ] 13.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 13.1 扩展user.schema.ts - 定义删除用户Schema
- [ ] 13.2 扩展user.response.ts - 定义删除用户响应格式
- [ ] 13.3 扩展user.service.ts - 根据当前单个接口doc.md实现删除用户业务逻辑
- [ ] 13.4 扩展user.controller.ts - 实现删除用户路由
- [ ] 13.5 扩展user.test.md - 编写删除用户测试用例文档
- [ ] 14.0 PUT /users/me/password - 修改密码接口
- [ ] 14.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 14.1 扩展user.schema.ts - 定义修改密码Schema
- [ ] 14.2 扩展user.response.ts - 定义修改密码响应格式
- [ ] 14.3 扩展user.service.ts - 根据当前单个接口doc.md实现修改密码业务逻辑
- [ ] 14.4 扩展user.controller.ts - 实现修改密码路由
- [ ] 14.5 扩展user.test.md - 编写修改密码测试用例文档
- [ ] 15.0 GET /users/{id} - 用户详情接口
- [ ] 15.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 15.1 扩展user.schema.ts - 定义用户详情Schema
- [ ] 15.2 扩展user.response.ts - 定义用户详情响应格式
- [ ] 15.3 扩展user.service.ts - 根据当前单个接口doc.md实现用户详情业务逻辑
- [ ] 15.4 扩展user.controller.ts - 实现用户详情路由
- [ ] 15.5 扩展user.test.md - 编写用户详情测试用例文档
- [ ] 16.0 POST /users/batch - 批量操作接口
- [ ] 16.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 16.1 扩展user.schema.ts - 定义批量操作Schema
- [ ] 16.2 扩展user.response.ts - 定义批量操作响应格式
- [ ] 16.3 扩展user.service.ts - 根据当前单个接口doc.md实现批量操作业务逻辑
- [ ] 16.4 扩展user.controller.ts - 实现批量操作路由
- [ ] 16.5 扩展user.test.md - 编写批量操作测试用例文档
### 🎭 角色权限模块 (Role Module) - P0优先级
- [ ] 17.0 GET /roles - 角色列表接口
- [ ] 17.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 17.1 创建role.schema.ts - 定义角色Schema
- [ ] 17.2 创建role.response.ts - 定义角色响应格式
- [ ] 17.3 创建role.service.ts - 根据当前单个接口doc.md实现角色业务逻辑
- [ ] 17.4 创建role.controller.ts - 实现角色路由
- [ ] 17.5 创建role.test.md - 编写角色测试用例文档
- [ ] 18.0 POST /roles - 创建角色接口
- [ ] 18.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 18.1 扩展role.schema.ts - 定义创建角色Schema
- [ ] 18.2 扩展role.response.ts - 定义创建角色响应格式
- [ ] 18.3 扩展role.service.ts - 根据当前单个接口doc.md实现创建角色业务逻辑
- [ ] 18.4 扩展role.controller.ts - 实现创建角色路由
- [ ] 18.5 扩展role.test.md - 编写创建角色测试用例文档
- [ ] 19.0 PUT /roles/{id} - 更新角色接口
- [ ] 19.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 19.1 扩展role.schema.ts - 定义更新角色Schema
- [ ] 19.2 扩展role.response.ts - 定义更新角色响应格式
- [ ] 19.3 扩展role.service.ts - 根据当前单个接口doc.md实现更新角色业务逻辑
- [ ] 19.4 扩展role.controller.ts - 实现更新角色路由
- [ ] 19.5 扩展role.test.md - 编写更新角色测试用例文档
- [ ] 20.0 DELETE /roles/{id} - 删除角色接口
- [ ] 20.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 20.1 扩展role.schema.ts - 定义删除角色Schema
- [ ] 20.2 扩展role.response.ts - 定义删除角色响应格式
- [ ] 20.3 扩展role.service.ts - 根据当前单个接口doc.md实现删除角色业务逻辑
- [ ] 20.4 扩展role.controller.ts - 实现删除角色路由
- [ ] 20.5 扩展role.test.md - 编写删除角色测试用例文档
- [ ] 21.0 GET /permissions - 权限列表接口
- [ ] 21.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 21.1 创建permission.schema.ts - 定义权限Schema
- [ ] 21.2 创建permission.response.ts - 定义权限响应格式
- [ ] 21.3 创建permission.service.ts - 根据当前单个接口doc.md实现权限业务逻辑
- [ ] 21.4 创建permission.controller.ts - 实现权限路由
- [ ] 21.5 创建permission.test.md - 编写权限测试用例文档
- [ ] 22.0 POST /roles/{id}/permissions - 权限分配接口
- [ ] 22.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 22.1 扩展role.schema.ts - 定义权限分配Schema
- [ ] 22.2 扩展role.response.ts - 定义权限分配响应格式
- [ ] 22.3 扩展role.service.ts - 根据当前单个接口doc.md实现权限分配业务逻辑
- [ ] 22.4 扩展role.controller.ts - 实现权限分配路由
- [ ] 22.5 扩展role.test.md - 编写权限分配测试用例文档
- [ ] 23.0 POST /users/{id}/roles - 用户角色分配接口
- [ ] 23.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 23.1 扩展user.schema.ts - 定义用户角色分配Schema
- [ ] 23.2 扩展user.response.ts - 定义用户角色分配响应格式
- [ ] 23.3 扩展user.service.ts - 根据当前单个接口doc.md实现用户角色分配业务逻辑
- [ ] 23.4 扩展user.controller.ts - 实现用户角色分配路由
- [ ] 23.5 扩展user.test.md - 编写用户角色分配测试用例文档
### 🏢 组织架构模块 (Organization Module) - P1优先级
- [ ] 24.0 GET /organizations - 组织列表接口
- [ ] 24.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 24.1 创建organization.schema.ts - 定义组织Schema
- [ ] 24.2 创建organization.response.ts - 定义组织响应格式
- [ ] 24.3 创建organization.service.ts - 根据当前单个接口doc.md实现组织业务逻辑
- [ ] 24.4 创建organization.controller.ts - 实现组织路由
- [ ] 24.5 创建organization.test.md - 编写组织测试用例文档
- [ ] 25.0 POST /organizations - 创建组织接口
- [ ] 25.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 25.1 扩展organization.schema.ts - 定义创建组织Schema
- [ ] 25.2 扩展organization.response.ts - 定义创建组织响应格式
- [ ] 25.3 扩展organization.service.ts - 根据当前单个接口doc.md实现创建组织业务逻辑
- [ ] 25.4 扩展organization.controller.ts - 实现创建组织路由
- [ ] 25.5 扩展organization.test.md - 编写创建组织测试用例文档
- [ ] 26.0 PUT /organizations/{id} - 更新组织接口
- [ ] 26.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 26.1 扩展organization.schema.ts - 定义更新组织Schema
- [ ] 26.2 扩展organization.response.ts - 定义更新组织响应格式
- [ ] 26.3 扩展organization.service.ts - 根据当前单个接口doc.md实现更新组织业务逻辑
- [ ] 26.4 扩展organization.controller.ts - 实现更新组织路由
- [ ] 26.5 扩展organization.test.md - 编写更新组织测试用例文档
- [ ] 27.0 DELETE /organizations/{id} - 删除组织接口
- [ ] 27.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 27.1 扩展organization.schema.ts - 定义删除组织Schema
- [ ] 27.2 扩展organization.response.ts - 定义删除组织响应格式
- [ ] 27.3 扩展organization.service.ts - 根据当前单个接口doc.md实现删除组织业务逻辑
- [ ] 27.4 扩展organization.controller.ts - 实现删除组织路由
- [ ] 27.5 扩展organization.test.md - 编写删除组织测试用例文档
- [ ] 28.0 POST /users/{id}/organizations - 用户组织关系接口
- [ ] 28.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 28.1 扩展user.schema.ts - 定义用户组织关系Schema
- [ ] 28.2 扩展user.response.ts - 定义用户组织关系响应格式
- [ ] 28.3 扩展user.service.ts - 根据当前单个接口doc.md实现用户组织关系业务逻辑
- [ ] 28.4 扩展user.controller.ts - 实现用户组织关系路由
- [ ] 28.5 扩展user.test.md - 编写用户组织关系测试用例文档
### 🗂️ 系统基础模块 (System Module) - P1优先级
- [ ] 29.0 字典类型管理 - CRUD /dict-types
- [ ] 29.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 29.1 创建dict.schema.ts - 定义字典类型Schema
- [ ] 29.2 创建dict.response.ts - 定义字典类型响应格式
- [ ] 29.3 创建dict.service.ts - 根据当前单个接口doc.md实现字典类型业务逻辑
- [ ] 29.4 创建dict.controller.ts - 实现字典类型路由
- [ ] 29.5 创建dict.test.md - 编写字典类型测试用例文档
- [ ] 30.0 字典项管理 - CRUD /dict-items
- [ ] 30.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 30.1 扩展dict.schema.ts - 定义字典项Schema
- [ ] 30.2 扩展dict.response.ts - 定义字典项响应格式
- [ ] 30.3 扩展dict.service.ts - 根据当前单个接口doc.md实现字典项业务逻辑
- [ ] 30.4 扩展dict.controller.ts - 实现字典项路由
- [ ] 30.5 扩展dict.test.md - 编写字典项测试用例文档
- [ ] 31.0 标签管理 - CRUD /tags
- [ ] 31.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 31.1 创建tag.schema.ts - 定义标签Schema
- [ ] 31.2 创建tag.response.ts - 定义标签响应格式
- [ ] 31.3 创建tag.service.ts - 根据当前单个接口doc.md实现标签业务逻辑
- [ ] 31.4 创建tag.controller.ts - 实现标签路由
- [ ] 31.5 创建tag.test.md - 编写标签测试用例文档
- [ ] 32.0 操作日志 - GET /logs/operations
- [ ] 32.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 32.1 创建log.schema.ts - 定义操作日志Schema
- [ ] 32.2 创建log.response.ts - 定义操作日志响应格式
- [ ] 32.3 创建log.service.ts - 根据当前单个接口doc.md实现操作日志业务逻辑
- [ ] 32.4 创建log.controller.ts - 实现操作日志路由
- [ ] 32.5 创建log.test.md - 编写操作日志测试用例文档
- [ ] 33.0 登录日志 - GET /logs/logins
- [ ] 33.0 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 33.1 扩展log.schema.ts - 定义登录日志Schema
- [ ] 33.2 扩展log.response.ts - 定义登录日志响应格式
- [ ] 33.3 扩展log.service.ts - 根据当前单个接口doc.md实现登录日志业务逻辑
- [ ] 33.4 扩展log.controller.ts - 实现登录日志路由
- [ ] 33.5 扩展log.test.md - 编写登录日志测试用例文档
### 🔧 基础设施完善
- [ ] 34.0 JWT认证中间件
- [ ] Before 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 34.1 创建JWT认证插件
- [ ] 34.2 实现Token黑名单管理
- [ ] 34.3 实现RefreshToken机制
- [ ] 34.4 集成权限验证中间件
- [ ] 34.5 编写认证中间件测试
- [ ] 35.0 路由模块集成
- [ ] Before 整理当前接口业务逻辑写入当前单个接口doc.md后续步骤按照此逻辑进行
- [ ] 35.1 更新src/modules/index.ts - 集成所有模块
- [ ] 35.2 更新src/app.ts - 注册所有路由
- [ ] 35.3 更新Swagger标签定义
- [ ] 35.4 完善API文档
- [ ] 35.5 集成测试验证
## 开发优先级说明
### 第一阶段P0基础认证和用户管理
- **认证模块**用户注册、激活、登录、刷新、退出任务1-5
- **用户管理模块**当前用户、用户列表、用户CRUD、密码管理任务9-14
- **完成目标**:具备基本的用户认证和管理功能
### 第二阶段P0角色权限系统
- **角色管理**角色CRUD、权限分配任务17-20
- **权限管理**权限列表、权限分配、用户角色分配任务21-23
- **完成目标**具备完整的RBAC权限控制体系
### 第三阶段P1扩展功能
- **密码管理**找回密码、重置密码任务6-7
- **验证码系统**图形验证码任务8
- **用户扩展**用户详情、批量操作任务15-16
- **组织架构**组织管理、用户组织关系任务24-28
### 第四阶段P1-P2系统完善
- **系统基础**字典、标签、日志管理任务29-33
- **基础设施**JWT中间件、路由集成任务34-35
- **完成目标**:系统功能完整,可投入生产使用
## 备注说明
1. **已完成部分**用户模块的Schema、Response、Service已基本完成可直接使用
2. **验证码集成**现有captcha模块可直接集成到认证流程中
3. **开发规范**严格按照Elysia开发规范每个接口都要有完整的5个子任务
4. **测试要求**:每个模块都要有完整的测试用例文档,确保功能正确性
5. **优先级管理**按照P0 > P1 > P2的顺序开发确保核心功能优先完成

View File

@ -0,0 +1,196 @@
# 字典模块开发计划
## 重新设计的字典表结构
**表名**: `sys_dict`
**字段设计**:
```sql
CREATE TABLE `sys_dict` (
`id` BIGINT NOT NULL COMMENT '主键ID',
`code` VARCHAR(50) NOT NULL COMMENT '字典代码,唯一标识',
`name` VARCHAR(100) NOT NULL COMMENT '字典名称',
`value` VARCHAR(200) NULL COMMENT '字典值(叶子节点才有值)',
`description` VARCHAR(500) NULL COMMENT '字典描述',
`icon` VARCHAR(100) NULL COMMENT '图标CSS类名或图标路径',
`pid` BIGINT NULL DEFAULT 0 COMMENT '父级ID0表示顶级',
`level` INT NOT NULL DEFAULT 1 COMMENT '层级深度1为顶级',
`sort_order` INT NOT NULL DEFAULT 0 COMMENT '排序号',
`status` VARCHAR(20) NOT NULL DEFAULT 'active' COMMENT '状态active-启用inactive-禁用',
`is_system` BOOLEAN NOT NULL DEFAULT FALSE COMMENT '是否系统字典',
`color` VARCHAR(20) NULL COMMENT '颜色标识',
`extra` JSON NULL COMMENT '扩展字段',
`created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updated_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uk_code` (`code`),
KEY `idx_pid` (`pid`),
KEY `idx_level` (`level`),
KEY `idx_status` (`status`),
KEY `idx_sort` (`sort_order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='系统字典表';
```
## 字典管理模块接口清单
1. 创建字典项
- 默认pid为0
- 字典项不允许同名
- 等级深度不能超过10
- 默认为系统字典
2. 获取字典项内容
- 根据code或id查找字典项
3. 获取完整字典树
- 获取完整的字典树
- 可根据status、is_system等条件过滤
4. 获取指定字典树
- 通过code或id或pid查找字典树
- 可根据status、is_system等条件过滤
5. 更新字典项内容
- 通过id修改字典内容可选参数修改不是传递全部参数至少包括一个参数
6. 字典项排序
- 拖动排序
7. 删除字典项
- 软删除,防止依赖找不到
## 缓存机制
- 提供方法将整个字典写入redis缓存后续接口查询先从缓存找
## 相关文件 (Relevant Files)
- `src/eneities/sysDict.ts` - 字典表实体定义
- `src/modules/dict/dict.docs.md` - 字典模块业务逻辑文档
- `src/modules/dict/dict.schema.ts` - 字典模块Schema定义
- `src/modules/dict/dict.response.ts` - 字典模块响应格式定义
- `src/modules/dict/dict.service.ts` - 字典模块业务逻辑
- `src/modules/dict/dict.controller.ts` - 字典模块路由控制器
- `src/modules/dict/dict.test.md` - 字典模块测试用例文档
- `src/modules/dict/dict.test.ts` - 字典模块单元测试
- `src/constants/swaggerTags.ts` - 更新Swagger标签定义
### 备注 (Notes)
- 单元测试通常应放置在与它们测试的代码文件相同的目录中
- 字典模块需要支持树形结构的CRUD操作
- 需要实现Redis缓存机制提高查询性能
- 需要处理软删除逻辑,避免数据依赖问题
## 开发计划
### 阶段1数据库实体和基础架构
- [x] 1.0 创建字典表实体
- [x] 1.1 ~~创建 `src/eneities/sysDict.ts` 文件,定义字典表实体结构~~
- [x] 1.2 更新 `src/eneities/index.ts` 导出字典实体
- [x] 1.3 创建数据库迁移文件,执行字典表创建
### 阶段2字典模块核心接口开发
- [ ] 2.0 创建字典项接口 (POST /api/dict)
- [ ] 2.1 生成接口业务逻辑文档,写入 `dict.docs.md`
- [ ] 2.2 创建 `dict.schema.ts` - 定义创建字典项Schema
- [ ] 2.3 创建 `dict.response.ts` - 定义创建字典项响应格式
- [ ] 2.4 创建 `dict.service.ts` - 实现创建字典项业务逻辑
- [ ] 2.5 创建 `dict.controller.ts` - 实现创建字典项路由
- [ ] 2.6 创建 `dict.test.md` - 编写创建字典项测试用例
- [ ] 3.0 获取字典项内容接口 (GET /api/dict/:id)
- [ ] 3.1 更新 `dict.docs.md` - 添加获取字典项业务逻辑
- [ ] 3.2 扩展 `dict.schema.ts` - 定义获取字典项Schema
- [ ] 3.3 扩展 `dict.response.ts` - 定义获取字典项响应格式
- [ ] 3.4 扩展 `dict.service.ts` - 实现获取字典项业务逻辑
- [ ] 3.5 扩展 `dict.controller.ts` - 实现获取字典项路由
- [ ] 3.6 更新 `dict.test.md` - 添加获取字典项测试用例
- [ ] 4.0 获取完整字典树接口 (GET /api/dict/tree)
- [ ] 4.1 更新 `dict.docs.md` - 添加获取完整字典树业务逻辑
- [ ] 4.2 扩展 `dict.schema.ts` - 定义获取字典树查询Schema
- [ ] 4.3 扩展 `dict.response.ts` - 定义字典树响应格式
- [ ] 4.4 扩展 `dict.service.ts` - 实现获取完整字典树业务逻辑
- [ ] 4.5 扩展 `dict.controller.ts` - 实现获取完整字典树路由
- [ ] 4.6 更新 `dict.test.md` - 添加获取完整字典树测试用例
- [ ] 5.0 获取指定字典树接口 (GET /api/dict/tree/:code)
- [ ] 5.1 更新 `dict.docs.md` - 添加获取指定字典树业务逻辑
- [ ] 5.2 扩展 `dict.schema.ts` - 定义获取指定字典树Schema
- [ ] 5.3 扩展 `dict.response.ts` - 定义指定字典树响应格式
- [ ] 5.4 扩展 `dict.service.ts` - 实现获取指定字典树业务逻辑
- [ ] 5.5 扩展 `dict.controller.ts` - 实现获取指定字典树路由
- [ ] 5.6 更新 `dict.test.md` - 添加获取指定字典树测试用例
### 阶段3字典管理接口开发
- [ ] 6.0 更新字典项内容接口 (PUT /api/dict/:id)
- [ ] 6.1 更新 `dict.docs.md` - 添加更新字典项业务逻辑
- [ ] 6.2 扩展 `dict.schema.ts` - 定义更新字典项Schema
- [ ] 6.3 扩展 `dict.response.ts` - 定义更新字典项响应格式
- [ ] 6.4 扩展 `dict.service.ts` - 实现更新字典项业务逻辑
- [ ] 6.5 扩展 `dict.controller.ts` - 实现更新字典项路由
- [ ] 6.6 更新 `dict.test.md` - 添加更新字典项测试用例
- [ ] 7.0 字典项排序接口 (PUT /api/dict/sort)
- [ ] 7.1 更新 `dict.docs.md` - 添加字典项排序业务逻辑
- [ ] 7.2 扩展 `dict.schema.ts` - 定义字典项排序Schema
- [ ] 7.3 扩展 `dict.response.ts` - 定义字典项排序响应格式
- [ ] 7.4 扩展 `dict.service.ts` - 实现字典项排序业务逻辑
- [ ] 7.5 扩展 `dict.controller.ts` - 实现字典项排序路由
- [ ] 7.6 更新 `dict.test.md` - 添加字典项排序测试用例
- [ ] 8.0 删除字典项接口 (DELETE /api/dict/:id)
- [ ] 8.1 更新 `dict.docs.md` - 添加删除字典项业务逻辑(软删除)
- [ ] 8.2 扩展 `dict.schema.ts` - 定义删除字典项Schema
- [ ] 8.3 扩展 `dict.response.ts` - 定义删除字典项响应格式
- [ ] 8.4 扩展 `dict.service.ts` - 实现删除字典项业务逻辑
- [ ] 8.5 扩展 `dict.controller.ts` - 实现删除字典项路由
- [ ] 8.6 更新 `dict.test.md` - 添加删除字典项测试用例
### 阶段4缓存机制和优化
- [ ] 9.0 Redis缓存机制实现
- [ ] 9.1 更新 `dict.docs.md` - 添加缓存机制说明
- [ ] 9.2 扩展 `dict.service.ts` - 实现Redis缓存写入方法
- [ ] 9.3 扩展 `dict.service.ts` - 实现Redis缓存读取方法
- [ ] 9.4 扩展 `dict.service.ts` - 实现缓存失效机制
- [ ] 9.5 更新所有查询接口,优先从缓存读取
- [ ] 9.6 更新 `dict.test.md` - 添加缓存机制测试用例
### 阶段5集成和测试
- [ ] 10.0 模块集成和配置
- [ ] 10.1 更新 `src/modules/index.ts` - 导出字典模块
- [ ] 10.2 更新 `src/constants/swaggerTags.ts` - 添加字典模块标签
- [ ] 10.3 更新主应用文件,注册字典模块路由
- [ ] 10.4 创建 `dict.test.ts` - 实现单元测试
- [ ] 10.5 进行端到端测试验证
### 阶段6文档和部署
- [ ] 11.0 文档完善和部署准备
- [ ] 11.1 完善API文档确保Swagger正确显示
- [ ] 11.2 创建字典模块使用说明文档
- [ ] 11.3 进行性能测试和优化
- [ ] 11.4 准备部署脚本和配置
- [ ] 11.5 最终测试和验证
## 注意事项
- **每个接口的子任务执行完成后需要停下来等待用户确认进行下一步输入才能进入下一步有可能需要对AI生成的内容作出修改**
- 所有接口都需要遵循项目的编码规范和错误处理机制
- 字典模块需要支持树形结构的递归查询和操作
- 缓存机制需要考虑数据一致性和失效策略
- 软删除机制需要确保不影响现有业务逻辑

View File

@ -1,9 +1,7 @@
{
"compilerOptions": {
// Environment setup & latest features
"lib": [
"ESNext"
],
"lib": ["ESNext"],
"target": "ESNext",
"module": "ESNext",
"moduleDetection": "force",
@ -31,22 +29,12 @@
"outDir": "dist",
"rootDir": "src",
"paths": {
"@/*": [
"src/*"
],
"@package.json": [
"package.json"
]
"@/*": ["src/*"],
"@package.json": ["package.json"]
},
"resolveJsonModule": true,
"allowSyntheticDefaultImports": true
},
"include": [
"src",
"types/**/*.d.ts"
, "drizzle.config.ts" ],
"exclude": [
"node_modules",
"dist"
]
"include": ["src", "types/**/*.d.ts", "drizzle.config.ts"],
"exclude": ["node_modules", "dist"]
}