@dangao/bun-server 1.0.1 → 1.1.2

package/src/request/body-parser.ts

@@ -0,0 +1,133 @@
+/**
+ * 请求体解析器
+ * 支持 JSON、FormData、URLEncoded 等格式
+ */
+export class BodyParser {
+  /**
+   * 解析请求体
+   * @param request - 请求对象
+   * @returns 解析后的请求体
+   */
+  public static async parse(request: Request): Promise<unknown> {
+    const contentType = request.headers.get('content-type') ?? '';
+
+    // 检查是否有请求体（GET 和 HEAD 请求通常没有 body）
+    if (request.method === 'GET' || request.method === 'HEAD') {
+      return undefined;
+    }
+
+    // 检查 Content-Length
+    const contentLength = request.headers.get('content-length');
+    if (contentLength === '0') {
+      return undefined;
+    }
+
+    // 尝试解析请求体
+    try {
+      // JSON 格式
+      if (contentType.includes('application/json')) {
+        const result = await this.parseJSON(request);
+        return result;
+      }
+
+      // FormData 格式
+      if (contentType.includes('multipart/form-data')) {
+        return await this.parseFormData(request);
+      }
+
+      // URLEncoded 格式
+      if (contentType.includes('application/x-www-form-urlencoded')) {
+        const result = await this.parseURLEncoded(request);
+        return result;
+      }
+
+      // 文本格式
+      if (contentType.includes('text/')) {
+        return await this.parseText(request);
+      }
+
+      // 如果没有 Content-Type 或 Content-Length，尝试读取 body
+      // 如果读取成功，尝试解析为 JSON，否则返回文本
+      if (!contentType && !contentLength) {
+        try {
+          const text = await request.text();
+          if (!text || text.length === 0) {
+            return undefined;
+          }
+          // 尝试解析为 JSON
+          try {
+            return JSON.parse(text);
+          } catch {
+            return text;
+          }
+        } catch {
+          return undefined;
+        }
+      }
+
+      // 默认尝试 JSON，失败后返回原始文本
+      const fallbackText = await request.text();
+      if (!fallbackText) {
+        return undefined;
+      }
+      try {
+        return JSON.parse(fallbackText);
+      } catch {
+        return fallbackText;
+      }
+    } catch (error) {
+      // 如果读取失败，返回 undefined
+      return undefined;
+    }
+  }
+
+  /**
+   * 解析 JSON 格式
+   * @param request - 请求对象
+   * @returns 解析后的对象
+   */
+  private static async parseJSON(request: Request): Promise<unknown> {
+    const text = await request.text();
+    if (!text) {
+      return undefined;
+    }
+    return JSON.parse(text);
+  }
+
+  /**
+   * 解析 FormData 格式
+   * @param request - 请求对象
+   * @returns 解析后的 FormData 对象
+   */
+  private static async parseFormData(request: Request): Promise<FormData> {
+    return await request.formData() as FormData;
+  }
+
+  /**
+   * 解析 URLEncoded 格式
+   * @param request - 请求对象
+   * @returns 解析后的对象
+   */
+  private static async parseURLEncoded(request: Request): Promise<Record<string, string> | undefined> {
+    const text = await request.text();
+    if (!text || text.length === 0) {
+      return undefined;
+    }
+
+    const params = new URLSearchParams(text);
+    const result: Record<string, string> = {};
+    params.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+
+  /**
+   * 解析文本格式
+   * @param request - 请求对象
+   * @returns 文本内容
+   */
+  private static async parseText(request: Request): Promise<string> {
+    return await request.text();
+  }
+}

package/src/request/file-handler.ts

@@ -0,0 +1,46 @@
+import type { Context } from '../core/context';
+
+export interface UploadedFile {
+  name: string;
+  type: string;
+  size: number;
+  data: ArrayBuffer;
+}
+
+export class FileHandler {
+  private static readonly MAX_SIZE = 10 * 1024 * 1024; // 10MB
+
+  public static async parseFormData(context: Context): Promise<FormData> {
+    const contentType = context.getHeader('Content-Type');
+    if (!contentType || !contentType.includes('multipart/form-data')) {
+      throw new Error('Content-Type must be multipart/form-data');
+    }
+    const request = context.request;
+    return await request.formData() as FormData;
+  }
+
+  public static async getFiles(formData: FormData): Promise<Record<string, UploadedFile[]>> {
+    const files: Record<string, UploadedFile[]> = {};
+    for (const [key, value] of formData.entries()) {
+      // @ts-ignore
+      if (value instanceof File) {
+        const buffer = await value.arrayBuffer();
+        if (buffer.byteLength > this.MAX_SIZE) {
+          throw new Error(`File ${value.name} exceeds maximum size`);
+        }
+        if (!files[key]) {
+          files[key] = [];
+        }
+        files[key].push({
+          name: value.name,
+          type: value.type,
+          size: value.size,
+          data: buffer,
+        });
+      }
+    }
+    return files;
+  }
+}
+
+

package/src/request/index.ts

@@ -0,0 +1,5 @@
+export { BodyParser } from './body-parser';
+export { RequestWrapper } from './request';
+export { ResponseBuilder } from './response';
+export { FileHandler } from './file-handler';
+

package/src/request/request.ts

@@ -0,0 +1,107 @@
+import { BodyParser } from './body-parser';
+
+/**
+ * 请求封装类
+ * 扩展原生 Request，提供便捷方法
+ */
+export class RequestWrapper {
+  /**
+   * 原始请求对象
+   */
+  public readonly request: Request;
+
+  /**
+   * 请求 URL
+   */
+  public readonly url: URL;
+
+  /**
+   * 请求方法
+   */
+  public readonly method: string;
+
+  /**
+   * 请求路径
+   */
+  public readonly path: string;
+
+  /**
+   * 查询参数
+   */
+  public readonly query: URLSearchParams;
+
+  /**
+   * 请求头
+   */
+  public readonly headers: Headers;
+
+  /**
+   * 请求体（解析后的）
+   */
+  private _body?: unknown;
+
+  /**
+   * 是否已解析请求体
+   */
+  private _bodyParsed: boolean = false;
+
+  public constructor(request: Request) {
+    this.request = request;
+    this.url = new URL(request.url);
+    this.method = request.method;
+    this.path = this.url.pathname;
+    this.query = this.url.searchParams;
+    this.headers = request.headers;
+  }
+
+  /**
+   * 获取请求体（自动解析）
+   * @returns 解析后的请求体
+   */
+  public async body(): Promise<unknown> {
+    if (!this._bodyParsed) {
+      this._body = await BodyParser.parse(this.request);
+      this._bodyParsed = true;
+    }
+    return this._body;
+  }
+
+  /**
+   * 获取请求体（已解析的，如果未解析则返回 undefined）
+   * @returns 请求体或 undefined
+   */
+  public getBody(): unknown {
+    return this._body;
+  }
+
+  /**
+   * 获取查询参数
+   * @param key - 参数名
+   * @returns 参数值
+   */
+  public getQuery(key: string): string | null {
+    return this.query.get(key);
+  }
+
+  /**
+   * 获取所有查询参数
+   * @returns 查询参数对象
+   */
+  public getQueryAll(): Record<string, string> {
+    const result: Record<string, string> = {};
+    this.query.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+
+  /**
+   * 获取请求头
+   * @param key - 头名称
+   * @returns 头值
+   */
+  public getHeader(key: string): string | null {
+    return this.headers.get(key);
+  }
+}
+

package/src/request/response.ts

@@ -0,0 +1,150 @@
+import type { BodyInit, HeadersInit } from 'bun';
+
+/**
+ * 响应封装类
+ * 提供便捷的响应创建方法
+ */
+export class ResponseBuilder {
+  /**
+   * 创建 JSON 响应
+   * @param data - 响应数据
+   * @param status - HTTP 状态码
+   * @param headers - 响应头
+   * @returns Response 对象
+   */
+  public static json(
+    data: unknown,
+    status: number = 200,
+    headers?: HeadersInit,
+  ): Response {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set('Content-Type', 'application/json');
+
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: responseHeaders,
+    });
+  }
+
+  /**
+   * 创建文本响应
+   * @param text - 响应文本
+   * @param status - HTTP 状态码
+   * @param headers - 响应头
+   * @returns Response 对象
+   */
+  public static text(
+    text: string,
+    status: number = 200,
+    headers?: HeadersInit,
+  ): Response {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set('Content-Type', 'text/plain');
+
+    return new Response(text, {
+      status,
+      headers: responseHeaders,
+    });
+  }
+
+  /**
+   * 创建 HTML 响应
+   * @param html - HTML 内容
+   * @param status - HTTP 状态码
+   * @param headers - 响应头
+   * @returns Response 对象
+   */
+  public static html(
+    html: string,
+    status: number = 200,
+    headers?: HeadersInit,
+  ): Response {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set('Content-Type', 'text/html');
+
+    return new Response(html, {
+      status,
+      headers: responseHeaders,
+    });
+  }
+
+  /**
+   * 创建空响应
+   * @param status - HTTP 状态码
+   * @param headers - 响应头
+   * @returns Response 对象
+   */
+  public static empty(status: number = 204, headers?: HeadersInit): Response {
+    const responseHeaders = headers ? new Headers(headers) : undefined;
+    return new Response(null, {
+      status,
+      headers: responseHeaders,
+    });
+  }
+
+  /**
+   * 创建重定向响应
+   * @param url - 重定向 URL
+   * @param status - HTTP 状态码（默认 302）
+   * @returns Response 对象
+   */
+  public static redirect(url: string, status: number = 302): Response {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url,
+      },
+    });
+  }
+
+  /**
+   * 创建错误响应
+   * @param message - 错误消息
+   * @param status - HTTP 状态码
+   * @returns Response 对象
+   */
+  public static error(message: string, status: number = 500): Response {
+    return this.json({ error: message }, status);
+  }
+
+  /**
+   * 创建文件/下载响应
+   * @param source - 文件路径或二进制数据
+   * @param options - 响应配置
+   * @returns Response 对象
+   */
+  public static file(
+    source: string | Blob | ArrayBuffer | ArrayBufferView,
+    options: {
+      fileName?: string;
+      contentType?: string;
+      status?: number;
+      headers?: HeadersInit;
+    } = {},
+  ): Response {
+    const headers = new Headers(options.headers);
+    if (options.fileName) {
+      headers.set('Content-Disposition', `attachment; filename="${options.fileName}"`);
+    }
+    if (options.contentType) {
+      headers.set('Content-Type', options.contentType);
+    }
+
+    if (typeof source === 'string') {
+      const file = Bun.file(source);
+      if (!headers.has('Content-Type') && file.type) {
+        headers.set('Content-Type', file.type);
+      }
+      return new Response(file, {
+        status: options.status ?? 200,
+        headers,
+      });
+    }
+
+    return new Response(source as BodyInit, {
+      status: options.status ?? 200,
+      headers,
+    });
+  }
+}
+

package/src/router/decorators.ts

@@ -0,0 +1,123 @@
+import 'reflect-metadata';
+import type { RouteHandler } from './types';
+import { RouteRegistry } from './registry';
+import type { HttpMethod } from './types';
+import { CONTROLLER_METADATA_KEY } from '../controller/controller';
+
+/**
+ * 路由元数据键
+ */
+export const ROUTE_METADATA_KEY = Symbol('route');
+
+/**
+ * 路由元数据
+ */
+export interface RouteMetadata {
+  method: HttpMethod;
+  path: string;
+  handler: RouteHandler;
+  /**
+   * 属性键（用于控制器方法）
+   */
+  propertyKey?: string;
+}
+
+/**
+ * 路由装饰器工厂
+ * @param method - HTTP 方法
+ * @param path - 路由路径
+ * @returns 方法装饰器
+ */
+function createRouteDecorator(method: HttpMethod, path: string) {
+  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
+    // 注意：装饰器应用顺序问题
+    // 方法装饰器（@GET）在类装饰器（@Controller）之前应用
+    // 因此这里无法立即检查 @Controller，需要在 ControllerRegistry.register 时验证
+    
+    // 尝试检查类是否已经有 @Controller 装饰器（如果装饰器已经应用）
+    // 这可以捕获一些早期错误，但不是 100% 可靠（因为装饰器应用顺序）
+    const constructor = target.constructor;
+    if (constructor && typeof constructor === 'function') {
+      const hasController = Reflect.getMetadata(CONTROLLER_METADATA_KEY, constructor);
+      if (hasController === undefined) {
+        // 类装饰器可能还没有应用，这是正常的
+        // 如果类装饰器已经应用但没有 @Controller，这里会捕获到
+        // 但这种情况很少见，因为通常 @Controller 会在 @GET 之前应用
+      }
+    }
+    
+    // 保存元数据
+    // 注意：即使类没有 @Controller，元数据也会被保存
+    // 但 ControllerRegistry.register 会验证并抛出错误，所以不会造成问题
+    const existingRoutes: RouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+    
+    // 获取方法名：优先使用 propertyKey，如果不可用则从函数名获取
+    let propertyKeyStr: string;
+    if (propertyKey && propertyKey !== '') {
+      propertyKeyStr = typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
+    } else {
+      // 从函数名获取（可能不可靠，但作为后备方案）
+      propertyKeyStr = descriptor.value.name || '';
+    }
+    
+    // 如果仍然没有方法名，尝试从原型中查找
+    if (!propertyKeyStr) {
+      const propertyNames = Object.getOwnPropertyNames(target);
+      for (const key of propertyNames) {
+        const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (targetDescriptor?.value === descriptor.value) {
+          propertyKeyStr = key;
+          break;
+        }
+      }
+    }
+    
+    existingRoutes.push({ 
+      method, 
+      path, 
+      handler: descriptor.value as RouteHandler,
+      propertyKey: propertyKeyStr || undefined,
+    });
+    Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
+  };
+}
+
+/**
+ * GET 路由装饰器
+ * @param path - 路由路径
+ */
+export function GET(path: string) {
+  return createRouteDecorator('GET', path);
+}
+
+/**
+ * POST 路由装饰器
+ * @param path - 路由路径
+ */
+export function POST(path: string) {
+  return createRouteDecorator('POST', path);
+}
+
+/**
+ * PUT 路由装饰器
+ * @param path - 路由路径
+ */
+export function PUT(path: string) {
+  return createRouteDecorator('PUT', path);
+}
+
+/**
+ * DELETE 路由装饰器
+ * @param path - 路由路径
+ */
+export function DELETE(path: string) {
+  return createRouteDecorator('DELETE', path);
+}
+
+/**
+ * PATCH 路由装饰器
+ * @param path - 路由路径
+ */
+export function PATCH(path: string) {
+  return createRouteDecorator('PATCH', path);
+}

package/src/router/index.ts

@@ -0,0 +1,6 @@
+export { Route } from './route';
+export { Router } from './router';
+export { RouteRegistry } from './registry';
+export { GET, POST, PUT, DELETE, PATCH } from './decorators';
+export type { HttpMethod, RouteHandler, RouteMatch } from './types';
+

package/src/router/registry.ts

@@ -0,0 +1,99 @@
+import { Router } from './router';
+import type { Constructor } from '../core/types';
+import type { HttpMethod, RouteHandler } from './types';
+import type { Middleware } from '../middleware';
+
+/**
+ * 路由注册表
+ * 全局路由注册表，管理所有路由
+ */
+export class RouteRegistry {
+  private static instance: RouteRegistry;
+  private readonly router: Router;
+
+  private constructor() {
+    this.router = new Router();
+  }
+
+  /**
+   * 获取单例实例
+   * @returns 路由注册表实例
+   */
+  public static getInstance(): RouteRegistry {
+    if (!RouteRegistry.instance) {
+      RouteRegistry.instance = new RouteRegistry();
+    }
+    return RouteRegistry.instance;
+  }
+
+  /**
+   * 注册路由
+   * @param method - HTTP 方法
+   * @param path - 路由路径
+   * @param handler - 路由处理器
+   * @param middlewares - 中间件列表
+   * @param controllerClass - 控制器类（可选）
+   * @param methodName - 方法名（可选）
+   */
+  public register(
+    method: HttpMethod,
+    path: string,
+    handler: RouteHandler,
+    middlewares: Middleware[] = [],
+    controllerClass?: Constructor<unknown>,
+    methodName?: string,
+  ): void {
+    this.router.register(method, path, handler, middlewares, controllerClass, methodName);
+  }
+
+  /**
+   * 注册 GET 路由
+   */
+  public get(path: string, handler: RouteHandler, middlewares: Middleware[] = []): void {
+    this.router.get(path, handler, middlewares);
+  }
+
+  /**
+   * 注册 POST 路由
+   */
+  public post(path: string, handler: RouteHandler, middlewares: Middleware[] = []): void {
+    this.router.post(path, handler, middlewares);
+  }
+
+  /**
+   * 注册 PUT 路由
+   */
+  public put(path: string, handler: RouteHandler, middlewares: Middleware[] = []): void {
+    this.router.put(path, handler, middlewares);
+  }
+
+  /**
+   * 注册 DELETE 路由
+   */
+  public delete(path: string, handler: RouteHandler, middlewares: Middleware[] = []): void {
+    this.router.delete(path, handler, middlewares);
+  }
+
+  /**
+   * 注册 PATCH 路由
+   */
+  public patch(path: string, handler: RouteHandler, middlewares: Middleware[] = []): void {
+    this.router.patch(path, handler, middlewares);
+  }
+
+  /**
+   * 获取路由器实例
+   * @returns 路由器实例
+   */
+  public getRouter(): Router {
+    return this.router;
+  }
+
+  /**
+   * 清除所有路由（主要用于测试）
+   */
+  public clear(): void {
+    this.router.clear();
+  }
+}
+