@dangao/bun-server 2.0.3 → 2.1.0

package/tests/database/database-module.test.ts

@@ -1,28 +1,26 @@
-import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import { DatabaseModule, DatabaseService, DATABASE_SERVICE_TOKEN } from '../../src/database';
-import { Container } from '../../src/di/container';
-import { ModuleRegistry } from '../../src/di/module-registry';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import {
+  BUN_SQL_MANAGER_TOKEN,
+  DB_TOKEN,
+  DATABASE_OPTIONS_TOKEN,
+  DATABASE_SERVICE_TOKEN,
+  DatabaseModule,
+  SQLITE_MANAGER_TOKEN,
+} from '../../src/database';
 import { MODULE_METADATA_KEY } from '../../src/di/module';
 
-describe('DatabaseModule', () => {
-  let container: Container;
-  let moduleRegistry: ModuleRegistry;
-
+describe('DatabaseModule V2', () => {
   beforeEach(() => {
-    // 清除模块元数据
     Reflect.deleteMetadata(MODULE_METADATA_KEY, DatabaseModule);
-    
-    container = new Container();
-    moduleRegistry = ModuleRegistry.getInstance();
-    moduleRegistry.clear();
   });
 
   afterEach(() => {
-    moduleRegistry.clear();
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DatabaseModule);
   });
 
-  test('should register database service provider', () => {
-    DatabaseModule.forRoot({
+  test('should normalize sqlite legacy config', () => {
+    const normalized = DatabaseModule.normalizeConfig({
       database: {
         type: 'sqlite',
         config: {
@@ -30,72 +28,49 @@ describe('DatabaseModule', () => {
         },
       },
     });
-
-    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule);
-    expect(metadata.providers).toBeDefined();
-    expect(metadata.providers.length).toBeGreaterThan(0);
-    
-    // 检查是否注册了 DATABASE_SERVICE_TOKEN
-    const hasServiceToken = metadata.providers.some(
-      (p: unknown) =>
-        typeof p === 'object' &&
-        p !== null &&
-        'provide' in p &&
-        p.provide === DATABASE_SERVICE_TOKEN,
-    );
-    expect(hasServiceToken).toBe(true);
+    expect(normalized.length).toBe(1);
+    expect(normalized[0]?.config.type).toBe('sqlite');
   });
 
-  test('should register database service instance', () => {
-    DatabaseModule.forRoot({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
+  test('should normalize postgres url config', () => {
+    const normalized = DatabaseModule.normalizeConfig({
+      type: 'postgres',
+      url: 'postgres://user:pass@localhost:5432/db',
+      bunSqlPool: {
+        max: 20,
       },
     });
-
-    moduleRegistry.register(DatabaseModule, container);
-    const service = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
-    
-    expect(service).toBeInstanceOf(DatabaseService);
-    expect(service.getDatabaseType()).toBe('sqlite');
-  });
-
-  test('should export database service', () => {
-    DatabaseModule.forRoot({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
+    expect(normalized[0]?.config.type).toBe('postgres');
+    if (normalized[0]?.config.type === 'postgres') {
+      expect(normalized[0].config.pool?.max).toBe(20);
+    }
+  });
+
+  test('should normalize tenants config', () => {
+    const normalized = DatabaseModule.normalizeConfig({
+      tenants: [
+        {
+          id: 'tenant-a',
+          config: {
+            type: 'postgres',
+            url: 'postgres://u:p@localhost:5432/a',
+          },
         },
-      },
-    });
-
-    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule);
-    expect(metadata.exports).toBeDefined();
-    expect(metadata.exports).toContain(DATABASE_SERVICE_TOKEN);
-    expect(metadata.exports).toContain(DatabaseService);
-  });
-
-  test('should register database extension', () => {
-    DatabaseModule.forRoot({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
+        {
+          id: 'tenant-b',
+          config: {
+            type: 'sqlite',
+            database: ':memory:',
+          },
         },
-      },
+      ],
     });
-
-    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule);
-    expect(metadata.extensions).toBeDefined();
-    expect(metadata.extensions.length).toBe(1);
-    expect(metadata.extensions[0]).toBeDefined();
+    expect(normalized.length).toBe(2);
+    expect(normalized[0]?.tenantId).toBe('tenant-a');
+    expect(normalized[1]?.tenantId).toBe('tenant-b');
   });
 
-  test('should support connection pool options', () => {
+  test('should register v2 providers and middleware', () => {
     DatabaseModule.forRoot({
       database: {
         type: 'sqlite',
@@ -103,282 +78,55 @@ describe('DatabaseModule', () => {
           path: ':memory:',
         },
       },
-      pool: {
-        maxConnections: 20,
-        connectionTimeout: 60000,
-        retryCount: 5,
-        retryDelay: 2000,
-      },
+      defaultStrategy: 'pool',
     });
 
-    moduleRegistry.register(DatabaseModule, container);
-    const service = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
-    
-    expect(service).toBeInstanceOf(DatabaseService);
-  });
-
-  test('should support disabling health check', () => {
-    DatabaseModule.forRoot({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
-      },
-      enableHealthCheck: false,
-    });
-
-    moduleRegistry.register(DatabaseModule, container);
-    const service = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
-    
-    expect(service).toBeInstanceOf(DatabaseService);
-  });
-});
-
-describe('DatabaseService', () => {
-  let service: DatabaseService;
-
-  beforeEach(async () => {
-    service = new DatabaseService({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
-      },
-    });
-    await service.initialize();
-  });
-
-  afterEach(async () => {
-    await service.close();
-  });
-
-  test('should initialize database connection', async () => {
-    const info = service.getConnectionInfo();
-    expect(info.status).toBe('connected');
-    expect(info.type).toBe('sqlite');
-  });
-
-  test('should get database connection', () => {
-    const connection = service.getConnection();
-    expect(connection).toBeDefined();
-    expect(connection).not.toBeNull();
-  });
-
-  test('should get database type', () => {
-    const type = service.getDatabaseType();
-    expect(type).toBe('sqlite');
-  });
-
-  test('should check health status', async () => {
-    const isHealthy = await service.healthCheck();
-    expect(isHealthy).toBe(true);
-  });
-
-  test('should get connection info', () => {
-    const info = service.getConnectionInfo();
-    expect(info).toBeDefined();
-    expect(info.status).toBe('connected');
-    expect(info.type).toBe('sqlite');
-  });
-
-  test('should execute SQL query', () => {
-    // 创建表
-    service.query('CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT)');
-    
-    // 插入数据
-    service.query('INSERT INTO test (name) VALUES (?)', ['test']);
-    
-    // 查询数据（SQLite 返回同步结果）
-    const result = service.query<{ id: number; name: string }>('SELECT * FROM test');
-    
-    expect(result).toBeDefined();
-    expect(Array.isArray(result)).toBe(true);
-    expect(result.length).toBe(1);
-    expect(result[0].name).toBe('test');
-  });
-
-  test('should close database connection', async () => {
-    await service.close();
-    const info = service.getConnectionInfo();
-    expect(info.status).toBe('disconnected');
-  });
-
-  test('should throw error when querying without connection', async () => {
-    await service.close();
-    
-    expect(() => {
-      service.query('SELECT 1');
-    }).toThrow('Database connection is not established');
-  });
-});
-
-describe('ConnectionPool', () => {
-  test('should create connection pool', () => {
-    const { ConnectionPool } = require('../../src/database/connection-pool');
-    const pool = new ConnectionPool(
-      {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
-      },
-      {
-        maxConnections: 5,
-      },
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+    expect(metadata.middlewares).toBeDefined();
+    expect(metadata.middlewares.length).toBeGreaterThan(0);
+
+    const hasDbToken = metadata.providers.some(
+      (provider: unknown) =>
+        typeof provider === 'object' &&
+        provider !== null &&
+        'provide' in provider &&
+        (provider as { provide: unknown }).provide === DB_TOKEN,
     );
-
-    expect(pool).toBeDefined();
-    const stats = pool.getPoolStats();
-    expect(stats.maxConnections).toBe(5);
-    expect(stats.total).toBe(0);
-  });
-
-  test('should acquire and release connections', async () => {
-    const { ConnectionPool } = require('../../src/database/connection-pool');
-    const pool = new ConnectionPool({
-      type: 'sqlite',
-      config: {
-        path: ':memory:',
-      },
-    });
-
-    const connection1 = await pool.acquire();
-    expect(connection1).toBeDefined();
-
-    const stats1 = pool.getPoolStats();
-    expect(stats1.total).toBe(1);
-    expect(stats1.inUse).toBe(1);
-
-    pool.release(connection1);
-    const stats2 = pool.getPoolStats();
-    expect(stats2.inUse).toBe(0);
-
-    await pool.close();
-  });
-
-  test('should limit max connections', async () => {
-    const { ConnectionPool } = require('../../src/database/connection-pool');
-    const pool = new ConnectionPool(
-      {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
-      },
-      {
-        maxConnections: 2,
-      },
+    const hasBunSqlManager = metadata.providers.some(
+      (provider: unknown) =>
+        typeof provider === 'object' &&
+        provider !== null &&
+        'provide' in provider &&
+        (provider as { provide: unknown }).provide === BUN_SQL_MANAGER_TOKEN,
     );
-
-    const conn1 = await pool.acquire();
-    const conn2 = await pool.acquire();
-
-    const stats = pool.getPoolStats();
-    expect(stats.total).toBe(2);
-    expect(stats.inUse).toBe(2);
-
-    pool.release(conn1);
-    pool.release(conn2);
-
-    await pool.close();
-  });
-
-  test('should close pool and all connections', async () => {
-    const { ConnectionPool } = require('../../src/database/connection-pool');
-    const pool = new ConnectionPool({
-      type: 'sqlite',
-      config: {
-        path: ':memory:',
-      },
-    });
-
-    const conn1 = await pool.acquire();
-    const conn2 = await pool.acquire();
-
-    await pool.close();
-
-    const stats = pool.getPoolStats();
-    expect(stats.total).toBe(0);
-  });
-});
-
-describe('DatabaseConnectionManager', () => {
-  test('should connect to SQLite database', async () => {
-    const { DatabaseConnectionManager } = await import('../../src/database/connection-manager');
-    const manager = new DatabaseConnectionManager({
-      type: 'sqlite',
-      config: {
-        path: ':memory:',
-      },
-    });
-
-    await manager.connect();
-    const info = manager.getConnectionInfo();
-    
-    expect(info.status).toBe('connected');
-    expect(info.type).toBe('sqlite');
-    
-    await manager.disconnect();
-  });
-
-  test('should handle connection errors gracefully', async () => {
-    const { DatabaseConnectionManager } = await import('../../src/database/connection-manager');
-    const manager = new DatabaseConnectionManager({
-      type: 'sqlite',
-      config: {
-        path: ':memory:', // 使用内存数据库，应该总是成功
-      },
-    });
-
-    // SQLite 内存数据库应该总是成功连接
-    await manager.connect();
-    
-    const info = manager.getConnectionInfo();
-    expect(info.status).toBe('connected');
-    
-    await manager.disconnect();
-  });
-
-  test('should check health status', async () => {
-    const { DatabaseConnectionManager } = await import('../../src/database/connection-manager');
-    const manager = new DatabaseConnectionManager({
-      type: 'sqlite',
-      config: {
-        path: ':memory:',
-      },
-    });
-
-    await manager.connect();
-    const isHealthy = await manager.healthCheck();
-    
-    expect(isHealthy).toBe(true);
-    
-    await manager.disconnect();
-  });
-
-  test('should get pool stats', async () => {
-    const { DatabaseConnectionManager } = await import('../../src/database/connection-manager');
-    const manager = new DatabaseConnectionManager(
-      {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
-      },
-      {
-        maxConnections: 5,
-      },
+    const hasSqliteManager = metadata.providers.some(
+      (provider: unknown) =>
+        typeof provider === 'object' &&
+        provider !== null &&
+        'provide' in provider &&
+        (provider as { provide: unknown }).provide === SQLITE_MANAGER_TOKEN,
+    );
+    const hasLegacyService = metadata.providers.some(
+      (provider: unknown) =>
+        typeof provider === 'object' &&
+        provider !== null &&
+        'provide' in provider &&
+        (provider as { provide: unknown }).provide === DATABASE_SERVICE_TOKEN,
+    );
+    const hasOptionsToken = metadata.providers.some(
+      (provider: unknown) =>
+        typeof provider === 'object' &&
+        provider !== null &&
+        'provide' in provider &&
+        (provider as { provide: unknown }).provide === DATABASE_OPTIONS_TOKEN,
     );
 
-    await manager.connect();
-    const stats = manager.getPoolStats();
-    
-    expect(stats).toBeDefined();
-    expect(stats.maxConnections).toBe(5);
-    expect(stats.total).toBeGreaterThanOrEqual(1);
-    
-    await manager.disconnect();
+    expect(hasDbToken).toBe(true);
+    expect(hasBunSqlManager).toBe(true);
+    expect(hasSqliteManager).toBe(true);
+    expect(hasLegacyService).toBe(true);
+    expect(hasOptionsToken).toBe(true);
   });
 });

package/tests/database/db-proxy.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'bun:test';
+
+import { db, initDbProxy } from '../../src/database/db-proxy';
+import { runWithSession } from '../../src/database/database-context';
+
+describe('db proxy', () => {
+  test('should fallback to default sql when no session', async () => {
+    const calls: unknown[] = [];
+    const defaultSql = async (
+      strings: TemplateStringsArray,
+      ...values: unknown[]
+    ) => {
+      calls.push([strings.join('?'), ...values]);
+      return [{ ok: true }];
+    };
+    initDbProxy(
+      {
+        getDefault: () => defaultSql,
+      } as any,
+      {
+        runInTransaction: async <T>(fn: () => Promise<T>) => await fn(),
+      } as any,
+    );
+
+    const result = await db`SELECT ${1}`;
+    expect(result).toEqual([{ ok: true }]);
+    expect(calls.length).toBe(1);
+  });
+
+  test('should route to reserved connection in session', async () => {
+    const reservedCalls: unknown[] = [];
+    const reserved = (async (
+      strings: TemplateStringsArray,
+      ...values: unknown[]
+    ) => {
+      reservedCalls.push([strings.join('?'), ...values]);
+      return [{ via: 'reserved' }];
+    }) as any;
+
+    initDbProxy(
+      {
+        getDefault: () => async () => [{ via: 'default' }],
+      } as any,
+      {
+        runInTransaction: async <T>(fn: () => Promise<T>) => await fn(),
+      } as any,
+    );
+
+    const result = await runWithSession(
+      {
+        tenantId: 'default',
+        reserved,
+      },
+      async () => await db`SELECT ${2}`,
+    );
+
+    expect(result).toEqual([{ via: 'reserved' }]);
+    expect(reservedCalls.length).toBe(1);
+  });
+
+  test('should use lazyReserve only once', async () => {
+    let reservedCount = 0;
+    const reserved = (async () => [{ via: 'lazy' }]) as any;
+    reserved.begin = async <T>(fn: () => Promise<T>) => await fn();
+    reserved.release = async () => undefined;
+
+    initDbProxy(
+      {
+        getDefault: () => async () => [{ via: 'default' }],
+      } as any,
+      {
+        runInTransaction: async <T>(fn: () => Promise<T>) => await fn(),
+      } as any,
+    );
+
+    await runWithSession(
+      {
+        tenantId: 'default',
+        lazyReserve: async () => {
+          reservedCount += 1;
+          return reserved;
+        },
+      },
+      async () => {
+        await db`SELECT 1`;
+        await db`SELECT 2`;
+      },
+    );
+
+    expect(reservedCount).toBe(2);
+  });
+});
+

package/tests/database/sql-manager.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'bun:test';
+
+import { BunSQLManager } from '../../src/database/sql-manager';
+
+describe('BunSQLManager', () => {
+  test('should throw when default tenant not initialized', () => {
+    const manager = new BunSQLManager();
+    expect(() => manager.getDefault()).toThrow();
+  });
+
+  test('should create and reuse instance by tenant', () => {
+    const manager = new BunSQLManager();
+    const mockSql = { close: async () => undefined };
+    let created = 0;
+    (manager as any).instances = new Map();
+    const originalGetOrCreate = manager.getOrCreate.bind(manager);
+
+    (manager as any).getOrCreate = (tenantId: string, config: any) => {
+      const existing = (manager as any).instances.get(tenantId);
+      if (existing) {
+        return existing;
+      }
+      created += 1;
+      (manager as any).instances.set(tenantId, mockSql);
+      return mockSql;
+    };
+
+    const a = (manager as any).getOrCreate('t1', {
+      type: 'postgres',
+      url: 'postgres://u:p@localhost:5432/db',
+    });
+    const b = (manager as any).getOrCreate('t1', {
+      type: 'postgres',
+      url: 'postgres://u:p@localhost:5432/db',
+    });
+
+    expect(a).toBe(mockSql);
+    expect(b).toBe(mockSql);
+    expect(created).toBe(1);
+    (manager as any).getOrCreate = originalGetOrCreate;
+  });
+});
+

package/tests/database/sqlite-adapter.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Semaphore, SqliteAdapter } from '../../src/database/sqlite-adapter';
+
+describe('SqliteAdapter', () => {
+  test('should execute query and write', async () => {
+    const adapter = new SqliteAdapter({
+      type: 'sqlite',
+      database: ':memory:',
+      wal: true,
+    });
+
+    await adapter.execute(
+      'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)',
+    );
+    await adapter.execute('INSERT INTO users (name) VALUES (?)', ['alice']);
+
+    const rows = adapter.query<{ id: number; name: string }>(
+      'SELECT * FROM users',
+    );
+    expect(rows.length).toBe(1);
+    expect(rows[0]?.name).toBe('alice');
+
+    adapter.close();
+  });
+});
+
+describe('Semaphore', () => {
+  test('should acquire and release lock', async () => {
+    const semaphore = new Semaphore(1);
+    const lock1 = await semaphore.acquire();
+
+    let acquiredSecond = false;
+    const pending = semaphore.acquire().then((lock2) => {
+      acquiredSecond = true;
+      lock2[Symbol.dispose]();
+    });
+
+    expect(acquiredSecond).toBe(false);
+    lock1[Symbol.dispose]();
+    await pending;
+    expect(acquiredSecond).toBe(true);
+  });
+});
+

package/tests/database/strategy-decorator.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  DbStrategy,
+  Session as DbSession,
+  getDbStrategy,
+} from '../../src/database/strategy-decorator';
+
+describe('DbStrategy decorator', () => {
+  test('should read class level strategy', () => {
+    @DbStrategy('session')
+    class UserController {
+      public list(): void {}
+    }
+
+    expect(getDbStrategy(UserController as any, 'list')).toBe('session');
+  });
+
+  test('should prefer method level strategy', () => {
+    @DbStrategy('pool')
+    class UserController {
+      @DbSession()
+      public list(): void {}
+    }
+
+    expect(getDbStrategy(UserController as any, 'list')).toBe('session');
+  });
+});
+