@thinkbun/middleware 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @thinkbun/middleware
 
+## 1.0.3
+
+### Patch Changes
+
+- feat(core): 增强 CLI 应用和核心框架功能
+- Updated dependencies
+  - @thinkbun/core@1.0.6
+
+## 1.0.2
+
+### Patch Changes
+
+- 替换 ajv 为 typebox 进行数据校验
+- Updated dependencies
+  - @thinkbun/core@1.0.5
+
 ## 1.0.1
 
 ### Patch Changes

package/package.json

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

package/src/index.ts

@@ -3,15 +3,12 @@ import { cors as _cors, type CorsOptions } from './middlewares/cors';
 import { errorHandler as _errorHandler, type ErrorHandlerOptions } from './middlewares/errorHandler';
 import { logger as _logger, type LoggerOptions } from './middlewares/logger';
 import { staticServe as _staticServe, type StaticOptions } from './middlewares/static';
-import { validator as _validator, type ValidatorOptions, type ValidationRule } from './middlewares/validator';
 
 // 重新导出各个中间件
 export { _errorHandler as errorHandler };
 export type { ErrorHandlerOptions };
 export { _logger as logger };
 export type { LoggerOptions };
-export { _validator as validator };
-export type { ValidatorOptions, ValidationRule };
 export { _cors as cors };
 export type { CorsOptions };
 export { _staticServe as staticServe };
@@ -24,7 +21,6 @@ export type { Middleware, Context } from '@thinkbun/core';
 export const middlewares = {
   errorHandler: _errorHandler,
   logger: _logger,
-  validator: _validator,
   cors: _cors,
   staticServe: _staticServe,
 };

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"],
 }

package/src/middlewares/validator.ts

@@ -1,187 +0,0 @@
-import { BadRequestError, type Context, type Middleware, type RouteSchema } from '@thinkbun/core';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-
-// 使用与核心框架相同的Ajv配置
-const ajv = addFormats(
-  new Ajv({
-    coerceTypes: true, // 自动类型转换
-    useDefaults: true, // 使用默认值
-    removeAdditional: false, // 保留额外属性
-    allErrors: true, // 返回所有错误
-  }),
-  [
-    'date-time',
-    'time',
-    'date',
-    'email',
-    'hostname',
-    'ipv4',
-    'ipv6',
-    'uri',
-    'uri-reference',
-    'uuid',
-    'uri-template',
-    'json-pointer',
-    'relative-json-pointer',
-    'regex',
-  ],
-);
-
-export interface ValidationRule {
-  /**
-   * 路由路径
-   * @example '/api/users'
-   */
-  path: string;
-  /**
-   * HTTP方法
-   * @example 'POST'
-   */
-  method: string;
-  /**
-   * 验证模式
-   */
-  schema: RouteSchema;
-}
-
-export interface ValidatorOptions {
-  /**
-   * 验证规则列表
-   */
-  rules: ValidationRule[];
-  /**
-   * 自定义错误处理函数
-   * @param error 验证错误
-   * @param ctx 请求上下文
-   * @returns 返回自定义的Response对象或抛出错误使用默认处理
-   */
-  errorHandler?: (error: Error, ctx: Context) => Response | never;
-}
-
-export function validator(options: ValidatorOptions): Middleware {
-  if (!options.rules || options.rules.length === 0) {
-    throw new Error('Validator middleware requires at least one validation rule');
-  }
-
-  // 编译所有验证规则
-  const compiledRules = options.rules.map((rule) => {
-    const compiled: any = {};
-
-    if (rule.schema.query) {
-      compiled.query = ajv.compile(rule.schema.query);
-    }
-
-    if (rule.schema.body) {
-      compiled.body = ajv.compile(rule.schema.body);
-    }
-
-    if (rule.schema.params) {
-      compiled.params = ajv.compile(rule.schema.params);
-    }
-
-    if (rule.schema.headers) {
-      compiled.headers = ajv.compile(rule.schema.headers);
-    }
-
-    return {
-      ...rule,
-      compiled,
-    };
-  });
-
-  return async (ctx: Context, next: () => Promise<Response | Context | void>): Promise<Response | Context | void> => {
-    // 查找匹配的验证规则
-    const matchingRules = compiledRules.filter(
-      (rule) => rule.path === ctx.path && rule.method.toUpperCase() === ctx.method.toUpperCase(),
-    );
-
-    if (matchingRules.length === 0) {
-      // 没有匹配的验证规则，继续执行后续中间件
-      return await next();
-    }
-
-    // 使用第一个匹配的规则
-    const rule = matchingRules[0]!; // 类型断言，因为已经确保matchingRules.length > 0
-    const errors: any[] = [];
-
-    // 验证查询参数
-    if (rule.compiled.query) {
-      const query = Object.fromEntries(ctx.url.searchParams);
-      if (!rule.compiled.query(query)) {
-        errors.push(
-          ...rule.compiled.query.errors!.map((err: any) => ({
-            ...err,
-            source: 'query',
-          })),
-        );
-      }
-    }
-
-    // 验证路由参数
-    if (rule.compiled.params) {
-      if (!rule.compiled.params(ctx.params)) {
-        errors.push(
-          ...rule.compiled.params.errors!.map((err: any) => ({
-            ...err,
-            source: 'params',
-          })),
-        );
-      }
-    }
-
-    // 验证请求头
-    if (rule.compiled.headers) {
-      const headers = Object.fromEntries(ctx.headers);
-      if (!rule.compiled.headers(headers)) {
-        errors.push(
-          ...rule.compiled.headers.errors!.map((err: any) => ({
-            ...err,
-            source: 'headers',
-          })),
-        );
-      }
-    }
-
-    // 验证请求体
-    if (rule.compiled.body && ctx.method !== 'GET' && ctx.method !== 'HEAD') {
-      try {
-        const body = await ctx.body();
-        if (!rule.compiled.body(body)) {
-          errors.push(
-            ...rule.compiled.body.errors!.map((err: any) => ({
-              ...err,
-              source: 'body',
-            })),
-          );
-        }
-      } catch (error) {
-        // 如果无法解析请求体，添加错误信息
-        errors.push({
-          keyword: 'invalid_body',
-          message: 'Invalid request body',
-          source: 'body',
-        });
-      }
-    }
-
-    // 如果有验证错误
-    if (errors.length > 0) {
-      const error = new BadRequestError(errors);
-
-      // 使用自定义错误处理（如果提供）
-      if (options.errorHandler) {
-        const response = options.errorHandler(error, ctx);
-        if (response) {
-          return response;
-        }
-      }
-
-      // 抛出错误，由错误处理中间件处理
-      throw error;
-    }
-
-    // 验证通过，继续执行后续中间件
-    return await next();
-  };
-}