@dangao/bun-server 2.3.0 → 3.0.1

package/src/platform/node/http.ts

@@ -0,0 +1,196 @@
+import { createServer as createHttpServer } from 'node:http';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { IHttpDriver, IServerHandle, HttpServeOptions, IWebSocket, WebSocketHandlers } from '../types';
+
+/**
+ * ws.WebSocket 的 IWebSocket 包装
+ */
+class NodeWebSocket<T> implements IWebSocket<T> {
+  private readonly ws: import('ws').WebSocket;
+  private _data: T;
+
+  public constructor(ws: import('ws').WebSocket, data: T) {
+    this.ws = ws;
+    this._data = data;
+  }
+
+  public get data(): T {
+    return this._data;
+  }
+
+  public get readyState(): number {
+    return this.ws.readyState;
+  }
+
+  public send(data: string | Buffer | Uint8Array): void {
+    this.ws.send(data);
+  }
+
+  public close(code?: number, reason?: string): void {
+    this.ws.close(code, reason);
+  }
+}
+
+class NodeServerHandle implements IServerHandle {
+  private readonly httpServer: import('node:http').Server;
+  private _port: number;
+  private _hostname?: string;
+
+  public constructor(
+    httpServer: import('node:http').Server,
+    port: number,
+    hostname?: string,
+  ) {
+    this.httpServer = httpServer;
+    this._port = port;
+    this._hostname = hostname;
+  }
+
+  public get port(): number {
+    return this._port;
+  }
+
+  public get hostname(): string | undefined {
+    return this._hostname;
+  }
+
+  public stop(): void {
+    this.httpServer.close();
+  }
+
+  public getNative(): unknown {
+    return this.httpServer;
+  }
+}
+
+async function nodeRequestToWebRequest(req: IncomingMessage): Promise<Request> {
+  const host = req.headers.host ?? 'localhost';
+  const url = `http://${host}${req.url ?? '/'}`;
+  const method = req.method ?? 'GET';
+
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(chunk as Buffer);
+  }
+  const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined;
+
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      if (Array.isArray(value)) {
+        for (const v of value) headers.append(key, v);
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+
+  return new Request(url, {
+    method,
+    headers,
+    body: body?.length ? body : undefined,
+  });
+}
+
+function sendWebResponse(res: ServerResponse, webResponse: Response): void {
+  res.statusCode = webResponse.status;
+  webResponse.headers.forEach((value, key) => {
+    res.setHeader(key, value);
+  });
+
+  if (!webResponse.body) {
+    res.end();
+    return;
+  }
+
+  const reader = webResponse.body.getReader();
+  const pump = () => {
+    reader.read().then(({ done, value }) => {
+      if (done) {
+        res.end();
+        return;
+      }
+      res.write(value, pump);
+    }).catch(() => {
+      res.destroy();
+    });
+  };
+  pump();
+}
+
+export const nodeHttpAdapter: IHttpDriver = {
+  async serve<T>(options: HttpServeOptions<T>): Promise<IServerHandle> {
+    // Initialized after listen; the fetch callback only fires after listen completes
+    let serverHandle: NodeServerHandle = null!;
+
+    const httpServer = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+      try {
+        const webRequest = await nodeRequestToWebRequest(req);
+        const response = await options.fetch(webRequest, serverHandle);
+        if (response) {
+          sendWebResponse(res, response);
+        } else {
+          res.statusCode = 404;
+          res.end('Not Found');
+        }
+      } catch (_err) {
+        res.statusCode = 500;
+        res.end('Internal Server Error');
+      }
+    });
+
+    // Mount WebSocket server if handlers provided
+    if (options.websocket) {
+      setupWebSocket(httpServer, options.websocket);
+    }
+
+    const requestedPort = options.port ?? 3000;
+    const hostname = options.hostname;
+
+    // Wait for the server to actually start listening so port 0 gets resolved
+    await new Promise<void>((resolve, reject) => {
+      httpServer.once('error', reject);
+      httpServer.once('listening', resolve);
+      if (hostname) {
+        httpServer.listen(requestedPort, hostname);
+      } else {
+        httpServer.listen(requestedPort);
+      }
+    });
+
+    const addr = httpServer.address() as import('node:net').AddressInfo;
+    serverHandle = new NodeServerHandle(httpServer, addr.port, hostname);
+    return serverHandle;
+  },
+};
+
+function setupWebSocket<T>(
+  httpServer: import('node:http').Server,
+  handlers: WebSocketHandlers<T>,
+): void {
+  const { WebSocketServer } = require('ws') as typeof import('ws');
+  const wss = new WebSocketServer({ noServer: true });
+
+  httpServer.on('upgrade', (request, socket, head) => {
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      const nodeWs = new NodeWebSocket<T>(ws, undefined as unknown as T);
+
+      if (handlers.open) {
+        handlers.open(nodeWs);
+      }
+
+      ws.on('message', (data) => {
+        if (handlers.message) {
+          const msg = data instanceof Buffer ? data : Buffer.from(data as ArrayBuffer);
+          handlers.message(nodeWs, msg);
+        }
+      });
+
+      ws.on('close', (code, reason) => {
+        if (handlers.close) {
+          handlers.close(nodeWs, code, reason.toString());
+        }
+      });
+    });
+  });
+}

package/src/platform/node/index.ts

@@ -0,0 +1,17 @@
+import type { IPlatform } from '../types';
+import { nodeFsAdapter } from './fs';
+import { nodeCryptoAdapter } from './crypto';
+import { nodeParserAdapter } from './parser';
+import { nodeProcessAdapter } from './process';
+import { nodeHttpAdapter } from './http';
+
+export function createNodePlatform(): IPlatform {
+  return {
+    engine: 'node',
+    fs: nodeFsAdapter,
+    crypto: nodeCryptoAdapter,
+    parser: nodeParserAdapter,
+    process: nodeProcessAdapter,
+    http: nodeHttpAdapter,
+  };
+}

package/src/platform/node/parser.ts

@@ -0,0 +1,34 @@
+import type { IParserAdapter } from '../types';
+
+export const nodeParserAdapter: IParserAdapter = {
+  parseJSONC(content: string): unknown {
+    const { parse } = require('jsonc-parser') as typeof import('jsonc-parser');
+    return parse(content);
+  },
+
+  parseJSON5(content: string): unknown {
+    const JSON5 = require('json5') as typeof import('json5');
+    return JSON5.parse(content);
+  },
+
+  parseJSONL(content: string): unknown[] {
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+      .map((line) => JSON.parse(line));
+  },
+
+  renderMarkdown(md: string): string {
+    const { marked } = require('marked') as typeof import('marked');
+    const result = marked(md);
+    if (typeof result === 'string') {
+      return result;
+    }
+    // marked can return a Promise in some configurations — resolve synchronously
+    // by using marked.parseInline which is sync, or fall back to a sync config
+    const { marked: markedSync } = require('marked') as typeof import('marked');
+    markedSync.setOptions({ async: false });
+    return markedSync(md) as string;
+  },
+};

package/src/platform/node/process.ts

@@ -0,0 +1,51 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import type { IProcessAdapter, IChildProcess, SpawnOptions } from '../types';
+
+class NodeChildProcess implements IChildProcess {
+  private readonly child: ReturnType<typeof nodeSpawn>;
+  private readonly _exited: Promise<number | null>;
+
+  public constructor(child: ReturnType<typeof nodeSpawn>) {
+    this.child = child;
+    this._exited = new Promise<number | null>((resolve) => {
+      child.on('exit', (code) => resolve(code));
+    });
+  }
+
+  public get pid(): number {
+    return this.child.pid ?? -1;
+  }
+
+  public get exited(): Promise<number | null> {
+    return this._exited;
+  }
+
+  public kill(signal?: string | number): void {
+    if (typeof signal === 'string') {
+      this.child.kill(signal as NodeJS.Signals);
+    } else if (typeof signal === 'number') {
+      this.child.kill(signal);
+    } else {
+      this.child.kill('SIGTERM');
+    }
+  }
+}
+
+export const nodeProcessAdapter: IProcessAdapter = {
+  spawn(options: SpawnOptions): IChildProcess {
+    const [cmd, ...args] = options.cmd;
+    const child = nodeSpawn(cmd!, args, {
+      env: (options.env ?? process.env) as Record<string, string>,
+      stdio: [
+        'ignore',
+        options.stdout === 'pipe' ? 'pipe' : options.stdout === 'ignore' ? 'ignore' : 'inherit',
+        options.stderr === 'pipe' ? 'pipe' : options.stderr === 'ignore' ? 'ignore' : 'inherit',
+      ],
+    });
+    return new NodeChildProcess(child);
+  },
+
+  async sleep(ms: number): Promise<void> {
+    await new Promise<void>((resolve) => setTimeout(resolve, ms));
+  },
+};

package/src/platform/runtime.ts

@@ -0,0 +1,50 @@
+import type { IPlatform, PlatformEngine } from './types';
+import { resolvePlatform } from './detector';
+
+let _runtime: IPlatform | null = null;
+
+/**
+ * 初始化全局运行时平台
+ * 应在 Application 构造函数中最先调用
+ *
+ * @param engine - 显式指定平台（优先级最高），省略则走优先级检测链
+ */
+export function initRuntime(engine?: PlatformEngine): void {
+  const resolved = resolvePlatform(engine);
+
+  if (_runtime && _runtime.engine === resolved) {
+    return;
+  }
+
+  if (resolved === 'bun') {
+    // 动态导入避免 Node.js 环境下引入 Bun 专属 API
+    const { createBunPlatform } = require('./bun/index');
+    _runtime = createBunPlatform();
+  } else {
+    const { createNodePlatform } = require('./node/index');
+    _runtime = createNodePlatform();
+  }
+}
+
+/**
+ * 获取当前已初始化的平台运行时
+ * 必须在 initRuntime() 调用之后使用
+ */
+export function getRuntime(): IPlatform {
+  if (!_runtime) {
+    throw new Error(
+      '[Platform] Runtime not initialized. ' +
+      'Make sure initRuntime() is called before using getRuntime(). ' +
+      'This is automatically done by new Application(options).',
+    );
+  }
+  return _runtime;
+}
+
+/**
+ * 重置运行时（仅用于测试）
+ * @internal
+ */
+export function _resetRuntime(): void {
+  _runtime = null;
+}

package/src/platform/types.ts

@@ -0,0 +1,150 @@
+/**
+ * 支持的运行时平台标识
+ */
+export type PlatformEngine = 'bun' | 'node';
+
+/**
+ * 文件引用抽象接口（替代 BunFile 的直接使用）
+ */
+export interface IFileRef {
+  readonly type: string;
+  readonly size: number;
+  text(): Promise<string>;
+  bytes(): Promise<Uint8Array>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  exists(): Promise<boolean>;
+  /** 返回可读流，用于 new Response(file.stream(), ...) */
+  stream(): ReadableStream<Uint8Array>;
+}
+
+/**
+ * 文件系统适配器接口
+ */
+export interface IFsAdapter {
+  /** 获取文件引用 */
+  file(path: string): IFileRef;
+  /** 写入文件 */
+  write(path: string, data: string | Uint8Array | ArrayBuffer): Promise<void>;
+  /** 匹配文件列表 */
+  glob(pattern: string, cwd?: string): string[];
+}
+
+/**
+ * 哈希器接口（替代 Bun.CryptoHasher）
+ */
+export interface IHasher {
+  update(data: string | Uint8Array | ArrayBuffer): IHasher;
+  digest(): Uint8Array;
+  digest(encoding: 'hex' | 'base64' | 'base64url'): string;
+}
+
+/**
+ * 加密适配器接口
+ */
+export interface ICryptoAdapter {
+  createHasher(algorithm: string): IHasher;
+}
+
+/**
+ * 解析器适配器接口
+ */
+export interface IParserAdapter {
+  parseJSONC(content: string): unknown;
+  parseJSON5(content: string): unknown;
+  parseJSONL(content: string): unknown[];
+  renderMarkdown(md: string): string;
+}
+
+/**
+ * 子进程接口
+ */
+export interface IChildProcess {
+  readonly pid: number;
+  readonly exited: Promise<number | null>;
+  kill(signal?: string | number): void;
+}
+
+/**
+ * spawn 选项
+ */
+export interface SpawnOptions {
+  cmd: string[];
+  env?: Record<string, string | undefined>;
+  stdout?: 'inherit' | 'pipe' | 'ignore';
+  stderr?: 'inherit' | 'pipe' | 'ignore';
+}
+
+/**
+ * 进程适配器接口
+ */
+export interface IProcessAdapter {
+  spawn(options: SpawnOptions): IChildProcess;
+  sleep(ms: number): Promise<void>;
+}
+
+/**
+ * WebSocket 连接抽象接口（替代 Bun.ServerWebSocket）
+ */
+export interface IWebSocket<T = unknown> {
+  readonly data: T;
+  readonly readyState: number;
+  send(data: string | Buffer | Uint8Array): void;
+  close(code?: number, reason?: string): void;
+}
+
+/**
+ * WebSocket 事件处理器集合
+ */
+export interface WebSocketHandlers<T = unknown> {
+  open?: (ws: IWebSocket<T>) => void | Promise<void>;
+  message?: (ws: IWebSocket<T>, msg: string | Buffer) => void | Promise<void>;
+  close?: (ws: IWebSocket<T>, code: number, reason: string) => void | Promise<void>;
+}
+
+/**
+ * HTTP 服务启动选项
+ */
+export interface HttpServeOptions<T = unknown> {
+  port?: number;
+  hostname?: string;
+  reusePort?: boolean;
+  idleTimeout?: number;
+  /** Unix socket 路径（cluster proxy 模式使用） */
+  unix?: string;
+  fetch: (request: Request, server: IServerHandle) => Response | Promise<Response | undefined> | undefined;
+  websocket?: WebSocketHandlers<T>;
+}
+
+/**
+ * 服务器句柄接口（替代 Bun.Server）
+ */
+export interface IServerHandle {
+  readonly port: number;
+  readonly hostname?: string;
+  stop(): void;
+  /** 升级 WebSocket 连接（Bun 原生升级） */
+  upgrade?(request: Request, options?: { data?: unknown }): boolean;
+  /** 设置连接超时（Bun 专属） */
+  timeout?(request: Request, seconds: number): void;
+  /** 获取底层原生服务器实例（不推荐，类型为 unknown） */
+  getNative(): unknown;
+}
+
+/**
+ * HTTP 驱动适配器接口
+ */
+export interface IHttpDriver {
+  serve<T = unknown>(options: HttpServeOptions<T>): Promise<IServerHandle>;
+}
+
+/**
+ * 平台接口聚合
+ */
+export interface IPlatform {
+  readonly engine: PlatformEngine;
+  readonly fs: IFsAdapter;
+  readonly crypto: ICryptoAdapter;
+  readonly parser: IParserAdapter;
+  readonly process: IProcessAdapter;
+  readonly http: IHttpDriver;
+}

package/src/prompt/stores/file-store.ts

@@ -6,6 +6,7 @@ import type {
 } from '../types';
 import { extractVariables } from '../types';
 import { InMemoryPromptStore } from './memory-store';
+import { getRuntime } from '../../platform/runtime';
 
 export interface FilePromptStoreConfig {
   /** Directory containing JSON prompt files (default: './.prompts') */
@@ -73,7 +74,7 @@ export class FilePromptStore implements PromptStore {
     if (deleted) {
       try {
         const path = `${this.promptsDir}/${id}.json`;
-        await Bun.file(path).exists() && Bun.write(path, ''); // Soft delete (empty file)
+        await getRuntime().fs.file(path).exists() && getRuntime().fs.write(path, ''); // Soft delete (empty file)
       } catch (_error) {
         // ignore
       }
@@ -86,12 +87,12 @@ export class FilePromptStore implements PromptStore {
     this.loaded = true;
 
     try {
-      const glob = new Bun.Glob('*.json');
-      const files = Array.from(glob.scanSync(this.promptsDir));
+      const runtime = getRuntime();
+      const files = runtime.fs.glob('*.json', this.promptsDir);
 
       for (const file of files) {
         try {
-          const content = await Bun.file(`${this.promptsDir}/${file}`).text();
+          const content = await runtime.fs.file(`${this.promptsDir}/${file}`).text();
           if (!content.trim()) continue;
 
           const data = JSON.parse(content) as {
@@ -127,7 +128,7 @@ export class FilePromptStore implements PromptStore {
         null,
         2,
       );
-      await Bun.write(`${this.promptsDir}/${template.id}.json`, content);
+      await getRuntime().fs.write(`${this.promptsDir}/${template.id}.json`, content);
     } catch (_error) {
       // Ignore write errors (e.g., read-only filesystem)
     }

package/src/rag/service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '../di/decorators';
 import { Inject } from '../di/decorators';
+import { getRuntime } from '../platform/runtime';
 import type { EmbeddingService } from '../embedding/service';
 import { EMBEDDING_SERVICE_TOKEN } from '../embedding/types';
 import type { VectorStore } from '../vector-store/types';
@@ -120,7 +121,7 @@ export class RagService {
         return source.content;
 
       case 'file': {
-        const file = Bun.file(source.path);
+        const file = getRuntime().fs.file(source.path);
         return file.text();
       }
 

package/src/request/response.ts

@@ -1,4 +1,7 @@
-import type { BodyInit, HeadersInit } from 'bun';
+import { getRuntime } from '../platform/runtime';
+
+/** Cross-runtime compatible headers input type */
+type HeadersInit = Headers | string[][] | Record<string, string>;
 
 /**
  * 响应封装类
@@ -131,17 +134,17 @@ export class ResponseBuilder {
     }
 
     if (typeof source === 'string') {
-      const file = Bun.file(source);
+      const file = getRuntime().fs.file(source);
       if (!headers.has('Content-Type') && file.type) {
         headers.set('Content-Type', file.type);
       }
-      return new Response(file, {
+      return new Response(file.stream(), {
         status: options.status ?? 200,
         headers,
       });
     }
 
-    return new Response(source as BodyInit, {
+    return new Response(source as any, {
       status: options.status ?? 200,
       headers,
     });

package/src/security/guards/execution-context.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import type { ServerWebSocket } from 'bun';
+import type { IWebSocket } from '../../platform/types';
 import type { Context } from '../../core/context';
 import type { ResponseBuilder } from '../../request/response';
 import type { Constructor } from '../../core/types';
@@ -38,14 +38,14 @@ class HttpArgumentsHostImpl implements HttpArgumentsHost {
  */
 class WsArgumentsHostImpl implements WsArgumentsHost {
   public constructor(
-    private readonly client: ServerWebSocket<unknown>,
+    private readonly client: IWebSocket<unknown>,
     private readonly data: unknown,
   ) {}
 
   /**
    * 获取 WebSocket 客户端
    */
-  public getClient(): ServerWebSocket<unknown> {
+  public getClient(): IWebSocket<unknown> {
     return this.client;
   }
 
@@ -80,7 +80,7 @@ export class ExecutionContextImpl implements ExecutionContext {
    * @param client - WebSocket 客户端
    * @param data - 消息数据
    */
-  public setWsContext(client: ServerWebSocket<unknown>, data: unknown): void {
+  public setWsContext(client: IWebSocket<unknown>, data: unknown): void {
     this.wsHost = new WsArgumentsHostImpl(client, data);
   }
 

package/src/security/guards/types.ts

@@ -1,7 +1,7 @@
 import type { Context } from '../../core/context';
 import type { ResponseBuilder } from '../../request/response';
 import type { Constructor } from '../../core/types';
-import type { ServerWebSocket } from 'bun';
+import type { IWebSocket } from '../../platform/types';
 
 /**
  * 守卫接口
@@ -43,7 +43,7 @@ export interface WsArgumentsHost {
    * 获取 WebSocket 客户端
    * @returns WebSocket 连接对象
    */
-  getClient(): ServerWebSocket<unknown>;
+  getClient(): IWebSocket<unknown>;
 
   /**
    * 获取消息数据

package/src/swagger/generator.ts

@@ -1,6 +1,7 @@
 import type { SwaggerDocument, SwaggerOptions, SwaggerPathItem } from './types';
 import { ControllerRegistry } from '../controller/controller';
 import { getControllerMetadata, getRouteMetadata } from '../controller/metadata';
+import { getRuntime } from '../platform/runtime';
 import {
   getApiTags,
   getApiOperation,
@@ -311,7 +312,7 @@ export class SwaggerGenerator {
    */
   public generateMarkdownHtml(): string {
     const md = this.generateMarkdown();
-    return Bun.markdown.html(md, { headings: true });
+    return getRuntime().parser.renderMarkdown(md);
   }
 
   /**