@dangao/bun-server 2.3.0 → 3.0.0

package/tests/files/static-middleware.test.ts

@@ -1,17 +1,20 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { createStaticFileMiddleware } from '../../src/files/static-middleware';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 describe('Static File Middleware', () => {
   let root: string;
 
   beforeEach(async () => {
     root = await mkdtemp(join(tmpdir(), 'bun-static-'));
-    await Bun.write(join(root, 'hello.txt'), 'hello world');
+    await writeFile(join(root, 'hello.txt'), 'hello world', 'utf-8');
   });
 
   afterEach(async () => {

package/tests/middleware/static-file.test.ts

@@ -1,14 +1,17 @@
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdir, rm } from 'fs/promises';
+import { mkdir, rm, writeFile as fsWriteFile } from 'fs/promises';
 import { join } from 'path';
 
 import { createStaticFileMiddleware } from '../../src/middleware/builtin/static-file';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 const TMP_DIR = join(process.cwd(), 'tmp-static-test');
 
 async function writeFile(path: string, content: string): Promise<void> {
-  await Bun.write(path, content);
+  await fsWriteFile(path, content, 'utf-8');
 }
 
 describe('StaticFileMiddleware', () => {

package/tests/platform/bun/crypto.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runCryptoCases } from '../shared/crypto.cases';
+
+describe('BunCryptoAdapter', () => {
+  initRuntime('bun');
+  runCryptoCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().crypto);
+});

package/tests/platform/bun/database.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime } from '../../../src/platform/runtime';
+import { runDatabaseCases } from '../shared/database.cases';
+
+describe('BunDatabase', () => {
+  initRuntime('bun');
+  runDatabaseCases({ test, expect: expect as any, beforeEach: () => {} }, 'bun');
+});

package/tests/platform/bun/fs.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+describe('BunFsAdapter', () => {
+  initRuntime('bun');
+  runFsCases({ test, expect: expect as any, beforeEach }, () => getRuntime().fs);
+});

package/tests/platform/bun/parser.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runParserCases } from '../shared/parser.cases';
+
+describe('BunParserAdapter', () => {
+  initRuntime('bun');
+  runParserCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().parser);
+});

package/tests/platform/bun/process.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runProcessCases } from '../shared/process.cases';
+
+describe('BunProcessAdapter', () => {
+  initRuntime('bun');
+  runProcessCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().process);
+});

package/tests/platform/bun/websocket.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runWebSocketCases } from '../shared/websocket.cases';
+
+describe('BunWebSocket', () => {
+  initRuntime('bun');
+  runWebSocketCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime());
+});

package/tests/platform/detector.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { resolvePlatform } from '../../src/platform/detector';
+
+describe('resolvePlatform priority chain', () => {
+  const originalArgv = process.argv.slice();
+  const originalEnv = process.env['BUN_SERVER_PLATFORM'];
+
+  afterEach(() => {
+    process.argv.length = 0;
+    for (const arg of originalArgv) process.argv.push(arg);
+    if (originalEnv === undefined) {
+      delete process.env['BUN_SERVER_PLATFORM'];
+    } else {
+      process.env['BUN_SERVER_PLATFORM'] = originalEnv;
+    }
+  });
+
+  test('bootstrap config takes highest priority over CLI arg', () => {
+    process.argv.push('--platform=node');
+    expect(resolvePlatform('bun')).toBe('bun');
+  });
+
+  test('CLI arg --platform=node', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=node');
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('CLI arg --platform=bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=node', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=bun', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'bun';
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('CLI arg takes priority over env var', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('auto-detect returns bun when running in Bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    // We're running in Bun (bun:test), so auto-detect should return 'bun'
+    const result = resolvePlatform();
+    expect(result).toBe('bun');
+  });
+});

package/tests/platform/node/build-smoke.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from 'vitest';
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * 烟雾测试：验证 bun build --target=node 的输出能被 Node.js 原生运行
+ *
+ * 测试流程：
+ * 1. 创建最小化 app fixture
+ * 2. 使用 bun build --target=node 编译
+ * 3. 用 node 运行编译产物
+ * 4. 验证应用启动成功
+ */
+describe('Build Smoke Test (bun build --target=node)', () => {
+  test('compiled output runs on Node.js', async () => {
+    const tmpDir = join(tmpdir(), `build-smoke-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+
+    const outDir = join(tmpDir, 'out');
+    mkdirSync(outDir, { recursive: true });
+
+    // Create a minimal fixture app using the framework
+    const fixturePath = join(tmpDir, 'fixture.ts');
+    const pkgRoot = resolve(__dirname, '../../..');
+
+    writeFileSync(fixturePath, `
+import { Application } from '${pkgRoot}/src/index.ts';
+import { Module } from '${pkgRoot}/src/index.ts';
+
+@Module({})
+class AppModule {}
+
+const app = new Application({ platform: 'node' });
+app.registerModule(AppModule);
+app.listen(0).then(() => {
+  const server = app.getServer()?.getServer();
+  console.log('SMOKE_OK port=' + (server?.port ?? 0));
+  process.exit(0);
+}).catch((err) => {
+  console.error('SMOKE_FAIL', err.message);
+  process.exit(1);
+});
+`);
+
+    const outFile = join(outDir, 'app.cjs');
+
+    // Build with bun
+    const buildResult = await runCommand('bun', [
+      'build',
+      fixturePath,
+      '--target=node',
+      '--outfile=' + outFile,
+      '--format=cjs',
+    ]);
+
+    if (buildResult.exitCode !== 0) {
+      // Build may fail in CI without Bun; skip gracefully
+      console.warn('[build-smoke] bun build failed, skipping test:', buildResult.stderr);
+      return;
+    }
+
+    // Run compiled file with node
+    const nodeResult = await runCommand('node', [outFile], 5000);
+
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+
+    expect(nodeResult.exitCode).toBe(0);
+    expect(nodeResult.stdout).toContain('SMOKE_OK');
+  }, 30000);
+});
+
+function runCommand(
+  cmd: string,
+  args: string[],
+  timeout = 15000,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { timeout });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (d) => { stdout += d.toString(); });
+    child.stderr?.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+    child.on('error', (err) => resolve({ exitCode: 1, stdout, stderr: err.message }));
+  });
+}

package/tests/platform/node/crypto.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runCryptoCases } from '../shared/crypto.cases';
+
+describe('NodeCryptoAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runCryptoCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().crypto);
+});

package/tests/platform/node/database.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runDatabaseCases } from '../shared/database.cases';
+
+describe('NodeDatabase', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runDatabaseCases({ test, expect: expect as any, beforeEach: () => {} }, 'node');
+});

package/tests/platform/node/fs.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect, beforeEach } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+describe('NodeFsAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runFsCases({ test, expect: expect as any, beforeEach }, () => getRuntime().fs);
+});

package/tests/platform/node/parser.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runParserCases } from '../shared/parser.cases';
+
+describe('NodeParserAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runParserCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().parser);
+});

package/tests/platform/node/process.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runProcessCases } from '../shared/process.cases';
+
+describe('NodeProcessAdapter', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runProcessCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().process);
+});

package/tests/platform/node/websocket.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+import { initRuntime, getRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runWebSocketCases } from '../shared/websocket.cases';
+
+describe('NodeWebSocket', () => {
+  _resetRuntime();
+  initRuntime('node');
+  runWebSocketCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime());
+});

package/tests/platform/shared/crypto.cases.ts

@@ -0,0 +1,49 @@
+import type { TestSuite } from './suite';
+import type { ICryptoAdapter } from '../../../src/platform/types';
+
+export function runCryptoCases(suite: TestSuite, getAdapter: () => ICryptoAdapter): void {
+  const { test, expect } = suite;
+
+  test('sha256 hex digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const hex = hasher.digest('hex');
+    // Known sha256('hello')
+    expect(hex).toBe('2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824');
+  });
+
+  test('sha256 base64 digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const b64 = hasher.digest('base64');
+    expect(typeof b64).toBe('string');
+    expect(b64.length).toBeGreaterThan(0);
+  });
+
+  test('sha256 arrayBuffer digest', () => {
+    const adapter = getAdapter();
+    const hasher = adapter.createHasher('sha256');
+    hasher.update('hello');
+    const buf = hasher.digest();
+    // Both Bun and Node return Buffer (extends Uint8Array), not a plain ArrayBuffer
+    expect(buf instanceof Uint8Array).toBe(true);
+    expect(buf.byteLength).toBe(32);
+  });
+
+  test('chaining update calls', () => {
+    const adapter = getAdapter();
+    // sha256('helloworld') should equal updating with 'hello' then 'world' only if same bytes
+    // We simply test that the result is consistent
+    const h1 = adapter.createHasher('sha256');
+    h1.update('hello').update('world');
+    const hex1 = h1.digest('hex');
+
+    const h2 = adapter.createHasher('sha256');
+    h2.update('helloworld');
+    const hex2 = h2.digest('hex');
+
+    expect(hex1).toBe(hex2);
+  });
+}

package/tests/platform/shared/database.cases.ts

@@ -0,0 +1,43 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { TestSuite } from './suite';
+import type { PlatformEngine } from '../../../src/platform/types';
+import { SqliteManager } from '../../../src/database/sqlite-adapter';
+
+export function runDatabaseCases(suite: TestSuite, engine: PlatformEngine): void {
+  const { test, expect } = suite;
+
+  // better-sqlite3 is not supported when running Node-platform tests under Bun runtime
+  const skipBetterSqlite = engine === 'node' && typeof (globalThis as any).Bun !== 'undefined';
+
+  test('SqliteAdapter: create table, insert and query', () => {
+    if (skipBetterSqlite) {
+      // better-sqlite3 is not supported in Bun — this test must run under Node.js
+      console.log('[skip] better-sqlite3 not available in Bun runtime; run with vitest for Node platform');
+      return;
+    }
+    const dbPath = join(tmpdir(), `platform-db-test-${engine}-${Date.now()}.db`);
+    const manager = new SqliteManager();
+    const adapter = manager.getOrCreate('test', { database: dbPath, wal: false });
+
+    adapter.query('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+    adapter.query("INSERT INTO users (name) VALUES ('Alice')");
+    const rows = adapter.query<{ id: number; name: string }>('SELECT * FROM users');
+
+    expect(rows.length).toBeGreaterThanOrEqual(1);
+    expect(rows[0]!.name).toBe('Alice');
+
+    manager.destroy('test');
+  });
+
+  test('SqliteManager.getDefault() throws when not initialized', () => {
+    const manager = new SqliteManager();
+    let threw = false;
+    try {
+      manager.getDefault();
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+}

package/tests/platform/shared/fs.cases.ts

@@ -0,0 +1,82 @@
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync } from 'node:fs';
+import type { TestSuite } from './suite';
+import type { IFsAdapter } from '../../../src/platform/types';
+
+export function runFsCases(suite: TestSuite, getAdapter: () => IFsAdapter): void {
+  const { test, expect, beforeEach } = suite;
+
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `platform-fs-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  test('write and read text', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'hello.txt');
+    await adapter.write(filePath, 'hello world');
+    const content = await adapter.file(filePath).text();
+    expect(content).toBe('hello world');
+  });
+
+  test('write and read bytes', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'bytes.bin');
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    await adapter.write(filePath, data);
+    const result = await adapter.file(filePath).bytes();
+    expect(result[0]).toBe(1);
+    expect(result[4]).toBe(5);
+  });
+
+  test('file.exists() returns true for existing file', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'exists.txt');
+    await adapter.write(filePath, 'content');
+    const exists = await adapter.file(filePath).exists();
+    expect(exists).toBe(true);
+  });
+
+  test('file.exists() returns false for missing file', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'does-not-exist.txt');
+    const exists = await adapter.file(filePath).exists();
+    expect(exists).toBe(false);
+  });
+
+  test('file.type returns MIME type', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'image.png');
+    await adapter.write(filePath, new Uint8Array([0x89, 0x50, 0x4e, 0x47]));
+    const mime = adapter.file(filePath).type;
+    expect(mime).toContain('png');
+  });
+
+  test('stream() produces readable stream with correct content', async () => {
+    const adapter = getAdapter();
+    const filePath = join(tmpDir, 'stream.txt');
+    await adapter.write(filePath, 'stream content');
+    const stream = adapter.file(filePath).stream();
+    const reader = stream.getReader();
+    const chunks: Uint8Array[] = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const combined = Buffer.concat(chunks).toString('utf-8');
+    expect(combined).toBe('stream content');
+  });
+
+  test('glob finds matching files', async () => {
+    const adapter = getAdapter();
+    await adapter.write(join(tmpDir, 'a.json'), '{}');
+    await adapter.write(join(tmpDir, 'b.json'), '{}');
+    await adapter.write(join(tmpDir, 'c.txt'), 'text');
+    const files = adapter.glob('*.json', tmpDir);
+    expect(files.length).toBeGreaterThanOrEqual(2);
+  });
+}

package/tests/platform/shared/parser.cases.ts

@@ -0,0 +1,55 @@
+import type { TestSuite } from './suite';
+import type { IParserAdapter } from '../../../src/platform/types';
+
+export function runParserCases(suite: TestSuite, getAdapter: () => IParserAdapter): void {
+  const { test, expect } = suite;
+
+  test('parseJSONC parses standard JSON', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSONC('{"a": 1, "b": "hello"}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+    expect(result['b']).toBe('hello');
+  });
+
+  test('parseJSONC ignores line comments', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSONC('{\n// comment\n"a": 1}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+  });
+
+  test('parseJSON5 parses JSON5 with trailing commas', () => {
+    const adapter = getAdapter();
+    const result = adapter.parseJSON5('{a: 1, b: "hello",}') as Record<string, unknown>;
+    expect(result['a']).toBe(1);
+  });
+
+  test('parseJSONL parses multiple JSON lines', () => {
+    const adapter = getAdapter();
+    const content = '{"id":1}\n{"id":2}\n{"id":3}';
+    const records = adapter.parseJSONL(content);
+    expect(records.length).toBe(3);
+    expect((records[0] as Record<string, unknown>)['id']).toBe(1);
+    expect((records[2] as Record<string, unknown>)['id']).toBe(3);
+  });
+
+  test('parseJSONL ignores empty lines', () => {
+    const adapter = getAdapter();
+    const content = '{"id":1}\n\n{"id":2}\n';
+    const records = adapter.parseJSONL(content);
+    expect(records.length).toBe(2);
+  });
+
+  test('renderMarkdown converts h1 heading', () => {
+    const adapter = getAdapter();
+    const html = adapter.renderMarkdown('# Hello World');
+    expect(html).toContain('<h1');
+    expect(html).toContain('Hello World');
+  });
+
+  test('renderMarkdown converts bold text', () => {
+    const adapter = getAdapter();
+    const html = adapter.renderMarkdown('**bold**');
+    expect(html).toContain('<strong>');
+    expect(html).toContain('bold');
+  });
+}

package/tests/platform/shared/process.cases.ts

@@ -0,0 +1,26 @@
+import type { TestSuite } from './suite';
+import type { IProcessAdapter } from '../../../src/platform/types';
+
+export function runProcessCases(suite: TestSuite, getAdapter: () => IProcessAdapter): void {
+  const { test, expect } = suite;
+
+  test('sleep waits at least the specified time', async () => {
+    const adapter = getAdapter();
+    const start = Date.now();
+    await adapter.sleep(100);
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(90);
+  });
+
+  test('spawn runs a process and returns exit code 0', async () => {
+    const adapter = getAdapter();
+    const child = adapter.spawn({
+      cmd: ['node', '--version'],
+      stdout: 'pipe',
+      stderr: 'ignore',
+    });
+    expect(child.pid).toBeGreaterThan(0);
+    const exitCode = await child.exited;
+    expect(exitCode).toBe(0);
+  });
+}

package/tests/platform/shared/suite.ts

@@ -0,0 +1,33 @@
+/**
+ * 框架无关的测试套件接口
+ * 让 shared cases 文件在 bun:test 和 vitest 中都能运行，无需任何适配层
+ */
+export interface TestSuite {
+  test: (name: string, fn: () => void | Promise<void>) => void;
+  expect: (actual: unknown) => {
+    toBe(e: unknown): void;
+    toEqual(e: unknown): void;
+    toBeTruthy(): void;
+    toBeFalsy(): void;
+    toContain(e: unknown): void;
+    toBeGreaterThan(e: number): void;
+    toBeGreaterThanOrEqual(e: number): void;
+    toBeLessThan(e: number): void;
+    toBeLessThanOrEqual(e: number): void;
+    toBeInstanceOf(e: unknown): void;
+    toHaveLength(e: number): void;
+    not: {
+      toBe(e: unknown): void;
+      toBeNull(): void;
+      toBeUndefined(): void;
+      toThrow(): void;
+    };
+    resolves: {
+      toBeTruthy(): Promise<void>;
+    };
+    rejects: {
+      toThrow(): Promise<void>;
+    };
+  };
+  beforeEach: (fn: () => void | Promise<void>) => void;
+}