@dangao/bun-server 1.0.0 → 1.0.3

package/src/core/application.ts

@@ -0,0 +1,233 @@
+import { BunServer, type ServerOptions } from './server';
+import { Context } from './context';
+import { RouteRegistry } from '../router/registry';
+import { ControllerRegistry } from '../controller/controller';
+import { MiddlewarePipeline } from '../middleware/pipeline';
+import type { Middleware } from '../middleware';
+import { createErrorHandlingMiddleware } from '../middleware';
+import { WebSocketGatewayRegistry } from '../websocket/registry';
+import type { ApplicationExtension } from '../extensions/types';
+import { LoggerExtension } from '../extensions/logger-extension';
+import { ModuleRegistry } from '../di/module-registry';
+import type { ModuleClass } from '../di/module';
+import type { Constructor } from './types'
+
+/**
+ * 应用配置选项
+ */
+export interface ApplicationOptions {
+  /**
+   * 端口号
+   */
+  port?: number;
+
+  /**
+   * 主机名
+   */
+  hostname?: string;
+}
+
+/**
+ * 应用主类
+ * 负责初始化和启动应用
+ */
+export class Application {
+  private server?: BunServer;
+  private readonly options: ApplicationOptions;
+  private readonly middlewarePipeline: MiddlewarePipeline;
+  private readonly websocketRegistry: WebSocketGatewayRegistry;
+  private readonly extensions: ApplicationExtension[] = [];
+
+  public constructor(options: ApplicationOptions = {}) {
+    this.options = options;
+    this.middlewarePipeline = new MiddlewarePipeline([createErrorHandlingMiddleware()]);
+    this.websocketRegistry = WebSocketGatewayRegistry.getInstance();
+
+    // 每个应用实例使用前先清空全局注册表，避免不同应用之间互相污染
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    ModuleRegistry.getInstance().clear();
+
+    // 默认注册 Logger（如果通过模块注册，会被覆盖）
+    this.registerExtension(new LoggerExtension());
+  }
+
+  /**
+   * 注册全局中间件
+   * @param middleware - 中间件函数
+   */
+  public use(middleware: Middleware): void {
+    this.middlewarePipeline.use(middleware);
+  }
+
+  /**
+   * 启动应用
+   */
+  public async listen(port?: number, hostname?: string): Promise<void> {
+    if (this.server?.isRunning()) {
+      throw new Error('Application is already running');
+    }
+
+    // 初始化所有扩展（包括数据库连接等）
+    await this.initializeExtensions();
+
+    const serverOptions: ServerOptions = {
+      port: port ?? this.options.port ?? 3000,
+      hostname: hostname ?? this.options.hostname,
+      fetch: this.handleRequest.bind(this),
+      websocketRegistry: this.websocketRegistry,
+    };
+
+    this.server = new BunServer(serverOptions);
+    this.server.start();
+  }
+
+  /**
+   * 初始化所有扩展
+   */
+  private async initializeExtensions(): Promise<void> {
+    const container = this.getContainer();
+    
+    // 初始化应用级别的扩展
+    for (const extension of this.extensions) {
+      // 如果扩展有 initialize 方法，调用它
+      if (
+        extension &&
+        typeof extension === 'object' &&
+        'initialize' in extension &&
+        typeof extension.initialize === 'function'
+      ) {
+        await extension.initialize(container);
+      }
+    }
+
+    // 初始化模块中的扩展（通过已注册的扩展列表）
+    // 模块扩展已经在 registerModule 时添加到 this.extensions
+    // 所以上面的循环已经处理了
+  }
+
+  /**
+   * 停止应用
+   */
+  public async stop(): Promise<void> {
+    // 关闭所有扩展（包括数据库连接等）
+    await this.closeExtensions();
+    this.server?.stop();
+  }
+
+  /**
+   * 关闭所有扩展
+   */
+  private async closeExtensions(): Promise<void> {
+    const container = this.getContainer();
+
+    // 关闭所有扩展（包括模块扩展，因为它们已经在 registerModule 时添加到 this.extensions）
+    // 按相反顺序关闭，确保依赖关系正确
+    for (let i = this.extensions.length - 1; i >= 0; i--) {
+      const extension = this.extensions[i];
+      if (
+        extension &&
+        typeof extension === 'object' &&
+        'close' in extension &&
+        typeof extension.close === 'function'
+      ) {
+        await extension.close(container);
+      }
+    }
+  }
+
+  /**
+   * 处理请求
+   * @param context - 请求上下文
+   * @returns 响应对象
+   */
+  private async handleRequest(context: Context): Promise<Response> {
+    // 对于 POST、PUT、PATCH 请求，提前解析 body 并缓存
+    // 这样可以确保 Request.body 流只读取一次
+    if (['POST', 'PUT', 'PATCH'].includes(context.method)) {
+      await context.getBody();
+    }
+
+    // 先通过路由解析出处理器信息，便于安全中间件等基于路由元数据做决策
+    const registry = RouteRegistry.getInstance();
+    const router = registry.getRouter();
+
+    // 预解析路由，仅设置上下文信息，不执行处理器
+    await router.preHandle(context);
+
+    // 再进入中间件管道，由中间件（如安全过滤器）根据 routeHandler 和 Auth 元数据做校验，
+    // 最后再由路由真正执行控制器方法
+    return await this.middlewarePipeline.run(context, async () => {
+      const response = await router.handle(context);
+      if (response) {
+        return response;
+      }
+
+      context.setStatus(404);
+      return context.createResponse({ error: 'Not Found' });
+    });
+  }
+
+  /**
+   * 注册控制器
+   * @param controllerClass - 控制器类
+   */
+  public registerController(controllerClass: Constructor<unknown>): void {
+    const registry = ControllerRegistry.getInstance();
+    registry.register(controllerClass);
+  }
+
+  /**
+   * 注册模块
+   * @param moduleClass - 模块类
+   */
+  public registerModule(moduleClass: ModuleClass): void {
+    const registry = ModuleRegistry.getInstance();
+    registry.register(moduleClass, this.getContainer());
+    
+    // 注册模块的扩展和中间件
+    const extensions = registry.getModuleExtensions(moduleClass);
+    for (const extension of extensions) {
+      this.registerExtension(extension);
+    }
+    
+    const middlewares = registry.getModuleMiddlewares(moduleClass);
+    for (const middleware of middlewares) {
+      this.use(middleware);
+    }
+  }
+
+  /**
+   * 注册 WebSocket 网关
+   * @param gatewayClass - WebSocket 网关类
+   */
+  public registerWebSocketGateway(gatewayClass: Constructor<unknown>): void {
+    this.websocketRegistry.register(gatewayClass);
+  }
+
+  /**
+   * 注册扩展
+   * @param extension - 应用扩展
+   */
+  public registerExtension(extension: ApplicationExtension): void {
+    this.extensions.push(extension);
+    extension.register(this.getContainer());
+  }
+
+  /**
+   * 获取服务器实例
+   * @returns Bun Server 实例
+   */
+  public getServer(): BunServer | undefined {
+    return this.server;
+  }
+
+  /**
+   * 获取 DI 容器（用于注册服务）
+   * @returns DI 容器
+   */
+  public getContainer() {
+    return ControllerRegistry.getInstance().getContainer();
+  }
+}
+

package/src/core/context.ts

@@ -0,0 +1,228 @@
+import { BodyParser } from '../request/body-parser';
+import type { UploadedFileInfo } from '../files';
+import type { BodyInit } from 'bun'
+
+/**
+ * 请求上下文
+ * 封装 Request 和 Response，提供便捷的访问方法
+ */
+export class Context {
+  /**
+   * 原始请求对象
+   */
+  public readonly request: Request;
+
+  /**
+   * 响应对象（可选，由框架创建）
+   */
+  public response?: Response;
+
+  /**
+   * 请求 URL
+   */
+  public readonly url: URL;
+
+  /**
+   * 请求方法
+   */
+  public readonly method: string;
+
+  /**
+   * 请求路径
+   */
+  public readonly path: string;
+
+  /**
+   * 查询参数
+   */
+  public readonly query: URLSearchParams;
+
+  /**
+   * 路径参数（由路由匹配后填充）
+   */
+  public params: Record<string, string> = {};
+
+  /**
+   * 请求头
+   */
+  public readonly headers: Headers;
+
+  /**
+   * 响应头
+   */
+  public responseHeaders: Headers;
+
+  /**
+   * 状态码
+   */
+  public statusCode: number = 200;
+
+  /**
+   * 上传文件信息
+   */
+  public files: UploadedFileInfo[] = [];
+
+  /**
+   * 请求体（解析后的）
+   */
+  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;
+    this.responseHeaders = new Headers();
+  }
+
+  /**
+   * 获取请求体（自动解析）
+   * @returns 解析后的请求体
+   */
+  public async getBody(): Promise<unknown> {
+    if (!this._bodyParsed) {
+      this._body = await BodyParser.parse(this.request);
+      this._bodyParsed = true;
+    }
+    return this._body;
+  }
+
+  /**
+   * 获取请求体（已解析的，如果未解析则返回 undefined）
+   * @returns 请求体或 undefined
+   */
+  public get body(): unknown {
+    return this._body;
+  }
+
+  /**
+   * 设置请求体
+   * @param body - 请求体
+   */
+  public set body(body: unknown) {
+    this._body = body;
+    this._bodyParsed = true;
+  }
+
+  /**
+   * 获取查询参数
+   * @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 getParam(key: string): string | undefined {
+    return this.params[key];
+  }
+
+  /**
+   * 获取请求头
+   * @param key - 头名称
+   * @returns 头值
+   */
+  public getHeader(key: string): string | null {
+    return this.headers.get(key);
+  }
+
+  /**
+   * 获取客户端 IP 地址
+   * 优先从 X-Forwarded-For 头获取（代理场景），否则从连接信息获取
+   * @returns 客户端 IP 地址
+   */
+  public getClientIp(): string {
+    // 优先从 X-Forwarded-For 头获取（处理代理场景）
+    const forwardedFor = this.getHeader('X-Forwarded-For');
+    if (forwardedFor) {
+      // X-Forwarded-For 可能包含多个 IP，取第一个
+      return forwardedFor.split(',')[0].trim();
+    }
+
+    // 尝试从 X-Real-IP 头获取
+    const realIp = this.getHeader('X-Real-IP');
+    if (realIp) {
+      return realIp.trim();
+    }
+
+    // 如果是在 Bun.serve 中，可以从 request 获取
+    // 但标准 Request 对象没有直接 IP 信息，返回默认值
+    return 'unknown';
+  }
+
+  /**
+   * 设置响应头
+   * @param key - 头名称
+   * @param value - 头值
+   */
+  public setHeader(key: string, value: string): void {
+    this.responseHeaders.set(key, value);
+  }
+
+  /**
+   * 设置状态码
+   * @param code - HTTP 状态码
+   */
+  public setStatus(code: number): void {
+    this.statusCode = code;
+  }
+
+  /**
+   * 创建响应
+   * @param body - 响应体
+   * @param init - 响应初始化选项
+   * @returns Response 对象
+   */
+  public createResponse(body?: unknown, init?: ResponseInit): Response {
+    // 如果已经是 Response 对象，直接返回
+    if (body instanceof Response) {
+      return body;
+    }
+
+    const headers = new Headers(this.responseHeaders);
+    
+    // 如果 body 是对象，自动序列化为 JSON
+    if (body !== undefined && body !== null) {
+      if (typeof body === 'object' && !(body instanceof ArrayBuffer) && !(body instanceof Blob)) {
+        headers.set('Content-Type', 'application/json');
+        const jsonString = JSON.stringify(body);
+        return new Response(jsonString, {
+          status: this.statusCode,
+          headers,
+          ...init,
+        });
+      }
+    }
+
+    return new Response(body as BodyInit, {
+      status: this.statusCode,
+      headers,
+      ...init,
+    });
+  }
+}
+

package/src/core/index.ts

@@ -0,0 +1,4 @@
+export { Application, type ApplicationOptions } from './application';
+export { BunServer, type ServerOptions } from './server';
+export { Context } from './context';
+

package/src/core/server.ts

@@ -0,0 +1,128 @@
+import type { Server } from "bun";
+import { Context } from "./context";
+import { LoggerManager } from "@dangao/logsmith";
+import type { WebSocketGatewayRegistry } from "../websocket/registry";
+import type { WebSocketConnectionData } from "../websocket/registry";
+
+/**
+ * 服务器配置选项
+ */
+export interface ServerOptions {
+  /**
+   * 端口号
+   */
+  port?: number;
+
+  /**
+   * 主机名
+   */
+  hostname?: string;
+
+  /**
+   * 请求处理函数
+   */
+  fetch: (context: Context) => Response | Promise<Response>;
+
+  /**
+   * WebSocket 网关注册表
+   */
+  websocketRegistry?: WebSocketGatewayRegistry;
+}
+
+/**
+ * 服务器封装类
+ * 基于 Bun.serve() 构建
+ */
+export class BunServer {
+  private server?: Server<WebSocketConnectionData>;
+  private readonly options: ServerOptions;
+
+  public constructor(options: ServerOptions) {
+    this.options = options;
+  }
+
+  /**
+   * 启动服务器
+   */
+  public start(): void {
+    if (this.server) {
+      throw new Error("Server is already running");
+    }
+
+    const logger = LoggerManager.getLogger();
+
+    this.server = Bun.serve({
+      port: this.options.port ?? 3000,
+      hostname: this.options.hostname,
+      fetch: (
+        request: Request,
+        server: Server<WebSocketConnectionData>,
+      ): Response | Promise<Response> | undefined => {
+        const upgradeHeader = request.headers.get("upgrade");
+        if (
+          this.options.websocketRegistry &&
+          upgradeHeader &&
+          upgradeHeader.toLowerCase() === "websocket"
+        ) {
+          const url = new URL(request.url);
+          if (!this.options.websocketRegistry.hasGateway(url.pathname)) {
+            return new Response("WebSocket gateway not found", { status: 404 });
+          }
+          const upgraded = server.upgrade(request, {
+            data: { path: url.pathname },
+          });
+          if (upgraded) {
+            return undefined;
+          }
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+
+        const context = new Context(request);
+        return this.options.fetch(context);
+      },
+      websocket: {
+        open: (ws) => {
+          this.options.websocketRegistry?.handleOpen(ws);
+        },
+        message: (ws, message) => {
+          this.options.websocketRegistry?.handleMessage(ws, message);
+        },
+        close: (ws, code, reason) => {
+          this.options.websocketRegistry?.handleClose(ws, code, reason);
+        },
+      },
+    });
+
+    const hostname = this.options.hostname ?? "localhost";
+    const port = this.options.port ?? 3000;
+    logger.info(`Server started at http://${hostname}:${port}`);
+  }
+
+  /**
+   * 停止服务器
+   */
+  public stop(): void {
+    if (this.server) {
+      const logger = LoggerManager.getLogger();
+      this.server.stop();
+      this.server = undefined;
+      logger.info("Server stopped");
+    }
+  }
+
+  /**
+   * 获取服务器实例
+   * @returns Bun Server 实例
+   */
+  public getServer(): Server<WebSocketConnectionData> | undefined {
+    return this.server;
+  }
+
+  /**
+   * 检查服务器是否运行中
+   * @returns 是否运行中
+   */
+  public isRunning(): boolean {
+    return this.server !== undefined;
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,2 @@
+
+export type Constructor<T> = new (...args: any[]) => T;