@dangao/bun-server 2.3.0 → 3.0.1

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/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';
+}

package/src/platform/index.ts

@@ -0,0 +1,20 @@
+export type {
+  PlatformEngine,
+  IPlatform,
+  IFsAdapter,
+  IFileRef,
+  ICryptoAdapter,
+  IHasher,
+  IParserAdapter,
+  IProcessAdapter,
+  IChildProcess,
+  SpawnOptions,
+  IHttpDriver,
+  IServerHandle,
+  IWebSocket,
+  WebSocketHandlers,
+  HttpServeOptions,
+} from './types';
+
+export { resolvePlatform } from './detector';
+export { initRuntime, getRuntime, _resetRuntime } from './runtime';

package/src/platform/node/crypto.ts

@@ -0,0 +1,40 @@
+import { createHmac, createHash } from 'node:crypto';
+import type { ICryptoAdapter, IHasher } from '../types';
+
+class NodeHasher implements IHasher {
+  private data: Buffer = Buffer.alloc(0);
+  private readonly algorithm: string;
+
+  public constructor(algorithm: string) {
+    this.algorithm = algorithm;
+  }
+
+  public update(data: string | Uint8Array | ArrayBuffer): IHasher {
+    if (data instanceof ArrayBuffer) {
+      this.data = Buffer.concat([this.data, Buffer.from(data)]);
+    } else if (typeof data === 'string') {
+      this.data = Buffer.concat([this.data, Buffer.from(data, 'utf-8')]);
+    } else {
+      this.data = Buffer.concat([this.data, Buffer.from(data)]);
+    }
+    return this;
+  }
+
+  public digest(): Uint8Array;
+  public digest(encoding: 'hex' | 'base64' | 'base64url'): string;
+  public digest(encoding?: 'hex' | 'base64' | 'base64url'): Uint8Array | string {
+    const hash = createHash(this.algorithm);
+    hash.update(this.data);
+    if (encoding === 'hex') return hash.digest('hex');
+    if (encoding === 'base64') return hash.digest('base64');
+    if (encoding === 'base64url') return hash.digest('base64url');
+    // node:crypto hash.digest() returns Buffer which extends Uint8Array
+    return hash.digest();
+  }
+}
+
+export const nodeCryptoAdapter: ICryptoAdapter = {
+  createHasher(algorithm: string): IHasher {
+    return new NodeHasher(algorithm);
+  },
+};

package/src/platform/node/fs.ts

@@ -0,0 +1,115 @@
+import { readFile, writeFile, stat } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { glob } from 'node:fs/promises';
+import { Readable } from 'node:stream';
+import { lookup as mimeLookup } from 'mime-types';
+import { extname } from 'node:path';
+import type { IFsAdapter, IFileRef } from '../types';
+
+class NodeFileRef implements IFileRef {
+  private readonly path: string;
+  private _type: string | null = null;
+  private _size: number | null = null;
+
+  public constructor(path: string) {
+    this.path = path;
+  }
+
+  public get type(): string {
+    if (this._type === null) {
+      const ext = extname(this.path).toLowerCase();
+      this._type = (mimeLookup(ext) || 'application/octet-stream') as string;
+    }
+    return this._type;
+  }
+
+  public get size(): number {
+    return this._size ?? 0;
+  }
+
+  public async text(): Promise<string> {
+    const buf = await readFile(this.path);
+    const stats = await stat(this.path).catch(() => null);
+    if (stats) this._size = stats.size;
+    return buf.toString('utf-8');
+  }
+
+  public async bytes(): Promise<Uint8Array> {
+    const buf = await readFile(this.path);
+    const stats = await stat(this.path).catch(() => null);
+    if (stats) this._size = stats.size;
+    return new Uint8Array(buf);
+  }
+
+  public async arrayBuffer(): Promise<ArrayBuffer> {
+    const bytes = await this.bytes();
+    return bytes.buffer as ArrayBuffer;
+  }
+
+  public async exists(): Promise<boolean> {
+    return stat(this.path)
+      .then((s) => { this._size = s.size; return true; })
+      .catch(() => false);
+  }
+
+  public stream(): ReadableStream<Uint8Array> {
+    const nodeStream = createReadStream(this.path);
+    // Convert Node.js Readable to Web ReadableStream
+    return Readable.toWeb(nodeStream) as ReadableStream<Uint8Array>;
+  }
+}
+
+export const nodeFsAdapter: IFsAdapter = {
+  file(path: string): IFileRef {
+    return new NodeFileRef(path);
+  },
+
+  async write(path: string, data: string | Uint8Array | ArrayBuffer): Promise<void> {
+    if (data instanceof ArrayBuffer) {
+      await writeFile(path, Buffer.from(data));
+    } else {
+      await writeFile(path, data as string | Uint8Array);
+    }
+  },
+
+  glob(pattern: string, cwd?: string): string[] {
+    // Use synchronous glob via fast-glob-compatible approach
+    // node:fs/promises glob is async; we use sync approach via readdirSync + pattern matching
+    const results: string[] = [];
+    const base = cwd ?? '.';
+    try {
+      const { globSync } = require('node:fs');
+      if (globSync) {
+        // Node 22.0+ has globSync
+        const matches = globSync(pattern, { cwd: base });
+        return Array.from(matches as string[]);
+      }
+    } catch {
+      // fallback
+    }
+    // Manual fallback: read dir and match with minimatch-style
+    try {
+      const entries = require('node:fs').readdirSync(base, { withFileTypes: true, recursive: true }) as import('node:fs').Dirent[];
+      const regex = patternToRegex(pattern);
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          const name = (entry as any).name as string;
+          if (regex.test(name)) {
+            results.push(name);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return results;
+  },
+};
+
+function patternToRegex(pattern: string): RegExp {
+  const escaped = pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]');
+  return new RegExp(`^${escaped}$`);
+}