@thinkbun/middleware 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @thinkbun/middleware
 
+## 1.0.4
+
+### Patch Changes
+
+- docs
+- Updated dependencies
+  - @thinkbun/core@1.0.7
+
+## 1.0.3
+
+### Patch Changes
+
+- feat(core): 增强 CLI 应用和核心框架功能
+- Updated dependencies
+  - @thinkbun/core@1.0.6
+
 ## 1.0.2
 
 ### Patch Changes

package/README.md

@@ -78,81 +78,7 @@ app.use(logger({
 | `logger`      | `(message: string) => void` | `console.log` | Custom logger function                 |
 | `ignorePaths` | `string[]`                  | `[]`          | Array of paths to exclude from logging |
 
-### 3. Validator
-
-Request parameter validation middleware that validates request body, query parameters, and route parameters using Ajv schema validation.
-
-#### Usage
-
-```typescript
-import { validator } from '@thinkbun/middleware';
-
-app.use(validator({
-  rules: [
-    {
-      path: '/api/users',
-      method: 'POST',
-      schema: {
-        body: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            email: { type: 'string', format: 'email' },
-            age: { type: 'number', minimum: 18 }
-          },
-          required: ['name', 'email']
-        },
-        query: {
-          type: 'object',
-          properties: {
-            active: { type: 'boolean' }
-          }
-        }
-      }
-    },
-    {
-      path: '/api/users/:id',
-      method: 'GET',
-      schema: {
-        params: {
-          type: 'object',
-          properties: {
-            id: { type: 'string', pattern: '^\\d+$' }
-          },
-          required: ['id']
-        }
-      }
-    }
-  ],
-  errorHandler: (errors, ctx) => {
-    // Custom validation error handling
-    ctx.throw(400, `Validation error: ${errors[0].message}`);
-  }
-}));
-```
-
-#### Options
-
-| Option         | Type                                    | Default | Description                               |
-| -------------- | --------------------------------------- | ------- | ----------------------------------------- |
-| `rules`        | `ValidationRule[]`                      | -       | Array of validation rules                 |
-| `errorHandler` | `(errors: any[], ctx: Context) => void` | -       | Custom validation error handling function |
-
-#### ValidationRule Interface
-
-```typescript
-interface ValidationRule {
-  path: string;           // Request path pattern to match
-  method: string;         // HTTP method to match (GET, POST, etc.)
-  schema: {
-    body?: any;          // Request body schema
-    query?: any;         // Query parameters schema
-    params?: any;        // Route parameters schema
-  };
-}
-```
-
-### 4. CORS
+### 3. CORS
 
 CORS configuration middleware that handles Cross-Origin Resource Sharing, supporting flexible configuration options.
 
@@ -188,9 +114,9 @@ app.use(cors({
 | `maxAge`            | `number`                                              | `86400` (24 hours)                                  | Preflight request cache time (seconds)                                     |
 | `preflightContinue` | `boolean`                                             | `true`                                              | Whether to continue processing preflight requests                          |
 
-### 5. Static Serve
+### 4. Static Serve
 
-Static file serving middleware that serves static files from the specified directory, with support for request path prefixes, cache control, and more.
+Static file serving middleware that serves static files from specified directory, with support for request path prefixes, cache control, and more.
 
 #### Usage
 
@@ -215,10 +141,10 @@ app.use(staticServe({
 #### Options
 
 | Option         | Type      | Default        | Description                      |
-| -------------- | --------- | -------------- | -------------------------------- |
-| `root`         | `string`  | -              | Static file directory (required) |
-| `prefix`       | `string`  | `''`           | Request path prefix              |
-| `index`        | `string`  | `'index.html'` | Default index file               |
+| -------------- | --------- | -------------- | ------------------------- |
+| `root`        | `string`  | -              | Static file directory (required) |
+| `prefix`      | `string`  | `''`           | Request path prefix              |
+| `index`       | `string`  | `'index.html'` | Default index file               |
 | `maxAge`       | `number`  | `3600`         | Cache control max-age (seconds)  |
 | `gzip`         | `boolean` | `true`         | Enable gzip compression          |
 | `brotli`       | `boolean` | `true`         | Enable Brotli compression        |
@@ -240,7 +166,7 @@ app.use(middlewares.staticServe({ root: './public' }));
 
 ## Middleware Execution Flow
 
-The middleware follows the Koa onion model, where each middleware can execute code before and after subsequent middleware:
+The middleware follows Koa onion model, where each middleware can execute code before and after subsequent middleware:
 
 ```typescript
 app.use(async (ctx, next) => {
@@ -275,11 +201,11 @@ app.use(async (ctx, next) => {
 
 ## Best Practices
 
-1. **Order Matters**: Middleware execution follows the order in which they are added with `app.use()`. Place global middleware (like error handler, logger, CORS) before route-specific middleware.
+1. **Order Matters**: Middleware execution follows order in which they are added with `app.use()`. Place global middleware (like error handler, logger, CORS) before route-specific middleware.
 
 2. **Error Handler Placement**: Always place the error handler middleware first to ensure it can capture errors from all subsequent middleware.
 
-3. **Static Files**: Place the static file serving middleware before route handlers to improve performance (static files are served directly without going through route processing).
+3. **Static Files**: Place static file serving middleware before route handlers to improve performance (static files are served directly without going through route processing).
 
 4. **Validation Scope**: Use the validator middleware with specific paths and methods to avoid unnecessary validation overhead.
 

package/README_CN.md

@@ -0,0 +1,290 @@
+# ThinkBun 中间件集合
+
+为 ThinkBun 框架提供的全面中间件集合，遵循 Koa 中间件规范，支持 async/await 语法和洋葱模型执行流程。
+
+## 安装
+
+```bash
+bun add @thinkbun/middleware
+```
+
+## 可用中间件
+
+### 1. 错误处理器
+
+全局错误处理中间件，捕获并处理后续中间件抛出的错误，支持在开发和生产环境中显示不同的错误信息。
+
+#### 使用方法
+
+```typescript
+import { errorHandler } from '@thinkbun/middleware';
+
+// 基本使用
+app.use(errorHandler());
+
+// 使用自定义选项
+app.use(errorHandler({
+  exposeStackTrace: true, // 在错误响应中显示堆栈跟踪（仅建议在开发环境使用）
+  customHandler: (error, ctx) => {
+    // 自定义错误处理逻辑
+    return new Response(JSON.stringify({ error: error.message }), {
+      status: (error as any).status || 500,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  },
+  logger: (error) => {
+    // 自定义错误日志记录
+    console.error('Error occurred:', error);
+  }
+}));
+```
+
+#### 选项
+
+| 选项              | 类型                                       | 默认值  | 描述                                   |
+| ----------------- | ------------------------------------------ | ------- | -------------------------------------- |
+| `exposeStackTrace` | `boolean`                                  | `false` | 是否在错误响应中暴露堆栈跟踪         |
+| `customHandler`    | `(error: Error, ctx: Context) => Response` | -       | 自定义错误处理函数                      |
+| `logger`           | `(error: Error, ctx: Context) => void`     | -       | 自定义错误日志记录函数                  |
+
+### 2. 日志记录器
+
+请求日志记录中间件，记录请求和响应信息，支持自定义日志格式、路径过滤和日志记录器。
+
+#### 使用方法
+
+```typescript
+import { logger } from '@thinkbun/middleware';
+
+// 基本使用
+app.use(logger());
+
+// 使用自定义选项
+app.use(logger({
+  format: (ctx) => `${ctx.method} ${ctx.path} ${ctx.header('user-agent')}`,
+  logger: (message) => {
+    // 自定义日志记录
+    console.log('[LOG]', message);
+  },
+  ignorePaths: ['/health', '/metrics'] // 从日志中排除的路径
+}));
+```
+
+#### 选项
+
+| 选项         | 类型                        | 默认值       | 描述                      |
+| ------------ | --------------------------- | ------------- | ------------------------- |
+| `format`     | `(ctx: Context) => string`  | -             | 自定义日志格式函数         |
+| `logger`     | `(message: string) => void` | `console.log` | 自定义日志记录函数         |
+| `ignorePaths`| `string[]`                  | `[]`          | 从日志中排除的路径数组    |
+
+### 3. 验证器
+
+请求参数验证中间件，使用 Ajv 模式验证验证请求体、查询参数和路由参数。
+
+#### 使用方法
+
+```typescript
+import { validator } from '@thinkbun/middleware';
+
+app.use(validator({
+  rules: [
+    {
+      path: '/api/users',
+      method: 'POST',
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            email: { type: 'string', format: 'email' },
+            age: { type: 'number', minimum: 18 }
+          },
+          required: ['name', 'email']
+        },
+        query: {
+          type: 'object',
+          properties: {
+            active: { type: 'boolean' }
+          }
+        }
+      }
+    },
+    {
+      path: '/api/users/:id',
+      method: 'GET',
+      schema: {
+        params: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', pattern: '^\\d+$' }
+          },
+          required: ['id']
+        }
+      }
+    }
+  ],
+  errorHandler: (errors, ctx) => {
+    // 自定义验证错误处理
+    ctx.throw(400, `Validation error: ${errors[0].message}`);
+  }
+}));
+```
+
+#### 选项
+
+| 选项           | 类型                                    | 默认值 | 描述                               |
+| -------------- | --------------------------------------- | ------- | ----------------------------------- |
+| `rules`        | `ValidationRule[]`                      | -       | 验证规则数组                         |
+| `errorHandler` | `(errors: any[], ctx: Context) => void` | -       | 自定义验证错误处理函数                |
+
+#### ValidationRule 接口
+
+```typescript
+interface ValidationRule {
+  path: string;           // 要匹配的请求路径模式
+  method: string;         // 要匹配的 HTTP 方法（GET、POST 等）
+  schema: {
+    body?: any;          // 请求体模式
+    query?: any;         // 查询参数模式
+    params?: any;        // 路由参数模式
+  };
+}
+```
+
+### 4. CORS
+
+CORS 配置中间件，处理跨源资源共享，支持灵活的配置选项。
+
+#### 使用方法
+
+```typescript
+import { cors } from '@thinkbun/middleware';
+
+// 基本使用（默认允许所有源）
+app.use(cors());
+
+// 使用自定义选项
+app.use(cors({
+  origin: ['https://example.com', 'https://sub.example.com'], // 允许特定源
+  methods: ['GET', 'POST', 'PUT', 'DELETE'],                // 允许的 HTTP 方法
+  allowedHeaders: ['Content-Type', 'Authorization'],        // 允许的请求头
+  exposedHeaders: ['X-Custom-Header'],                      // 暴露给客户端的响应头
+  credentials: true,                                        // 允许凭据
+  maxAge: 86400,                                            // 预检请求缓存时间（秒）
+  preflightContinue: true                                  // 继续处理预检请求
+}));
+```
+
+#### 选项
+
+| 选项              | 类型                                                  | 默认值                                                 | 描述                                                                |
+| ----------------- | ----------------------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------- |
+| `origin`          | `string \| string[] \| ((origin: string) => boolean)` | `'*'`                                                   | 允许的源                                                          |
+| `methods`         | `string[]`                                            | `['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH']` | 允许的 HTTP 方法                                                     |
+| `allowedHeaders`  | `string[]`                                            | -                                                        | 允许的请求头（默认为 Access-Control-Request-Headers 的值）           |
+| `exposedHeaders`  | `string[]`                                            | -                                                        | 暴露给客户端的响应头                                              |
+| `credentials`     | `boolean`                                             | `false`                                                  | 是否允许凭据                                                       |
+| `maxAge`          | `number`                                              | `86400` (24 小时)                                        | 预检请求缓存时间（秒）                                               |
+| `preflightContinue` | `boolean`                                             | `true`                                                   | 是否继续处理预检请求                                              |
+
+### 5. 静态文件服务
+
+静态文件服务中间件，从指定目录服务静态文件，支持请求路径前缀、缓存控制等功能。
+
+#### 使用方法
+
+```typescript
+import { staticServe } from '@thinkbun/middleware';
+
+// 基本使用
+app.use(staticServe({ root: './public' }));
+
+// 使用自定义选项
+app.use(staticServe({
+  root: './public',        // 静态文件目录
+  prefix: '/static',       // 请求路径前缀（例如 /static/css/style.css）
+  index: 'index.html',     // 默认索引文件
+  maxAge: 3600,            // 缓存控制 max-age（秒）
+  gzip: true,              // 启用 gzip 压缩
+  brotli: true,            // 启用 Brotli 压缩
+  cacheControl: true       // 启用缓存控制头
+}));
+```
+
+#### 选项
+
+| 选项          | 类型      | 默认值        | 描述                      |
+| ------------- | --------- | -------------- | ------------------------- |
+| `root`        | `string`  | -              | 静态文件目录（必需）      |
+| `prefix`      | `string`  | `''`           | 请求路径前缀              |
+| `index`       | `string`  | `'index.html'` | 默认索引文件              |
+| `maxAge`      | `number`  | `3600`         | 缓存控制 max-age（秒）     |
+| `gzip`        | `boolean` | `true`         | 启用 gzip 压缩          |
+| `brotli`      | `boolean` | `true`         | 启用 Brotli 压缩        |
+| `cacheControl` | `boolean` | `true`         | 启用缓存控制头         |
+
+## 使用所有中间件
+
+您也可以一次性导入所有中间件：
+
+```typescript
+import { middlewares } from '@thinkbun/middleware';
+
+// 使用所有中间件
+app.use(middlewares.errorHandler());
+app.use(middlewares.logger());
+app.use(middlewares.cors());
+app.use(middlewares.staticServe({ root: './public' }));
+```
+
+## 中间件执行流程
+
+中间件遵循 Koa 洋葱模型，每个中间件可以在后续中间件之前和之后执行代码：
+
+```typescript
+app.use(async (ctx, next) => {
+  // 在下一个中间件之前执行的代码
+  console.log('中间件 1: 之前');
+
+  const response = await next();
+
+  // 在下一个中间件之后执行的代码
+  console.log('中间件 1: 之后');
+
+  return response;
+});
+
+app.use(async (ctx, next) => {
+  console.log('中间件 2: 之前');
+
+  const response = await next();
+
+  console.log('中间件 2: 之后');
+
+  return response;
+});
+
+// 处理请求时的输出：
+// 中间件 1: 之前
+// 中间件 2: 之前
+// (请求处理)
+// 中间件 2: 之后
+// 中间件 1: 之后
+```
+
+## 最佳实践
+
+1. **顺序很重要**：中间件执行遵循使用 `app.use()` 添加时的顺序。将全局中间件（如错误处理器、日志、CORS）放在特定于路由的中间件之前。
+
+2. **错误处理器位置**：始终将错误处理中间件放在第一位，以确保它可以捕获所有后续中间件的错误。
+
+3. **静态文件**：将静态文件服务中间件放在路由处理器之前，以提高性能（静态文件直接提供服务，无需经过路由处理）。
+
+4. **验证范围**：将验证器中间件与特定路径和方法一起使用，以避免不必要的验证开销。
+
+5. **环境特定配置**：为开发和生产环境配置不同的中间件（例如，仅在开发环境中暴露堆栈跟踪）。
+
+## 许可证
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinkbun/middleware",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "module": "src/index.ts",
   "type": "module",
   "devDependencies": {
@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "picocolors": "^1.1.1",
-    "@thinkbun/core": "1.0.4"
+    "@thinkbun/core": "1.0.6"
   },
   "publishConfig": {
     "access": "public"

package/src/middlewares/cors.ts

@@ -38,6 +38,18 @@ export interface CorsOptions {
   preflightContinue?: boolean;
 }
 
+/**
+ * CORS中间件函数
+ *
+ * 处理跨域资源共享，支持：
+ * - 自定义允许的源
+ * - 自定义HTTP方法
+ * - 预检请求处理
+ * - 凭证支持
+ *
+ * @param options CORS配置选项
+ * @returns 返回一个中间件函数
+ */
 export function cors(options: CorsOptions = {}): Middleware {
   const {
     origin = '*',
@@ -52,7 +64,12 @@ export function cors(options: CorsOptions = {}): Middleware {
   // 格式化methods为字符串
   const methodsStr = methods.join(', ').toUpperCase();
 
-  // 检查origin是否允许
+  /**
+   * 检查origin是否允许
+   * @private
+   * @param originHeader 请求头中的Origin值
+   * @returns 允许的origin字符串或false
+   */
   const checkOrigin = (originHeader: string | null): string | false => {
     if (!originHeader) return false;
 
@@ -75,6 +92,34 @@ export function cors(options: CorsOptions = {}): Middleware {
     return false;
   };
 
+  /**
+   * 设置CORS响应头
+   * @private
+   * @param headers Headers对象
+   * @param allowedOrigin 允许的origin
+   * @param isPreflight 是否为预检请求
+   */
+  const setCORSHeaders = (headers: Headers, allowedOrigin: string, isPreflight = false) => {
+    headers.set('Access-Control-Allow-Origin', allowedOrigin);
+
+    if (isPreflight) {
+      headers.set('Access-Control-Allow-Methods', methodsStr);
+      headers.set(
+        'Access-Control-Allow-Headers',
+        allowedHeaders?.join(', ') || headers.get('Access-Control-Request-Headers') || '',
+      );
+      headers.set('Access-Control-Max-Age', maxAge.toString());
+    }
+
+    if (credentials) {
+      headers.set('Access-Control-Allow-Credentials', 'true');
+    }
+
+    if (exposedHeaders && exposedHeaders.length > 0 && !isPreflight) {
+      headers.set('Access-Control-Expose-Headers', exposedHeaders.join(', '));
+    }
+  };
+
   return async (ctx: Context, next: () => Promise<Response | Context | void>): Promise<Response | Context | void> => {
     // 处理OPTIONS预检请求
     if (ctx.method === 'OPTIONS') {
@@ -87,16 +132,11 @@ export function cors(options: CorsOptions = {}): Middleware {
       }
 
       // 构建预检响应
-      const preflightResponse = new Response(null, { 
+      const preflightHeaders = new Headers();
+      setCORSHeaders(preflightHeaders, allowedOrigin, true);
+      const preflightResponse = new Response(null, {
         status: 204,
-        headers: {
-          'Access-Control-Allow-Origin': allowedOrigin,
-          'Access-Control-Allow-Methods': methodsStr,
-          'Access-Control-Allow-Headers':
-            allowedHeaders?.join(', ') || ctx.header('Access-Control-Request-Headers') || '',
-          'Access-Control-Max-Age': maxAge.toString(),
-          ...(credentials && { 'Access-Control-Allow-Credentials': 'true' }),
-        },
+        headers: preflightHeaders,
       });
 
       if (!preflightContinue) {
@@ -110,7 +150,7 @@ export function cors(options: CorsOptions = {}): Middleware {
       if (nextResponse instanceof Response) {
         const headers = new Headers(nextResponse.headers);
 
-        // 复制preflightResponse的所有头到新响应
+        // 复制预检响应的所有头到新响应
         preflightResponse.headers.forEach((value, name) => {
           headers.set(name, value);
         });
@@ -143,17 +183,9 @@ export function cors(options: CorsOptions = {}): Middleware {
     const response = await next();
 
     // 设置CORS响应头
-    const setCorsHeaders = (res: Response) => {
+    const setCORSHeadersOnResponse = (res: Response) => {
       const headers = new Headers(res.headers);
-      headers.set('Access-Control-Allow-Origin', allowedOrigin);
-
-      if (credentials) {
-        headers.set('Access-Control-Allow-Credentials', 'true');
-      }
-
-      if (exposedHeaders && exposedHeaders.length > 0) {
-        headers.set('Access-Control-Expose-Headers', exposedHeaders.join(', '));
-      }
+      setCORSHeaders(headers, allowedOrigin);
 
       return new Response(res.body, {
         status: res.status,
@@ -163,18 +195,10 @@ export function cors(options: CorsOptions = {}): Middleware {
     };
 
     if (response instanceof Response) {
-      return setCorsHeaders(response);
+      return setCORSHeadersOnResponse(response);
     } else {
       // 如果返回的是上下文对象或undefined，设置响应头
-      ctx.responseHeaders.set('Access-Control-Allow-Origin', allowedOrigin);
-
-      if (credentials) {
-        ctx.responseHeaders.set('Access-Control-Allow-Credentials', 'true');
-      }
-
-      if (exposedHeaders && exposedHeaders.length > 0) {
-        ctx.responseHeaders.set('Access-Control-Expose-Headers', exposedHeaders.join(', '));
-      }
+      setCORSHeaders(ctx.responseHeaders, allowedOrigin);
     }
 
     return response;

package/src/middlewares/errorHandler.ts

@@ -21,6 +21,51 @@ export interface ErrorHandlerOptions {
   logger?: (error: Error, ctx: Context) => void;
 }
 
+/**
+ * 错误类型映射表
+ */
+const ERROR_TYPE_MAP: Record<string, { status: number; defaultMessage: string }> = {
+  BadRequestError: { status: 400, defaultMessage: 'Bad Request' },
+  UnauthorizedError: { status: 401, defaultMessage: 'Unauthorized' },
+  ForbiddenError: { status: 403, defaultMessage: 'Forbidden' },
+  NotFoundError: { status: 404, defaultMessage: 'Not Found' },
+  MethodNotAllowedError: { status: 405, defaultMessage: 'Method Not Allowed' },
+  ConflictError: { status: 409, defaultMessage: 'Conflict' },
+  UnprocessableEntityError: { status: 422, defaultMessage: 'Unprocessable Entity' },
+};
+
+/**
+ * 根据错误类型获取状态码和消息
+ * @private
+ * @param error 错误对象
+ * @returns 包含状态码和消息的对象
+ */
+const getErrorInfo = (error: Error) => {
+  const errorType = ERROR_TYPE_MAP[error.name];
+  if (errorType) {
+    return {
+      status: errorType.status,
+      message: error.message || errorType.defaultMessage,
+    };
+  }
+  return {
+    status: 500,
+    message: 'Internal Server Error',
+  };
+};
+
+/**
+ * 错误处理中间件函数
+ *
+ * 捕获和处理应用中的错误，支持：
+ * - 自定义错误处理函数
+ * - 错误日志记录
+ * - 根据错误类型设置HTTP状态码
+ * - 生产环境下的错误信息隐藏
+ *
+ * @param options 错误处理配置选项
+ * @returns 返回一个中间件函数
+ */
 export function errorHandler(options: ErrorHandlerOptions = {}): Middleware {
   const { exposeStackTrace = process.env.NODE_ENV !== 'production', customHandler, logger = console.error } = options;
 
@@ -41,32 +86,7 @@ export function errorHandler(options: ErrorHandlerOptions = {}): Middleware {
 
       // 默认错误处理
       const err = error as Error;
-      let status = 500;
-      let message = 'Internal Server Error';
-
-      // 根据错误类型设置状态码
-      if (err.name === 'BadRequestError') {
-        status = 400;
-        message = err.message || 'Bad Request';
-      } else if (err.name === 'UnauthorizedError') {
-        status = 401;
-        message = err.message || 'Unauthorized';
-      } else if (err.name === 'ForbiddenError') {
-        status = 403;
-        message = err.message || 'Forbidden';
-      } else if (err.name === 'NotFoundError') {
-        status = 404;
-        message = err.message || 'Not Found';
-      } else if (err.name === 'MethodNotAllowedError') {
-        status = 405;
-        message = err.message || 'Method Not Allowed';
-      } else if (err.name === 'ConflictError') {
-        status = 409;
-        message = err.message || 'Conflict';
-      } else if (err.name === 'UnprocessableEntityError') {
-        status = 422;
-        message = err.message || 'Unprocessable Entity';
-      }
+      const { status, message } = getErrorInfo(err);
 
       // 构建错误响应
       const errorResponse = {

package/src/middlewares/logger.ts

@@ -29,6 +29,18 @@ export interface LoggerOptions {
   logResponseBody?: boolean;
 }
 
+/**
+ * 日志中间件函数
+ *
+ * 记录HTTP请求和响应信息，支持：
+ * - 文本和JSON两种日志格式
+ * - 自定义日志记录函数
+ * - 请求和响应体记录
+ * - 路径过滤
+ *
+ * @param options 日志配置选项
+ * @returns 返回一个中间件函数
+ */
 export function logger(options: LoggerOptions = {}): Middleware {
   const {
     format = 'text',
@@ -38,21 +50,39 @@ export function logger(options: LoggerOptions = {}): Middleware {
     logResponseBody = false,
   } = options;
 
-  return async (ctx: Context, next: () => Promise<Response | Context | void>): Promise<Response | Context | void> => {
-    // 检查是否需要忽略该路径的日志
-    if (ignorePaths.includes(ctx.path)) {
-      return await next();
+  /**
+   * 记录日志的通用方法
+   * @private
+   * @param message 日志消息
+   * @param data 日志数据对象
+   */
+  const writeLog = (message: string, data?: Record<string, any>) => {
+    if (format === 'json') {
+      logger(JSON.stringify(data || { message }));
+    } else {
+      logger(message);
     }
+  };
 
-    const startTime = Date.now();
-    const requestInfo: {
-      method: string;
-      path: string;
-      ip: string;
-      userAgent: string;
-      query: Record<string, string>;
-      body?: unknown;
-    } = {
+  /**
+   * 创建请求信息对象
+   * @private
+   * @param ctx 上下文对象
+   * @param includeBody 是否包含请求体
+   * @returns 请求信息对象
+   */
+  const createRequestInfo = async (
+    ctx: Context,
+    includeBody = false,
+  ): Promise<{
+    method: string;
+    path: string;
+    ip: string;
+    userAgent: string;
+    query: Record<string, string>;
+    body?: unknown;
+  }> => {
+    const requestInfo = {
       method: ctx.method,
       path: ctx.path,
       ip: ctx.ip?.address || 'unknown',
@@ -60,6 +90,28 @@ export function logger(options: LoggerOptions = {}): Middleware {
       query: Object.fromEntries(ctx.url.searchParams),
     };
 
+    // 记录请求体（如果需要）
+    if (includeBody && ctx.method !== 'GET') {
+      try {
+        const body = await ctx.body();
+        requestInfo.body = body;
+      } catch (_error) {
+        // 忽略读取请求体错误
+      }
+    }
+
+    return requestInfo;
+  };
+
+  return async (ctx: Context, next: () => Promise<Response | Context | void>): Promise<Response | Context | void> => {
+    // 检查是否需要忽略该路径的日志
+    if (ignorePaths.includes(ctx.path)) {
+      return await next();
+    }
+
+    const startTime = Date.now();
+    const requestInfo = await createRequestInfo(ctx, logRequestBody);
+
     // 记录请求体（如果需要）
     if (logRequestBody && ctx.method !== 'GET') {
       try {
@@ -85,13 +137,10 @@ export function logger(options: LoggerOptions = {}): Middleware {
         stack: (error as Error).stack,
       };
 
-      if (format === 'json') {
-        logger(JSON.stringify(errorInfo));
-      } else {
-        logger(
-          `[ERROR] ${requestInfo.method} ${requestInfo.path} ${500} ${endTime - startTime}ms - ${(error as Error).message}`,
-        );
-      }
+      writeLog(
+        `[ERROR] ${requestInfo.method} ${requestInfo.path} 500 ${endTime - startTime}ms - ${(error as Error).message}`,
+        errorInfo,
+      );
 
       throw error;
     } finally {
@@ -132,11 +181,10 @@ export function logger(options: LoggerOptions = {}): Middleware {
           }
         }
 
-        if (format === 'json') {
-          logger(JSON.stringify(responseInfo));
-        } else {
-          logger(`[INFO] ${requestInfo.method} ${requestInfo.path} ${response.status} ${endTime - startTime}ms`);
-        }
+        writeLog(
+          `[INFO] ${requestInfo.method} ${requestInfo.path} ${response.status} ${endTime - startTime}ms`,
+          responseInfo,
+        );
       }
     }
   };

package/src/test/middlewares.test.ts

@@ -1,14 +1,16 @@
 import { describe, expect, it } from 'bun:test';
-import { cors, errorHandler, logger, staticServe, validator } from '../index';
+
 import type { Context } from '@thinkbun/core';
 
+import { cors, errorHandler, logger, staticServe, validator } from '../index';
+
 // 创建模拟上下文
 function createMockContext(req: Request): Context {
   const mockApp: any = {
     server: {
-      requestIP: () => '127.0.0.1'
+      requestIP: () => '127.0.0.1',
     },
-    logger: console
+    logger: console,
   };
 
   const ctx: any = {
@@ -51,13 +53,17 @@ function createMockContext(req: Request): Context {
     clearCookie: () => ctx,
     body: async () => ({}),
     text: async () => '',
-    json: (data: any, options: any = {}) => new Response(JSON.stringify(data), {
-      status: options.status || ctx.status,
-      headers: new Headers([...ctx.responseHeaders.entries(), ...(options.headers ? Object.entries(options.headers) : [])])
-    }),
+    json: (data: any, options: any = {}) =>
+      new Response(JSON.stringify(data), {
+        status: options.status || ctx.status,
+        headers: new Headers([
+          ...ctx.responseHeaders.entries(),
+          ...(options.headers ? Object.entries(options.headers) : []),
+        ]),
+      }),
     ok: () => new Response(null, { status: 200, headers: ctx.responseHeaders }),
     success: (data: any) => ctx.json({ errno: 0, data }),
-    fail: (errno: number, msg: string) => ctx.json({ errno, msg })
+    fail: (errno: number, msg: string) => ctx.json({ errno, msg }),
   };
 
   return ctx;
@@ -69,89 +75,89 @@ describe('Middleware Tests', () => {
     it('should add CORS headers to response', async () => {
       const req = new Request('http://test:5300/', {
         headers: {
-          Origin: 'http://example.com'
-        }
+          Origin: 'http://example.com',
+        },
       });
       const ctx = createMockContext(req);
       const corsMiddleware = cors();
-      
+
       await corsMiddleware(ctx, async () => {});
-      
+
       expect(ctx.responseHeaders.get('Access-Control-Allow-Origin')).toBe('*'); // 默认配置下使用*
       expect(ctx.responseHeaders.get('Access-Control-Allow-Methods')).toBeNull(); // 非OPTIONS请求不会添加这个头
       expect(ctx.responseHeaders.get('Access-Control-Allow-Headers')).toBeNull(); // 非OPTIONS请求不会添加这个头
       expect(ctx.responseHeaders.get('Access-Control-Max-Age')).toBeNull(); // 非OPTIONS请求不会添加这个头
     });
-    
+
     it('should handle OPTIONS requests', async () => {
       const req = new Request('http://test:5300/', {
         method: 'OPTIONS',
         headers: {
           Origin: 'http://example.com',
           'Access-Control-Request-Methods': 'GET, POST',
-          'Access-Control-Request-Headers': 'Content-Type'
-        }
+          'Access-Control-Request-Headers': 'Content-Type',
+        },
       });
       const ctx = createMockContext(req);
       const corsMiddleware = cors();
-      
+
       const result = await corsMiddleware(ctx, async () => {});
-      
+
       expect(result).toBeDefined();
       expect((result as Response).status).toBe(204);
     });
   });
-  
+
   // 测试Logger中间件
   describe('Logger Middleware', () => {
     it('should log request and response information', async () => {
       const req = new Request('http://test:5300/');
       const ctx = createMockContext(req);
-      
+
       let logCalled = false;
       const loggerMiddleware = logger({
-        logger: () => logCalled = true
+        logger: () => (logCalled = true),
       });
-      
+
       await loggerMiddleware(ctx, async () => {
         return new Response('OK', { status: 200 });
       });
-      
+
       expect(logCalled).toBe(true);
     });
   });
-  
+
   // 测试ErrorHandler中间件
   describe('ErrorHandler Middleware', () => {
     it('should handle errors and return JSON response', async () => {
       const req = new Request('http://test:5300/');
       const ctx = createMockContext(req);
       const errorHandlerMiddleware = errorHandler();
-      
+
       const result = await errorHandlerMiddleware(ctx, async () => {
         throw new Error('Test error');
       });
-      
+
       expect(result).toBeDefined();
       const response = result as Response;
       expect(response.status).toBe(500);
       const responseData = await response.json();
       expect(responseData.error).toBe('Internal Server Error');
     });
-    
+
     it('should handle HTTP errors with specific status codes', async () => {
       const req = new Request('http://test:5300/');
       const ctx = createMockContext(req);
       const errorHandlerMiddleware = errorHandler();
-      
+
       // 使用与errorHandler中间件匹配的错误类型
       const notFoundError = new Error('Not Found');
       notFoundError.name = 'NotFoundError';
-      
+
       const result = await errorHandlerMiddleware(ctx, async () => {
         throw notFoundError;
       });
-      
+
       expect(result).toBeDefined();
       const response = result as Response;
       expect(response.status).toBe(404);
@@ -159,23 +165,23 @@ describe('Middleware Tests', () => {
       expect(responseData.error).toBe('Not Found');
     });
   });
-  
+
   // 测试Validator中间件
   describe('Validator Middleware', () => {
     it('should validate request body against schema', async () => {
       const req = new Request('http://test:5300/', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: 'test', age: 25 })
+        body: JSON.stringify({ name: 'test', age: 25 }),
       });
       const ctx = createMockContext(req);
-      
+
       // Mock the body method
       ctx.body = async () => ({ name: 'test', age: 25 });
-      
+
       // 设置params属性
       ctx.params = {};
-      
+
       const validatorMiddleware = validator({
         rules: [
           {
@@ -186,37 +192,37 @@ describe('Middleware Tests', () => {
                 type: 'object',
                 properties: {
                   name: { type: 'string' },
-                  age: { type: 'number' }
+                  age: { type: 'number' },
                 },
-                required: ['name', 'age']
-              }
-            }
-          }
-        ]
+                required: ['name', 'age'],
+              },
+            },
+          },
+        ],
       });
-      
+
       let nextCalled = false;
       await validatorMiddleware(ctx, async () => {
         nextCalled = true;
       });
-      
+
       expect(nextCalled).toBe(true);
     });
-    
+
     it('should throw error for invalid request body', async () => {
       const req = new Request('http://test:5300/', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: 'test' })
+        body: JSON.stringify({ name: 'test' }),
       });
       const ctx = createMockContext(req);
-      
+
       // Mock the body method
       ctx.body = async () => ({ name: 'test' });
-      
+
       // 设置params属性
       ctx.params = {};
-      
+
       const validatorMiddleware = validator({
         rules: [
           {
@@ -227,28 +233,28 @@ describe('Middleware Tests', () => {
                 type: 'object',
                 properties: {
                   name: { type: 'string' },
-                  age: { type: 'number' }
+                  age: { type: 'number' },
                 },
-                required: ['name', 'age']
-              }
-            }
-          }
-        ]
+                required: ['name', 'age'],
+              },
+            },
+          },
+        ],
       });
-      
+
       await expect(validatorMiddleware(ctx, async () => {})).rejects.toThrow();
     });
   });
-  
+
   // 测试StaticServe中间件
   describe('StaticServe Middleware', () => {
     it('should serve static files', async () => {
       const req = new Request('http://test:5300/test.txt');
       const ctx = createMockContext(req);
-      
+
       // 这个测试会实际查找文件，所以我们只测试中间件是否能正常执行
       const staticMiddleware = staticServe({ root: './public' });
-      
+
       let nextCalled = false;
       try {
         await staticMiddleware(ctx, async () => {
@@ -257,7 +263,7 @@ describe('Middleware Tests', () => {
       } catch (error) {
         // 忽略文件不存在的错误
       }
-      
+
       // 因为文件可能不存在，所以无论如何都应该调用next
       expect(nextCalled).toBe(true);
     });

package/tsconfig.json

@@ -1,7 +1,4 @@
 {
   "extends": "../../tsconfig.json",
-  "include": [
-    "src/**/*",
-    "package.json"
-  ]
+  "include": ["src/**/*", "package.json"],
 }