@thinkbun/middleware 1.0.0

package/src/middlewares/logger.ts

@@ -0,0 +1,143 @@
+import type { Context, Middleware } from '@thinkbun/core';
+
+export interface LoggerOptions {
+  /**
+   * 日志格式
+   * @default 'text'
+   */
+  format?: 'text' | 'json';
+  /**
+   * 自定义日志记录函数
+   * @param message 日志信息
+   * @param details 日志详细信息
+   */
+  logger?: (message: string, details?: Record<string, any>) => void;
+  /**
+   * 需要忽略日志记录的路径
+   * @example ['/health', '/metrics']
+   */
+  ignorePaths?: string[];
+  /**
+   * 是否记录请求体（仅适用于非GET请求）
+   * @default false
+   */
+  logRequestBody?: boolean;
+  /**
+   * 是否记录响应体
+   * @default false
+   */
+  logResponseBody?: boolean;
+}
+
+export function logger(options: LoggerOptions = {}): Middleware {
+  const {
+    format = 'text',
+    logger = console.log,
+    ignorePaths = [],
+    logRequestBody = false,
+    logResponseBody = false,
+  } = options;
+
+  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: {
+      method: string;
+      path: string;
+      ip: string;
+      userAgent: string;
+      query: Record<string, string>;
+      body?: unknown;
+    } = {
+      method: ctx.method,
+      path: ctx.path,
+      ip: ctx.ip?.address || 'unknown',
+      userAgent: ctx.userAgent || 'unknown',
+      query: Object.fromEntries(ctx.url.searchParams),
+    };
+
+    // 记录请求体（如果需要）
+    if (logRequestBody && ctx.method !== 'GET') {
+      try {
+        const body = await ctx.body();
+        requestInfo.body = body;
+      } catch (_error) {
+        // 忽略读取请求体错误
+      }
+    }
+
+    let response: Response | Context | void = undefined;
+    try {
+      response = await next();
+      return response;
+    } catch (error) {
+      // 记录错误
+      const endTime = Date.now();
+      const errorInfo = {
+        ...requestInfo,
+        status: 500,
+        duration: endTime - startTime,
+        error: (error as Error).message,
+        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}`,
+        );
+      }
+
+      throw error;
+    } finally {
+      // 记录正常响应
+      if (response instanceof Response) {
+        const endTime = Date.now();
+        const responseInfo: {
+          method: string;
+          path: string;
+          ip: string;
+          userAgent: string;
+          query: Record<string, string>;
+          body?: unknown;
+          status: number;
+          duration: number;
+          headers: Record<string, string>;
+        } = {
+          ...requestInfo,
+          status: response.status,
+          duration: endTime - startTime,
+          headers: Object.fromEntries(response.headers),
+          body: undefined,
+        };
+
+        // 记录响应体（如果需要）
+        if (logResponseBody) {
+          try {
+            // 克隆响应以读取响应体
+            const clonedResponse = response.clone();
+            const body = await clonedResponse.text();
+            try {
+              responseInfo.body = JSON.parse(body);
+            } catch {
+              responseInfo.body = body;
+            }
+          } catch (_error) {
+            // 忽略读取响应体错误
+          }
+        }
+
+        if (format === 'json') {
+          logger(JSON.stringify(responseInfo));
+        } else {
+          logger(`[INFO] ${requestInfo.method} ${requestInfo.path} ${response.status} ${endTime - startTime}ms`);
+        }
+      }
+    }
+  };
+}

package/src/middlewares/static.ts

@@ -0,0 +1,236 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import type { Context, Middleware } from '@thinkbun/core';
+
+export interface StaticOptions {
+  /**
+   * 静态资源目录的绝对路径
+   */
+  root: string;
+  /**
+   * 请求路径前缀
+   * @example '/public' 会将 /public/css/style.css 映射到 root/css/style.css
+   */
+  prefix?: string;
+  /**
+   * 自动索引文件
+   * @default ['index.html', 'index.htm']
+   */
+  index?: string[];
+  /**
+   * 缓存控制头
+   * @example 'public, max-age=31536000' 或 (path: string) => string
+   */
+  cacheControl?: string | ((filePath: string) => string);
+  /**
+   * 是否启用文件压缩
+   * @default true
+   */
+  compression?: boolean;
+  /**
+   * 文件不存在时的处理函数
+   * @param ctx 请求上下文
+   * @param filePath 请求的文件路径
+   * @returns 返回自定义的Response对象或undefined继续执行后续中间件
+   */
+  notFoundHandler?: (ctx: Context, filePath: string) => Response | undefined;
+}
+
+export function staticServe(options: StaticOptions): Middleware {
+  if (!options.root) {
+    throw new Error('Static middleware requires a root directory');
+  }
+
+  const {
+    root,
+    prefix = '',
+    index = ['index.html', 'index.htm'],
+    cacheControl,
+    _compression = true,
+    notFoundHandler,
+  } = options;
+
+  // 移除前缀末尾的斜杠
+  const normalizedPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+
+  // 获取文件的MIME类型
+  const getContentType = (filePath: string): string => {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+      case '.html':
+        return 'text/html; charset=utf-8';
+      case '.css':
+        return 'text/css';
+      case '.js':
+        return 'application/javascript; charset=utf-8';
+      case '.json':
+        return 'application/json';
+      case '.png':
+        return 'image/png';
+      case '.jpg':
+      case '.jpeg':
+        return 'image/jpeg';
+      case '.gif':
+        return 'image/gif';
+      case '.svg':
+        return 'image/svg+xml';
+      case '.ico':
+        return 'image/x-icon';
+      case '.webp':
+        return 'image/webp';
+      case '.woff':
+        return 'font/woff';
+      case '.woff2':
+        return 'font/woff2';
+      case '.ttf':
+        return 'font/ttf';
+      case '.otf':
+        return 'font/otf';
+      case '.eot':
+        return 'application/vnd.ms-fontobject';
+      case '.mp3':
+        return 'audio/mpeg';
+      case '.mp4':
+        return 'video/mp4';
+      case '.pdf':
+        return 'application/pdf';
+      case '.zip':
+        return 'application/zip';
+      case '.txt':
+        return 'text/plain; charset=utf-8';
+      default:
+        return 'application/octet-stream';
+    }
+  };
+
+  return async (ctx: Context, next: () => Promise<Response | Context | void>): Promise<Response | Context | void> => {
+    // 检查请求路径是否匹配前缀
+    if (normalizedPrefix && !ctx.path.startsWith(normalizedPrefix)) {
+      return await next();
+    }
+
+    // 移除前缀，获取相对文件路径
+    let filePath = ctx.path;
+    if (normalizedPrefix) {
+      filePath = filePath.slice(normalizedPrefix.length);
+    }
+
+    // 防止路径遍历攻击
+    if (filePath.includes('..')) {
+      return new Response('Forbidden', { status: 403 });
+    }
+
+    // 构建绝对文件路径
+    let absolutePath = path.join(root, filePath);
+
+    // 检查是否是目录
+    let stats;
+    try {
+      stats = await fs.stat(absolutePath);
+    } catch (_error) {
+      // 文件不存在，检查是否有自定义404处理
+      if (notFoundHandler) {
+        const customResponse = notFoundHandler(ctx, absolutePath);
+        if (customResponse) {
+          return customResponse;
+        }
+      }
+      return await next();
+    }
+
+    // 如果是目录，尝试查找索引文件
+    if (stats.isDirectory()) {
+      // 确保路径以斜杠结尾
+      if (!ctx.path.endsWith('/')) {
+        return new Response(null, {
+          status: 301,
+          headers: {
+            Location: ctx.path + '/',
+          },
+        });
+      }
+
+      // 查找索引文件
+      for (const indexFile of index) {
+        const indexPath = path.join(absolutePath, indexFile);
+        try {
+          const indexStats = await fs.stat(indexPath);
+          if (indexStats.isFile()) {
+            absolutePath = indexPath;
+            break;
+          }
+        } catch (_error) {
+          // 继续查找下一个索引文件
+        }
+      }
+
+      // 检查是否找到了索引文件
+      try {
+        stats = await fs.stat(absolutePath);
+        if (!stats.isFile()) {
+          // 没有找到索引文件，继续执行后续中间件
+          return await next();
+        }
+      } catch (_error) {
+        return await next();
+      }
+    }
+
+    // 读取文件
+    let content: Buffer;
+    try {
+      content = await fs.readFile(absolutePath);
+    } catch (_error) {
+      return await next();
+    }
+
+    // 设置响应头
+    const headers: Record<string, string> = {
+      'Content-Type': getContentType(absolutePath),
+      'Content-Length': content.length.toString(),
+      'Last-Modified': stats.mtime.toUTCString(),
+      'Accept-Ranges': 'bytes',
+    };
+
+    // 设置缓存控制头
+    if (cacheControl) {
+      const cacheHeader = typeof cacheControl === 'function' ? cacheControl(absolutePath) : cacheControl;
+      if (cacheHeader) {
+        headers['Cache-Control'] = cacheHeader;
+      }
+    }
+
+    // 支持范围请求
+    const rangeHeader = ctx.header('Range');
+    if (rangeHeader) {
+      const parts = rangeHeader.replace(/bytes=/, '').split('-');
+      const start = parseInt(parts[0] || '0', 10);
+      const end = parts[1] ? parseInt(parts[1], 10) : content.length - 1;
+
+      if (isNaN(start) || isNaN(end) || start > end || end >= content.length) {
+        return new Response(null, {
+          status: 416,
+          headers: {
+            'Content-Range': `bytes */${content.length}`,
+          },
+        });
+      }
+
+      const rangeContent = content.slice(start, end + 1);
+      headers['Content-Range'] = `bytes ${start}-${end}/${content.length}`;
+      headers['Content-Length'] = rangeContent.length.toString();
+
+      return new Response(rangeContent, {
+        status: 206,
+        headers,
+      });
+    }
+
+    // 返回完整文件
+    return new Response(content, {
+      status: 200,
+      headers,
+    });
+  };
+}

package/src/middlewares/validator.ts

@@ -0,0 +1,187 @@
+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();
+  };
+}

package/src/test/index.ts

@@ -0,0 +1 @@
+// Test entry point