@dangao/bun-server 2.2.0 → 3.0.0

package/src/database/db-proxy.ts

@@ -49,10 +49,10 @@ const baseDb = async (
   if (tenantId) {
     const tenantSql = sqlManager.get(tenantId);
     if (tenantSql) {
-      return await tenantSql(strings, ...values);
+      return await (tenantSql as any)(strings, ...values);
     }
   }
-  return await sqlManager.getDefault()(strings, ...values);
+  return await (sqlManager.getDefault() as any)(strings, ...values);
 };
 
 function createDb(tenantId?: string): DbProxy {

package/src/database/orm/transaction-manager.ts

@@ -86,7 +86,7 @@ export class TransactionManager {
     fn: () => Promise<T>,
     options: TransactionOptions = {},
   ): Promise<T> {
-    const reserved = await this.sqlManager.getDefault().reserve();
+    const reserved = await (this.sqlManager.getDefault() as any).reserve();
     try {
       const tenantId = getCurrentSession()?.tenantId ?? 'default';
       return await runWithSession(

package/src/database/sql-manager.ts

@@ -1,24 +1,55 @@
-import { SQL } from 'bun';
-
 import type { BunSQLConfig } from './types';
+import { getRuntime } from '../platform/runtime';
 
+/**
+ * SQL 连接管理器
+ * 在 Bun 平台下使用 Bun.SQL，在 Node.js 平台下使用 postgres/mysql2
+ * 内部自动感知运行时，用户无需关心底层实现
+ */
 export class BunSQLManager {
-  private readonly instances = new Map<string, SQL>();
+  private readonly instances = new Map<string, unknown>();
   private defaultTenantId = 'default';
 
-  public getOrCreate(tenantId: string, config: BunSQLConfig): SQL {
+  public getOrCreate(tenantId: string, config: BunSQLConfig): unknown {
     const existing = this.instances.get(tenantId);
     if (existing) {
       return existing;
     }
 
     const pool = config.pool ?? {};
-    const sql = new SQL(config.url, {
-      max: pool.max ?? 10,
-      idleTimeout: pool.idleTimeout ?? 30,
-      maxLifetime: pool.maxLifetime ?? 0,
-      connectionTimeout: pool.connectionTimeout ?? 30000,
-    });
+    let sql: unknown;
+
+    if (getRuntime().engine === 'bun') {
+      const { SQL } = require('bun') as typeof import('bun');
+      sql = new SQL(config.url, {
+        max: pool.max ?? 10,
+        idleTimeout: pool.idleTimeout ?? 30,
+        maxLifetime: pool.maxLifetime ?? 0,
+        connectionTimeout: pool.connectionTimeout ?? 30000,
+      });
+    } else {
+      // Node.js: detect dialect from URL
+      const url = config.url.toLowerCase();
+      if (url.startsWith('mysql://') || url.startsWith('mysql2://')) {
+        const mysql2 = require('mysql2/promise') as typeof import('mysql2/promise');
+        // Create a pool in Node.js
+        sql = mysql2.createPool({
+          uri: config.url,
+          connectionLimit: pool.max ?? 10,
+          waitForConnections: true,
+        });
+      } else {
+        // postgres (default)
+        const postgres = require('postgres') as typeof import('postgres');
+        sql = postgres(config.url, {
+          max: pool.max ?? 10,
+          idle_timeout: pool.idleTimeout ?? 30,
+          max_lifetime: pool.maxLifetime ?? 0,
+          connect_timeout: (pool.connectionTimeout ?? 30000) / 1000,
+        });
+      }
+    }
+
     this.instances.set(tenantId, sql);
     return sql;
   }
@@ -27,7 +58,7 @@ export class BunSQLManager {
     return this.instances.has(tenantId);
   }
 
-  public get(tenantId: string): SQL | undefined {
+  public get(tenantId: string): unknown {
     return this.instances.get(tenantId);
   }
 
@@ -35,7 +66,7 @@ export class BunSQLManager {
     this.defaultTenantId = tenantId;
   }
 
-  public getDefault(): SQL {
+  public getDefault(): unknown {
     const sql = this.instances.get(this.defaultTenantId);
     if (!sql) {
       throw new Error(
@@ -50,7 +81,11 @@ export class BunSQLManager {
     if (!sql) {
       return;
     }
-    await sql.close({ timeout });
+    if (typeof (sql as any).close === 'function') {
+      await (sql as any).close({ timeout });
+    } else if (typeof (sql as any).end === 'function') {
+      await (sql as any).end();
+    }
     this.instances.delete(tenantId);
   }
 

package/src/database/sqlite-adapter.ts

@@ -1,6 +1,5 @@
-import { Database, type SQLQueryBindings } from 'bun:sqlite';
-
 import type { SqliteV2Config } from './types';
+import { getRuntime } from '../platform/runtime';
 
 export interface DisposableLock {
   [Symbol.dispose](): void;
@@ -39,30 +38,64 @@ export class Semaphore {
   }
 }
 
+/**
+ * SQLite 适配器（自动感知运行时）
+ * Bun 平台下使用 bun:sqlite，Node.js 平台下使用 better-sqlite3
+ */
 export class SqliteAdapter {
-  private readonly db: Database;
+  private readonly db: unknown;
   public readonly semaphore: Semaphore;
+  private readonly isBun: boolean;
 
   public constructor(config: SqliteV2Config) {
-    this.db = new Database(config.database);
-    if (config.wal !== false) {
-      this.db.exec('PRAGMA journal_mode = WAL;');
+    this.isBun = getRuntime().engine === 'bun';
+
+    if (this.isBun) {
+      const { Database } = require('bun:sqlite') as typeof import('bun:sqlite');
+      const db = new Database(config.database);
+      if (config.wal !== false) {
+        db.exec('PRAGMA journal_mode = WAL;');
+      }
+      this.db = db;
+    } else {
+      const BetterSqlite3 = require('better-sqlite3') as typeof import('better-sqlite3');
+      const db = BetterSqlite3(config.database);
+      if (config.wal !== false) {
+        db.exec('PRAGMA journal_mode = WAL;');
+      }
+      this.db = db;
     }
+
     this.semaphore = new Semaphore(config.maxWriteConcurrency ?? 1);
   }
 
-  public query<T = unknown>(sql: string, params: SQLQueryBindings[] = []): T[] {
-    const stmt = this.db.query(sql);
+  public query<T = unknown>(sql: string, params: unknown[] = []): T[] {
+    if (this.isBun) {
+      const db = this.db as import('bun:sqlite').Database;
+      const stmt = db.query(sql);
+      return stmt.all(...params as Parameters<typeof stmt.all>) as T[];
+    }
+    const db = this.db as import('better-sqlite3').Database;
+    const stmt = db.prepare(sql);
     return stmt.all(...params) as T[];
   }
 
-  public async execute(sql: string, params: SQLQueryBindings[] = []): Promise<void> {
-    const stmt = this.db.query(sql);
-    stmt.run(...params);
+  public async execute(sql: string, params: unknown[] = []): Promise<void> {
+    if (this.isBun) {
+      const db = this.db as import('bun:sqlite').Database;
+      const stmt = db.query(sql);
+      stmt.run(...params as Parameters<typeof stmt.run>);
+    } else {
+      const db = this.db as import('better-sqlite3').Database;
+      const stmt = db.prepare(sql);
+      stmt.run(...params);
+    }
   }
 
   public close(): void {
-    this.db.close();
+    if (typeof (this.db as any).close === 'function') {
+      (this.db as any).close();
+    }
   }
 }
 

package/src/debug/recorder.ts

@@ -110,11 +110,11 @@ export class RequestRecorder {
 
   /**
    * 从 JSONL 内容导入请求记录
-   * 利用 Bun 1.3.7+ 原生 Bun.JSONL.parse() 高性能解析
    * @param content - JSONL 格式文本
    */
   public importFromJsonl(content: string): void {
-    const records = Bun.JSONL.parse(content) as RequestRecord[];
+    const { getRuntime } = require('../platform/runtime') as typeof import('../platform/runtime');
+    const records = getRuntime().parser.parseJSONL(content) as RequestRecord[];
     for (const record of records) {
       if (record.id) {
         const oldRecord = this.buffer[this.writeIndex];
@@ -136,6 +136,7 @@ export class RequestRecorder {
    * @param content - JSONL 格式文本
    */
   public static parseJsonl(content: string): RequestRecord[] {
-    return Bun.JSONL.parse(content) as RequestRecord[];
+    const { getRuntime } = require('../platform/runtime') as typeof import('../platform/runtime');
+    return getRuntime().parser.parseJSONL(content) as RequestRecord[];
   }
 }

package/src/files/static-middleware.ts

@@ -2,6 +2,7 @@ import { join, normalize } from 'node:path';
 import { stat } from 'node:fs/promises';
 
 import type { Middleware } from '../middleware';
+import { getRuntime } from '../platform/runtime';
 
 export interface StaticFileOptions {
   root: string;
@@ -35,8 +36,8 @@ export function createStaticFileMiddleware(options: StaticFileOptions): Middlewa
         return await next();
       }
 
-      const file = Bun.file(filePath);
-      return new Response(file, {
+      const file = getRuntime().fs.file(filePath);
+      return new Response(file.stream(), {
         headers: {
           'Content-Type': file.type || 'application/octet-stream',
         },

package/src/files/storage.ts

@@ -3,6 +3,7 @@ import { constants } from 'node:fs';
 import { join } from 'node:path';
 
 import type { UploadedFileInfo } from './types';
+import { getRuntime } from '../platform/runtime';
 
 export interface SaveFileOptions {
   dest: string;
@@ -51,7 +52,7 @@ export class FileStorage {
       }
     }
 
-    await Bun.write(targetPath, file);
+    await getRuntime().fs.write(targetPath, await file.arrayBuffer());
 
     return {
       fieldName,

package/src/index.ts

@@ -1,4 +1,17 @@
 export { Application, type ApplicationOptions } from './core/application';
+export type {
+  PlatformEngine,
+  IServerHandle,
+  IWebSocket,
+  WebSocketHandlers,
+  IFsAdapter,
+  ICryptoAdapter,
+  IParserAdapter,
+  IProcessAdapter,
+  IHttpDriver,
+  IPlatform,
+} from './platform';
+export { getRuntime, initRuntime, resolvePlatform } from './platform';
 export { applyDecorators } from './core/apply-decorators';
 export { BunServer, type ServerOptions } from './core/server';
 export { ClusterManager, type ClusterOptions, type ClusterMode } from './core/cluster';

package/src/mcp/server.ts

@@ -48,31 +48,22 @@ export class McpServer {
   }
 
   /**
-   * Create an SSE response that keeps the connection open for streaming
-   * This is the SSE transport endpoint
+   * Create an SSE response that keeps the connection open for streaming.
+   *
+   * Heartbeat / keep-alive pings are handled automatically by the framework's
+   * SSE post-processor (`sseKeepAlive`), so this method no longer injects its
+   * own `setInterval`.
    */
   public createSseResponse(): Response {
-    const registry = this.registry;
-    const serverInfo = this.serverInfo;
     const encoder = new TextEncoder();
 
     const stream = new ReadableStream({
       start(controller) {
-        // Send initial server info event
         const initEvent = `event: endpoint\ndata: ${JSON.stringify({
           type: 'endpoint',
           method: 'POST',
         })}\n\n`;
         controller.enqueue(encoder.encode(initEvent));
-
-        // Keep connection alive with periodic pings
-        const pingInterval = setInterval(() => {
-          try {
-            controller.enqueue(encoder.encode(': ping\n\n'));
-          } catch (_error) {
-            clearInterval(pingInterval);
-          }
-        }, 15000);
       },
     });
 
@@ -81,7 +72,7 @@ export class McpServer {
         'Content-Type': 'text/event-stream',
         'Cache-Control': 'no-cache',
         'Connection': 'keep-alive',
-        'X-MCP-Server': `${serverInfo.name}/${serverInfo.version}`,
+        'X-MCP-Server': `${this.serverInfo.name}/${this.serverInfo.version}`,
       },
     });
   }

package/src/middleware/builtin/static-file.ts

@@ -1,14 +1,17 @@
 import { normalize, resolve, sep } from 'path';
 
 import type { Middleware } from '../middleware';
-import type { HeadersInit } from 'bun'
+import { getRuntime } from '../../platform/runtime';
+
+/** Cross-runtime compatible headers input type */
+type HeadersInput = Headers | string[][] | Record<string, string>;
 
 export interface StaticFileOptions {
   root: string;
   prefix?: string;
   indexFile?: string;
   enableCache?: boolean;
-  headers?: HeadersInit | Headers;
+  headers?: HeadersInput;
 }
 
 function isSubPath(root: string, target: string): boolean {
@@ -65,12 +68,12 @@ export function createStaticFileMiddleware(options: StaticFileOptions): Middlewa
       return context.createErrorResponse({ error: 'Forbidden' });
     }
 
-    const file = Bun.file(targetPath);
+    const file = getRuntime().fs.file(targetPath);
     if (!(await file.exists())) {
       return await next();
     }
 
-    const headers = new Headers(options.headers);
+    const headers = new Headers(options.headers as HeadersInput);
     if (enableCache) {
       headers.set('Cache-Control', 'public, max-age=31536000, immutable');
     }
@@ -78,7 +81,7 @@ export function createStaticFileMiddleware(options: StaticFileOptions): Middlewa
       headers.set('Content-Type', file.type);
     }
 
-    return new Response(file, {
+    return new Response(file.stream(), {
       status: 200,
       headers,
     });

package/src/platform/bun/crypto.ts

@@ -0,0 +1,30 @@
+import type { ICryptoAdapter, IHasher } from '../types';
+
+class BunHasher implements IHasher {
+  private readonly hasher: Bun.CryptoHasher;
+
+  public constructor(algorithm: string) {
+    this.hasher = new Bun.CryptoHasher(algorithm as any);
+  }
+
+  public update(data: string | Uint8Array | ArrayBuffer): IHasher {
+    this.hasher.update(data as Parameters<Bun.CryptoHasher['update']>[0]);
+    return this;
+  }
+
+  public digest(): Uint8Array;
+  public digest(encoding: 'hex' | 'base64' | 'base64url'): string;
+  public digest(encoding?: 'hex' | 'base64' | 'base64url'): Uint8Array | string {
+    if (encoding) {
+      return this.hasher.digest(encoding) as string;
+    }
+    // Bun.CryptoHasher.digest() returns Buffer which extends Uint8Array
+    return this.hasher.digest() as unknown as Uint8Array;
+  }
+}
+
+export const bunCryptoAdapter: ICryptoAdapter = {
+  createHasher(algorithm: string): IHasher {
+    return new BunHasher(algorithm);
+  },
+};

package/src/platform/bun/fs.ts

@@ -0,0 +1,52 @@
+import type { IFsAdapter, IFileRef } from '../types';
+
+class BunFileRef implements IFileRef {
+  private readonly bunFile: ReturnType<typeof Bun.file>;
+
+  public constructor(bunFile: ReturnType<typeof Bun.file>) {
+    this.bunFile = bunFile;
+  }
+
+  public get type(): string {
+    return this.bunFile.type;
+  }
+
+  public get size(): number {
+    return this.bunFile.size;
+  }
+
+  public text(): Promise<string> {
+    return this.bunFile.text();
+  }
+
+  public bytes(): Promise<Uint8Array> {
+    return this.bunFile.bytes();
+  }
+
+  public arrayBuffer(): Promise<ArrayBuffer> {
+    return this.bunFile.arrayBuffer();
+  }
+
+  public exists(): Promise<boolean> {
+    return this.bunFile.exists();
+  }
+
+  public stream(): ReadableStream<Uint8Array> {
+    return this.bunFile.stream() as ReadableStream<Uint8Array>;
+  }
+}
+
+export const bunFsAdapter: IFsAdapter = {
+  file(path: string): IFileRef {
+    return new BunFileRef(Bun.file(path));
+  },
+
+  async write(path: string, data: string | Uint8Array | ArrayBuffer): Promise<void> {
+    await Bun.write(path, data as any);
+  },
+
+  glob(pattern: string, cwd?: string): string[] {
+    const g = new Bun.Glob(pattern);
+    return Array.from(g.scanSync(cwd ?? '.'));
+  },
+};

package/src/platform/bun/http.ts

@@ -0,0 +1,106 @@
+import type { IHttpDriver, IServerHandle, HttpServeOptions, IWebSocket, WebSocketHandlers } from '../types';
+
+/**
+ * Bun ServerWebSocket 的 IWebSocket 包装
+ */
+export class BunWebSocket<T> implements IWebSocket<T> {
+  public constructor(private readonly ws: import('bun').ServerWebSocket<T>) {}
+
+  public get data(): T {
+    return this.ws.data;
+  }
+
+  public get readyState(): number {
+    return this.ws.readyState;
+  }
+
+  public send(data: string | Buffer | Uint8Array): void {
+    this.ws.send(data as string);
+  }
+
+  public close(code?: number, reason?: string): void {
+    this.ws.close(code, reason);
+  }
+
+  public getNative(): import('bun').ServerWebSocket<T> {
+    return this.ws;
+  }
+}
+
+class BunServerHandle implements IServerHandle {
+  public constructor(private readonly server: import('bun').Server<unknown>) {}
+
+  public get port(): number {
+    return this.server.port ?? 0;
+  }
+
+  public get hostname(): string | undefined {
+    return this.server.hostname ?? undefined;
+  }
+
+  public stop(): void {
+    this.server.stop();
+  }
+
+  public upgrade(request: Request, options?: { data?: unknown }): boolean {
+    return this.server.upgrade(request, options as any);
+  }
+
+  public timeout(request: Request, seconds: number): void {
+    this.server.timeout(request, seconds);
+  }
+
+  public getNative(): unknown {
+    return this.server;
+  }
+}
+
+function buildWebSocketHandlers<T>(
+  handlers?: WebSocketHandlers<T>,
+): import('bun').WebSocketHandler<T> | undefined {
+  if (!handlers) return undefined;
+
+  return {
+    open: handlers.open
+      ? (ws) => handlers.open!(new BunWebSocket(ws) as IWebSocket<T>)
+      : undefined,
+    message: handlers.message
+      ? (ws, msg) => handlers.message!(new BunWebSocket(ws) as IWebSocket<T>, msg as string | Buffer)
+      : undefined,
+    close: handlers.close
+      ? (ws, code, reason) => handlers.close!(new BunWebSocket(ws) as IWebSocket<T>, code, reason)
+      : undefined,
+  } as import('bun').WebSocketHandler<T>;
+}
+
+export const bunHttpAdapter: IHttpDriver = {
+  async serve<T>(options: HttpServeOptions<T>): Promise<IServerHandle> {
+    const wsHandlers = buildWebSocketHandlers(options.websocket);
+
+    const fetchHandler = (request: Request, bunServer: import('bun').Server<unknown>): Response | Promise<Response | undefined> | undefined => {
+      const handle = new BunServerHandle(bunServer);
+      return options.fetch(request, handle);
+    };
+
+    let server: import('bun').Server<unknown>;
+
+    if (options.unix) {
+      server = Bun.serve({
+        unix: options.unix,
+        fetch: fetchHandler,
+        websocket: wsHandlers,
+      } as any);
+    } else {
+      server = Bun.serve({
+        port: options.port ?? 3000,
+        hostname: options.hostname,
+        reusePort: options.reusePort,
+        idleTimeout: options.idleTimeout,
+        fetch: fetchHandler,
+        websocket: wsHandlers,
+      } as any);
+    }
+
+    return new BunServerHandle(server);
+  },
+};

package/src/platform/bun/index.ts

@@ -0,0 +1,17 @@
+import type { IPlatform } from '../types';
+import { bunFsAdapter } from './fs';
+import { bunCryptoAdapter } from './crypto';
+import { bunParserAdapter } from './parser';
+import { bunProcessAdapter } from './process';
+import { bunHttpAdapter } from './http';
+
+export function createBunPlatform(): IPlatform {
+  return {
+    engine: 'bun',
+    fs: bunFsAdapter,
+    crypto: bunCryptoAdapter,
+    parser: bunParserAdapter,
+    process: bunProcessAdapter,
+    http: bunHttpAdapter,
+  };
+}

package/src/platform/bun/parser.ts

@@ -0,0 +1,19 @@
+import type { IParserAdapter } from '../types';
+
+export const bunParserAdapter: IParserAdapter = {
+  parseJSONC(content: string): unknown {
+    return Bun.JSONC.parse(content);
+  },
+
+  parseJSON5(content: string): unknown {
+    return Bun.JSON5.parse(content);
+  },
+
+  parseJSONL(content: string): unknown[] {
+    return Bun.JSONL.parse(content) as unknown[];
+  },
+
+  renderMarkdown(md: string): string {
+    return Bun.markdown.html(md, { headings: true });
+  },
+};

package/src/platform/bun/process.ts

@@ -0,0 +1,37 @@
+import type { IProcessAdapter, IChildProcess, SpawnOptions } from '../types';
+
+class BunChildProcess implements IChildProcess {
+  private readonly child: ReturnType<typeof Bun.spawn>;
+
+  public constructor(child: ReturnType<typeof Bun.spawn>) {
+    this.child = child;
+  }
+
+  public get pid(): number {
+    return this.child.pid;
+  }
+
+  public get exited(): Promise<number | null> {
+    return this.child.exited;
+  }
+
+  public kill(signal?: string | number): void {
+    this.child.kill(signal as Parameters<ReturnType<typeof Bun.spawn>['kill']>[0]);
+  }
+}
+
+export const bunProcessAdapter: IProcessAdapter = {
+  spawn(options: SpawnOptions): IChildProcess {
+    const child = Bun.spawn({
+      cmd: options.cmd,
+      env: options.env as Record<string, string>,
+      stdout: options.stdout ?? 'inherit',
+      stderr: options.stderr ?? 'inherit',
+    });
+    return new BunChildProcess(child);
+  },
+
+  async sleep(ms: number): Promise<void> {
+    await Bun.sleep(ms);
+  },
+};

package/src/platform/detector.ts

@@ -0,0 +1,36 @@
+import type { PlatformEngine } from './types';
+
+/**
+ * 解析运行时平台引擎
+ * 优先级：bootstrap config > CLI arg (--platform=) > env var (BUN_SERVER_PLATFORM) > auto-detect
+ *
+ * @param bootstrapConfig - 应用启动时显式指定的平台（最高优先级）
+ */
+export function resolvePlatform(bootstrapConfig?: PlatformEngine): PlatformEngine {
+  if (bootstrapConfig) {
+    return bootstrapConfig;
+  }
+
+  // CLI arg: --platform=node or --platform=bun
+  for (const arg of process.argv) {
+    if (arg.startsWith('--platform=')) {
+      const value = arg.slice('--platform='.length).trim();
+      if (value === 'node' || value === 'bun') {
+        return value;
+      }
+    }
+  }
+
+  // Env var: BUN_SERVER_PLATFORM=node or BUN_SERVER_PLATFORM=bun
+  const envValue = process.env['BUN_SERVER_PLATFORM'];
+  if (envValue === 'node' || envValue === 'bun') {
+    return envValue;
+  }
+
+  // Auto-detect: check if running inside Bun
+  if (typeof Bun !== 'undefined') {
+    return 'bun';
+  }
+
+  return 'node';
+}