@dangao/bun-server 1.0.0 → 1.0.3

package/tests/database/postgres-mysql-integration.test.ts

@@ -0,0 +1,395 @@
+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 { MODULE_METADATA_KEY } from '../../src/di/module';
+import 'reflect-metadata';
+
+/**
+ * PostgreSQL/MySQL 集成测试
+ * 
+ * 这些测试需要实际的数据库连接，通过环境变量配置：
+ * - POSTGRES_URL: PostgreSQL 连接字符串（可选）
+ * - MYSQL_URL: MySQL 连接字符串（可选）
+ * 
+ * 如果没有配置相应的环境变量，相关测试会被跳过。
+ */
+
+function parseDatabaseUrl(url: string): {
+  type: 'postgres' | 'mysql';
+  host: string;
+  port: number;
+  database: string;
+  user: string;
+  password: string;
+} {
+  const urlObj = new URL(url);
+  return {
+    type: urlObj.protocol === 'postgresql:' || urlObj.protocol === 'postgres:' ? 'postgres' : 'mysql',
+    host: urlObj.hostname,
+    port: Number(urlObj.port) || (urlObj.protocol.includes('postgres') ? 5432 : 3306),
+    database: urlObj.pathname.slice(1),
+    user: urlObj.username,
+    password: urlObj.password,
+  };
+}
+
+describe('PostgreSQL Integration Tests', () => {
+  const postgresUrl = process.env.POSTGRES_URL;
+  const hasPostgres = !!postgresUrl;
+
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+  let dbService: DatabaseService | null = null;
+
+  beforeEach(() => {
+    if (!hasPostgres) {
+      return;
+    }
+
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DatabaseModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  afterEach(async () => {
+    if (dbService) {
+      try {
+        await dbService.closePool();
+      } catch {
+        // Ignore errors during cleanup
+      }
+      dbService = null;
+    }
+    if (moduleRegistry) {
+      moduleRegistry.clear();
+    }
+  });
+
+  test.skipIf(!hasPostgres)('should connect to PostgreSQL database', async () => {
+
+    const config = parseDatabaseUrl(postgresUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'postgres',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    const info = dbService.getConnectionInfo();
+    expect(info.status).toBe('connected');
+    expect(info.type).toBe('postgres');
+  });
+
+  test.skipIf(!hasPostgres)('should execute PostgreSQL queries', async () => {
+
+    const config = parseDatabaseUrl(postgresUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'postgres',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    // 测试查询
+    const result = await dbService.query('SELECT version() as version');
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0]).toHaveProperty('version');
+  });
+
+  test.skipIf(!hasPostgres)('should handle PostgreSQL transactions', async () => {
+
+    const config = parseDatabaseUrl(postgresUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'postgres',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    // 创建测试表
+    await dbService.query(`
+      CREATE TABLE IF NOT EXISTS test_transaction_pg (
+        id SERIAL PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+
+    try {
+      // 开始事务
+      await dbService.query('BEGIN');
+      
+      // 插入数据
+      await dbService.query(
+        "INSERT INTO test_transaction_pg (value) VALUES ('test')",
+      );
+
+      // 回滚事务
+      await dbService.query('ROLLBACK');
+
+      // 验证数据未插入
+      const result = await dbService.query<{ count: number | string }>(
+        "SELECT COUNT(*) as count FROM test_transaction_pg WHERE value = 'test'",
+      );
+      const countValue = Array.isArray(result) && result.length > 0
+        ? result[0]?.count
+        : 0;
+      const count = typeof countValue === 'string' ? parseInt(countValue, 10) : (countValue || 0);
+      expect(count).toBe(0);
+    } finally {
+      // 清理测试表
+      try {
+        await dbService.query('DROP TABLE IF EXISTS test_transaction_pg');
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  test.skipIf(!hasPostgres)('should check PostgreSQL health status', async () => {
+
+    const config = parseDatabaseUrl(postgresUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'postgres',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+      enableHealthCheck: true,
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    const isHealthy = await dbService.healthCheck();
+    expect(isHealthy).toBe(true);
+  });
+});
+
+describe('MySQL Integration Tests', () => {
+  const mysqlUrl = process.env.MYSQL_URL;
+  const hasMysql = !!mysqlUrl;
+
+  let container: Container;
+  let moduleRegistry: ModuleRegistry;
+  let dbService: DatabaseService | null = null;
+
+  beforeEach(() => {
+    if (!hasMysql) {
+      return;
+    }
+
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DatabaseModule);
+    container = new Container();
+    moduleRegistry = ModuleRegistry.getInstance();
+    moduleRegistry.clear();
+  });
+
+  afterEach(async () => {
+    if (dbService) {
+      try {
+        await dbService.closePool();
+      } catch {
+        // Ignore errors during cleanup
+      }
+      dbService = null;
+    }
+    if (moduleRegistry) {
+      moduleRegistry.clear();
+    }
+  });
+
+  test.skipIf(!hasMysql)('should connect to MySQL database', async () => {
+
+    const config = parseDatabaseUrl(mysqlUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'mysql',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    const info = dbService.getConnectionInfo();
+    expect(info.status).toBe('connected');
+    expect(info.type).toBe('mysql');
+  });
+
+  test.skipIf(!hasMysql)('should execute MySQL queries', async () => {
+
+    const config = parseDatabaseUrl(mysqlUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'mysql',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    // 测试查询
+    const result = await dbService.query('SELECT VERSION() as version');
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0]).toHaveProperty('version');
+  });
+
+  test.skipIf(!hasMysql)('should handle MySQL transactions', async () => {
+
+    const config = parseDatabaseUrl(mysqlUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'mysql',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    // 创建测试表
+    await dbService.query(`
+      CREATE TABLE IF NOT EXISTS test_transaction_mysql (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+
+    try {
+      // 开始事务
+      await dbService.query('START TRANSACTION');
+      
+      // 插入数据
+      await dbService.query(
+        "INSERT INTO test_transaction_mysql (value) VALUES ('test')",
+      );
+
+      // 回滚事务
+      await dbService.query('ROLLBACK');
+
+      // 验证数据未插入
+      const result = await dbService.query<{ count: number | string }>(
+        "SELECT COUNT(*) as count FROM test_transaction_mysql WHERE value = 'test'",
+      );
+      const countValue = Array.isArray(result) && result.length > 0
+        ? result[0]?.count
+        : 0;
+      const count = typeof countValue === 'string' ? parseInt(countValue, 10) : (countValue || 0);
+      expect(count).toBe(0);
+    } finally {
+      // 清理测试表
+      try {
+        await dbService.query('DROP TABLE IF EXISTS test_transaction_mysql');
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  test.skipIf(!hasMysql)('should check MySQL health status', async () => {
+
+    const config = parseDatabaseUrl(mysqlUrl!);
+
+    DatabaseModule.forRoot({
+      database: {
+        type: 'mysql',
+        config: {
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+        },
+      },
+      enableHealthCheck: true,
+    });
+
+    moduleRegistry.register(DatabaseModule, container);
+    dbService = container.resolve<DatabaseService>(DATABASE_SERVICE_TOKEN);
+
+    await dbService.initialize();
+
+    const isHealthy = await dbService.healthCheck();
+    expect(isHealthy).toBe(true);
+  });
+});

package/tests/database/transaction.test.ts

@@ -0,0 +1,238 @@
+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';
+import 'reflect-metadata';
+
+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:',
+        },
+      },
+    });
+    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],
+    );
+
+    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);
+  });
+
+  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],
+    );
+
+    // 回滚到保存点
+    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);
+  });
+
+  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:',
+        },
+      },
+    });
+    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,
+    );
+
+    // 验证数据已提交
+    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);
+  });
+});