@dangao/bun-server 2.3.0 → 3.0.0

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}$`);
+}

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;
+  },
+};