@dangao/bun-server 2.0.3 → 2.1.0

package/tests/database/transaction.test.ts

@@ -1,237 +1,99 @@
-import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import {
-  Transactional,
-  TransactionManager,
-  Propagation,
-  IsolationLevel,
-  TransactionStatus,
-  TRANSACTION_SERVICE_TOKEN,
-} from '../../src/database/orm';
-import { DatabaseService, DATABASE_SERVICE_TOKEN } from '../../src/database';
-import { Container } from '../../src/di/container';
-
-describe('TransactionManager', () => {
-  let container: Container;
-  let databaseService: DatabaseService;
-  let transactionManager: TransactionManager;
-
-  beforeEach(async () => {
-    container = new Container();
-    databaseService = new DatabaseService({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
-        },
+import { describe, expect, test } from 'bun:test';
+
+import { runWithSession } from '../../src/database/database-context';
+import { BunSQLManager } from '../../src/database/sql-manager';
+import { TransactionManager } from '../../src/database/orm/transaction-manager';
+
+function createReserved() {
+  const calls: string[] = [];
+  const reserved = (async () => [{ ok: true }]) as any;
+  reserved.begin = async <T>(fn: () => Promise<T>) => {
+    calls.push('begin');
+    const result = await fn();
+    calls.push('commit');
+    return result;
+  };
+  reserved.release = async () => {
+    calls.push('release');
+  };
+  return {
+    reserved,
+    calls,
+  };
+}
+
+describe('TransactionManager V2', () => {
+  test('should run transaction in reserved session', async () => {
+    const sqlManager = new BunSQLManager();
+    const manager = new TransactionManager(sqlManager as any);
+    const { reserved, calls } = createReserved();
+
+    const result = await runWithSession(
+      {
+        tenantId: 'default',
+        reserved,
       },
-    });
-    await databaseService.initialize();
-
-    transactionManager = new TransactionManager(databaseService);
-    container.registerInstance(DATABASE_SERVICE_TOKEN, databaseService);
-    container.registerInstance(TRANSACTION_SERVICE_TOKEN, transactionManager);
-
-    // 创建测试表
-    databaseService.query(`
-      CREATE TABLE IF NOT EXISTS test_accounts (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        balance REAL NOT NULL DEFAULT 0
-      )
-    `);
-  });
-
-  afterEach(async () => {
-    await databaseService.closePool();
-  });
-
-  test('should begin and commit transaction', async () => {
-    const context = await transactionManager.beginTransaction();
-    expect(context.status).toBe(TransactionStatus.ACTIVE);
-    expect(context.id).toBeDefined();
-
-    // 插入数据
-    await databaseService.query(
-      'INSERT INTO test_accounts (name, balance) VALUES (?, ?)',
-      ['Alice', 100],
+      async () => await manager.runInTransaction(async () => 'ok'),
     );
 
-    await transactionManager.commitTransaction(context.id);
-
-    // 验证数据已提交
-    const result = databaseService.query('SELECT * FROM test_accounts WHERE name = ?', ['Alice']);
-    expect(Array.isArray(result) ? result.length : 0).toBeGreaterThan(0);
+    expect(result).toBe('ok');
+    expect(calls).toEqual(['begin', 'commit']);
   });
 
-  test('should rollback transaction', async () => {
-    const context = await transactionManager.beginTransaction();
-
-    // 插入数据
-    await databaseService.query(
-      'INSERT INTO test_accounts (name, balance) VALUES (?, ?)',
-      ['Bob', 200],
-    );
-
-    await transactionManager.rollbackTransaction(context.id);
-
-    // 验证数据已回滚
-    const result = databaseService.query('SELECT * FROM test_accounts WHERE name = ?', ['Bob']);
-    expect(Array.isArray(result) ? result.length : 0).toBe(0);
-  });
-
-  test('should create and rollback to savepoint', async () => {
-    const context = await transactionManager.beginTransaction();
-
-    // 插入第一条数据
-    await databaseService.query(
-      'INSERT INTO test_accounts (name, balance) VALUES (?, ?)',
-      ['Charlie', 300],
-    );
-
-    // 创建保存点
-    const savepoint = await transactionManager.createSavepoint(context.id);
-    expect(savepoint).toBeDefined();
-    expect(context.level).toBe(1);
-
-    // 插入第二条数据
-    await databaseService.query(
-      'INSERT INTO test_accounts (name, balance) VALUES (?, ?)',
-      ['David', 400],
+  test('should auto lazy reserve when transaction starts', async () => {
+    const sqlManager = new BunSQLManager();
+    const manager = new TransactionManager(sqlManager as any);
+    const { reserved, calls } = createReserved();
+
+    let reserveCalled = 0;
+    await runWithSession(
+      {
+        tenantId: 'default',
+        lazyReserve: async () => {
+          reserveCalled += 1;
+          return reserved;
+        },
+      },
+      async () => {
+        await manager.runInTransaction(async () => undefined);
+      },
     );
 
-    // 回滚到保存点
-    await transactionManager.rollbackToSavepoint(context.id, savepoint);
-
-    // 提交事务
-    await transactionManager.commitTransaction(context.id);
-
-    // 验证：Charlie 应该存在，David 应该不存在（已回滚）
-    const charlie = databaseService.query('SELECT * FROM test_accounts WHERE name = ?', ['Charlie']);
-    const david = databaseService.query('SELECT * FROM test_accounts WHERE name = ?', ['David']);
-
-    expect(Array.isArray(charlie) ? charlie.length : 0).toBeGreaterThan(0);
-    expect(Array.isArray(david) ? david.length : 0).toBe(0);
+    expect(reserveCalled).toBe(1);
+    expect(calls).toEqual(['begin', 'commit']);
   });
 
-  test('should get current transaction', async () => {
-    expect(transactionManager.hasActiveTransaction()).toBe(false);
-
-    const context = await transactionManager.beginTransaction();
-    expect(transactionManager.hasActiveTransaction()).toBe(true);
-
-    const current = transactionManager.getCurrentTransaction();
-    expect(current).not.toBeNull();
-    expect(current?.id).toBe(context.id);
-
-    await transactionManager.commitTransaction(context.id);
-    expect(transactionManager.hasActiveTransaction()).toBe(false);
-  });
-});
-
-describe('@Transactional Decorator', () => {
-  let container: Container;
-  let databaseService: DatabaseService;
-  let transactionManager: TransactionManager;
-
-  beforeEach(async () => {
-    container = new Container();
-    databaseService = new DatabaseService({
-      database: {
-        type: 'sqlite',
-        config: {
-          path: ':memory:',
+  test('should run nested transaction via savepoint', async () => {
+    const sqlManager = new BunSQLManager();
+    const manager = new TransactionManager(sqlManager as any);
+    const savepointCommands: string[] = [];
+
+    const reserved = (async (
+      strings: TemplateStringsArray,
+      ...values: unknown[]
+    ) => {
+      savepointCommands.push(strings.join('?'));
+      return [];
+    }) as any;
+    reserved.begin = async <T>(fn: () => Promise<T>) => await fn();
+    reserved.release = async () => undefined;
+
+    await runWithSession(
+      {
+        tenantId: 'default',
+        reserved,
+        transaction: {
+          id: 'tx-1',
+          status: 'ACTIVE' as any,
+          level: 0,
+          savepoints: [],
         },
       },
-    });
-    await databaseService.initialize();
-
-    transactionManager = new TransactionManager(databaseService);
-    container.registerInstance(DATABASE_SERVICE_TOKEN, databaseService);
-    container.registerInstance(TRANSACTION_SERVICE_TOKEN, transactionManager);
-
-    // 创建测试表
-    databaseService.query(`
-      CREATE TABLE IF NOT EXISTS test_users (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        email TEXT NOT NULL UNIQUE
-      )
-    `);
-  });
-
-  afterEach(async () => {
-    await databaseService.closePool();
-  });
-
-  test('should apply transaction to method', async () => {
-    class UserService {
-      @Transactional()
-      public async createUser(name: string, email: string): Promise<void> {
-        await databaseService.query(
-          'INSERT INTO test_users (name, email) VALUES (?, ?)',
-          [name, email],
-        );
-      }
-
-      @Transactional({ propagation: Propagation.REQUIRES_NEW })
-      public async createUserInNewTransaction(name: string, email: string): Promise<void> {
-        await databaseService.query(
-          'INSERT INTO test_users (name, email) VALUES (?, ?)',
-          [name, email],
-        );
-      }
-    }
-
-    const service = new UserService();
-    const prototype = UserService.prototype;
-
-    // 使用 TransactionInterceptor 执行方法
-    const { TransactionInterceptor } = await import('../../src/database/orm/transaction-interceptor');
-    await TransactionInterceptor.executeWithTransaction(
-      prototype,
-      'createUser',
-      service.createUser.bind(service),
-      ['Alice', 'alice@example.com'],
-      container,
+      async () => {
+        await manager.runInNestedTransaction(async () => undefined);
+      },
     );
 
-    // 验证数据已提交
-    const result = databaseService.query('SELECT * FROM test_users WHERE name = ?', ['Alice']);
-    expect(Array.isArray(result) ? result.length : 0).toBeGreaterThan(0);
-  });
-
-  test('should rollback on error', async () => {
-    class UserService {
-      @Transactional()
-      public async createUserWithError(name: string, email: string): Promise<void> {
-        await databaseService.query(
-          'INSERT INTO test_users (name, email) VALUES (?, ?)',
-          [name, email],
-        );
-        throw new Error('Test error');
-      }
-    }
-
-    const service = new UserService();
-    const prototype = UserService.prototype;
-
-    const { TransactionInterceptor } = await import('../../src/database/orm/transaction-interceptor');
-
-    try {
-      await TransactionInterceptor.executeWithTransaction(
-        prototype,
-        'createUserWithError',
-        service.createUserWithError.bind(service),
-        ['Bob', 'bob@example.com'],
-        container,
-      );
-      expect(true).toBe(false); // 不应该到达这里
-    } catch (error) {
-      expect(error).toBeInstanceOf(Error);
-    }
-
-    // 验证数据已回滚
-    const result = databaseService.query('SELECT * FROM test_users WHERE name = ?', ['Bob']);
-    expect(Array.isArray(result) ? result.length : 0).toBe(0);
+    expect(savepointCommands.some((item) => item.includes('SAVEPOINT'))).toBe(true);
   });
 });

package/tests/di/lifecycle.test.ts

@@ -136,5 +136,42 @@ describe('Lifecycle Hooks', () => {
       const shutdownEntry = calls.find((c) => c.startsWith('onApplicationShutdown'));
       expect(shutdownEntry).toBeDefined();
     });
+
+    test('should call onModuleInit once for duplicated provider instance', async () => {
+      const calls: string[] = [];
+
+      @Injectable()
+      class SharedService implements OnModuleInit {
+        public onModuleInit(): void {
+          calls.push('init');
+        }
+      }
+
+      const shared = new SharedService();
+
+      @Controller('/dup')
+      class DupController {
+        @GET('/')
+        public get(): string {
+          return 'ok';
+        }
+      }
+
+      @Module({
+        controllers: [DupController],
+        providers: [
+          { provide: SharedService, useValue: shared },
+          { provide: Symbol.for('dup-shared'), useValue: shared },
+        ],
+      })
+      class DupModule {}
+
+      const app = new Application({ port: 0, enableSignalHandlers: false });
+      app.registerModule(DupModule);
+      await app.listen(0);
+      await app.stop();
+
+      expect(calls.length).toBe(1);
+    });
   });
 });

package/tests/error/error-handler.test.ts

@@ -140,6 +140,30 @@ describe('handleError', () => {
       expect(body.error).toBe('Internal Server Error');
     });
 
+    test('should not expose stack field in error response body', async () => {
+      const previousNodeEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+      const context = createContext();
+      const error = new Error('Stack should be hidden from response body');
+      error.stack = 'sensitive stack trace';
+
+      try {
+        const response = await handleError(error, context);
+        const body = await response.json() as {
+          error: string;
+          details?: string;
+          stack?: string;
+        };
+
+        expect(response.status).toBe(500);
+        expect(body.error).toBe('Internal Server Error');
+        expect(body.details).toBe('Stack should be hidden from response body');
+        expect(body.stack).toBeUndefined();
+      } finally {
+        process.env.NODE_ENV = previousNodeEnv;
+      }
+    });
+
     test('should handle string error', async () => {
       const context = createContext();
       const error = 'String error message';

package/tests/microservice/service-registry.test.ts

@@ -30,6 +30,21 @@ describe('ServiceRegistryModule', () => {
       (provider: any) => provider.provide === SERVICE_REGISTRY_TOKEN,
     );
     expect(serviceRegistryProvider).toBeDefined();
+    expect(ServiceRegistryModule.autoRegister).toBe(true);
+  });
+
+  test('should support autoRegister option', () => {
+    ServiceRegistryModule.forRoot({
+      provider: 'nacos',
+      autoRegister: false,
+      nacos: {
+        client: {
+          serverList: ['http://localhost:8848'],
+          namespaceId: 'public',
+        },
+      },
+    });
+    expect(ServiceRegistryModule.autoRegister).toBe(false);
   });
 
   test('should throw error when provider is not supported', () => {

package/tests/router/timeout-decorator.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Context } from '../../src/core/context';
+import { Route } from '../../src/router/route';
+import {
+  IdleTimeout,
+  getIdleTimeout,
+} from '../../src/router/timeout-decorator';
+
+describe('IdleTimeout decorator', () => {
+  test('should get class level timeout', () => {
+    @IdleTimeout(500)
+    class Controller {
+      public list(): void {}
+    }
+    expect(getIdleTimeout(Controller as any, 'list')).toBe(500);
+  });
+
+  test('should prefer method level timeout', () => {
+    @IdleTimeout(500)
+    class Controller {
+      @IdleTimeout(100)
+      public list(): void {}
+    }
+    expect(getIdleTimeout(Controller as any, 'list')).toBe(100);
+  });
+});
+
+describe('Route timeout', () => {
+  test('should throw 408 when route execution times out', async () => {
+    const route = new Route(
+      'GET',
+      '/slow',
+      async () => {
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        return new Response('ok');
+      },
+      [],
+      undefined,
+      undefined,
+      5,
+    );
+
+    const context = new Context(new Request('http://localhost/slow'));
+    await expect(route.execute(context)).rejects.toThrow('Request Timeout');
+  });
+});
+

package/tests/validation/validation.test.ts

@@ -37,6 +37,24 @@ describe('Validation Decorators', () => {
     const metadata = [{ index: 0, rules: [IsOptional(), IsString()] }];
     expect(() => validateParameters([undefined], metadata)).not.toThrow();
   });
+
+  test('IsEmail should accept common valid emails', () => {
+    const metadata = [{ index: 0, rules: [IsEmail()] }];
+    expect(() => validateParameters(['test@example.com'], metadata)).not.toThrow();
+    expect(() => validateParameters(['user.name+tag@sub.example.co'], metadata)).not.toThrow();
+  });
+
+  test('IsEmail should reject invalid or risky inputs', () => {
+    const metadata = [{ index: 0, rules: [IsEmail()] }];
+    const tooLongLocal = `${'a'.repeat(65)}@example.com`;
+    const tooLongEmail = `${'a'.repeat(245)}@ex.com`;
+
+    expect(() => validateParameters(['not-email'], metadata)).toThrow(ValidationError);
+    expect(() => validateParameters(['a..b@example.com'], metadata)).toThrow(ValidationError);
+    expect(() => validateParameters(['a@-example.com'], metadata)).toThrow(ValidationError);
+    expect(() => validateParameters([tooLongLocal], metadata)).toThrow(ValidationError);
+    expect(() => validateParameters([tooLongEmail], metadata)).toThrow(ValidationError);
+  });
 });