@dangao/bun-server 1.0.0 → 1.0.3

package/src/database/connection-manager.ts

@@ -0,0 +1,239 @@
+import type {
+  ConnectionInfo,
+  ConnectionPoolOptions,
+  ConnectionStatus,
+  DatabaseConfig,
+  DatabaseType,
+} from './types';
+
+import { ConnectionPool } from './connection-pool';
+
+/**
+ * 数据库连接管理器
+ * 负责管理数据库连接池和连接健康检查
+ */
+export class DatabaseConnectionManager {
+  private config: DatabaseConfig;
+  private poolOptions: ConnectionPoolOptions;
+  private pool: ConnectionPool;
+  private currentConnection: unknown | null = null;
+  private status: ConnectionStatus = 'disconnected';
+  private error: string | undefined;
+
+  public constructor(
+    config: DatabaseConfig,
+    poolOptions: ConnectionPoolOptions = {},
+  ) {
+    this.config = config;
+    this.poolOptions = {
+      maxConnections: poolOptions.maxConnections ?? 10,
+      connectionTimeout: poolOptions.connectionTimeout ?? 30000,
+      retryCount: poolOptions.retryCount ?? 3,
+      retryDelay: poolOptions.retryDelay ?? 1000,
+    };
+    this.pool = new ConnectionPool(config, this.poolOptions);
+  }
+
+  /**
+   * 连接数据库（从连接池获取连接）
+   */
+  public async connect(): Promise<void> {
+    if (this.status === 'connected') {
+      return;
+    }
+
+    this.status = 'connecting';
+
+    try {
+      // 从连接池获取连接
+      this.currentConnection = await this.pool.acquire();
+      this.status = 'connected';
+      this.error = undefined;
+    } catch (error) {
+      this.status = 'error';
+      this.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+
+  /**
+   * 断开数据库连接（释放连接回池中）
+   */
+  public async disconnect(): Promise<void> {
+    if (this.status === 'disconnected' || !this.currentConnection) {
+      return;
+    }
+
+    try {
+      // 释放连接回池中
+      this.pool.release(this.currentConnection);
+      this.currentConnection = null;
+      this.status = 'disconnected';
+      this.error = undefined;
+    } catch (error) {
+      this.status = 'error';
+      this.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+
+  /**
+   * 关闭连接池（关闭所有连接）
+   */
+  public async closePool(): Promise<void> {
+    await this.pool.close();
+    this.currentConnection = null;
+    this.status = 'disconnected';
+    this.error = undefined;
+  }
+
+  /**
+   * 检查数据库连接健康状态
+   */
+  public async healthCheck(): Promise<boolean> {
+    if (this.status !== 'connected' || !this.currentConnection) {
+      return false;
+    }
+
+    try {
+      if (this.config.type === 'sqlite') {
+        return await this.healthCheckSqlite(this.currentConnection);
+      } else if (this.config.type === 'postgres') {
+        return await this.healthCheckPostgres(this.currentConnection);
+      } else if (this.config.type === 'mysql') {
+        return await this.healthCheckMysql(this.currentConnection);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 获取连接池统计信息
+   */
+  public getPoolStats() {
+    return this.pool.getPoolStats();
+  }
+
+  /**
+   * 获取连接信息
+   */
+  public getConnectionInfo(): ConnectionInfo {
+    return {
+      status: this.status,
+      type: this.config.type,
+      error: this.error,
+    };
+  }
+
+  /**
+   * 获取原始连接对象
+   */
+  public getConnection(): unknown {
+    return this.currentConnection;
+  }
+
+  /**
+   * 从连接池获取新连接（用于需要独立连接的场景）
+   */
+  public async acquireConnection(): Promise<unknown> {
+    return await this.pool.acquire();
+  }
+
+  /**
+   * 释放连接回池中
+   */
+  public releaseConnection(connection: unknown): void {
+    this.pool.release(connection);
+  }
+
+  /**
+   * 获取数据库类型
+   */
+  public getDatabaseType(): DatabaseType {
+    return this.config.type;
+  }
+
+  /**
+   * SQLite 健康检查
+   */
+  private async healthCheckSqlite(connection: unknown): Promise<boolean> {
+    try {
+      if (
+        connection &&
+        typeof connection === 'object' &&
+        'query' in connection &&
+        typeof connection.query === 'function'
+      ) {
+        // 执行简单的查询来检查连接
+        const db = connection as {
+          query: (sql: string) => {
+            all: () => unknown[];
+          };
+        };
+        db.query('SELECT 1').all();
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * PostgreSQL 健康检查（使用 Bun.SQL）
+   */
+  private async healthCheckPostgres(connection: unknown): Promise<boolean> {
+    try {
+      // Bun.SQL 对象可以作为函数调用（模板字符串）
+      if (connection && typeof connection === 'function') {
+        const result = await (connection as (template: TemplateStringsArray, ...values: unknown[]) => Promise<unknown[]>)`SELECT 1`;
+        return Array.isArray(result) && result.length > 0;
+      }
+      // 或者使用 query 方法（如果存在）
+      if (
+        connection &&
+        typeof connection === 'object' &&
+        'query' in connection &&
+        typeof connection.query === 'function'
+      ) {
+        await (connection as { query: (sql: string) => Promise<unknown> }).query(
+          'SELECT 1',
+        );
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * MySQL 健康检查（使用 Bun.SQL）
+   */
+  private async healthCheckMysql(connection: unknown): Promise<boolean> {
+    try {
+      // Bun.SQL 对象可以作为函数调用（模板字符串）
+      if (connection && typeof connection === 'function') {
+        const result = await (connection as (template: TemplateStringsArray, ...values: unknown[]) => Promise<unknown[]>)`SELECT 1`;
+        return Array.isArray(result) && result.length > 0;
+      }
+      // 或者使用 query 方法（如果存在）
+      if (
+        connection &&
+        typeof connection === 'object' &&
+        'query' in connection &&
+        typeof connection.query === 'function'
+      ) {
+        await (connection as { query: (sql: string) => Promise<unknown> }).query(
+          'SELECT 1',
+        );
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/database/connection-pool.ts

@@ -0,0 +1,322 @@
+import type {
+  ConnectionPoolOptions,
+  DatabaseConfig,
+  DatabaseType,
+} from './types';
+
+/**
+ * 连接池中的连接项
+ */
+interface PoolConnection {
+  /**
+   * 连接对象
+   */
+  connection: unknown;
+  /**
+   * 是否正在使用
+   */
+  inUse: boolean;
+  /**
+   * 创建时间
+   */
+  createdAt: number;
+  /**
+   * 最后使用时间
+   */
+  lastUsedAt: number;
+}
+
+/**
+ * 数据库连接池
+ * 管理数据库连接的创建、复用和销毁
+ */
+export class ConnectionPool {
+  private config: DatabaseConfig;
+  private options: Required<ConnectionPoolOptions>;
+  private connections: PoolConnection[] = [];
+  private pendingConnections: Set<Promise<unknown>> = new Set();
+  private isClosing = false;
+
+  public constructor(
+    config: DatabaseConfig,
+    options: ConnectionPoolOptions = {},
+  ) {
+    this.config = config;
+    this.options = {
+      maxConnections: options.maxConnections ?? 10,
+      connectionTimeout: options.connectionTimeout ?? 30000,
+      retryCount: options.retryCount ?? 3,
+      retryDelay: options.retryDelay ?? 1000,
+    };
+  }
+
+  /**
+   * 获取连接（从池中获取或创建新连接）
+   */
+  public async acquire(): Promise<unknown> {
+    if (this.isClosing) {
+      throw new Error('Connection pool is closing');
+    }
+
+    // 查找空闲连接
+    const idleConnection = this.connections.find((conn) => !conn.inUse);
+    if (idleConnection) {
+      idleConnection.inUse = true;
+      idleConnection.lastUsedAt = Date.now();
+      return idleConnection.connection;
+    }
+
+    // 如果未达到最大连接数，创建新连接
+    if (this.connections.length < this.options.maxConnections) {
+      const connection = await this.createConnection();
+      const poolConnection: PoolConnection = {
+        connection,
+        inUse: true,
+        createdAt: Date.now(),
+        lastUsedAt: Date.now(),
+      };
+      this.connections.push(poolConnection);
+      return connection;
+    }
+
+    // 等待连接可用（简单的轮询等待）
+    return await this.waitForConnection();
+  }
+
+  /**
+   * 释放连接回池中
+   */
+  public release(connection: unknown): void {
+    const poolConnection = this.connections.find(
+      (conn) => conn.connection === connection,
+    );
+    if (poolConnection) {
+      poolConnection.inUse = false;
+      poolConnection.lastUsedAt = Date.now();
+    }
+  }
+
+  /**
+   * 关闭连接池
+   */
+  public async close(): Promise<void> {
+    this.isClosing = true;
+
+    // 等待所有待处理的连接完成
+    await Promise.all(Array.from(this.pendingConnections));
+
+    // 关闭所有连接
+    const closePromises = this.connections.map((poolConnection) =>
+      this.closeConnection(poolConnection.connection),
+    );
+    await Promise.all(closePromises);
+
+    this.connections = [];
+    this.isClosing = false;
+  }
+
+  /**
+   * 获取池状态信息
+   */
+  public getPoolStats(): {
+    total: number;
+    inUse: number;
+    idle: number;
+    maxConnections: number;
+  } {
+    const inUse = this.connections.filter((conn) => conn.inUse).length;
+    return {
+      total: this.connections.length,
+      inUse,
+      idle: this.connections.length - inUse,
+      maxConnections: this.options.maxConnections,
+    };
+  }
+
+  /**
+   * 创建新连接
+   */
+  private async createConnection(): Promise<unknown> {
+    const createPromise = this.createConnectionWithRetry();
+    this.pendingConnections.add(createPromise);
+
+    try {
+      const connection = await createPromise;
+      return connection;
+    } finally {
+      this.pendingConnections.delete(createPromise);
+    }
+  }
+
+  /**
+   * 带重试的连接创建
+   */
+  private async createConnectionWithRetry(): Promise<unknown> {
+    let lastError: Error | undefined;
+
+    for (let i = 0; i <= this.options.retryCount; i++) {
+      try {
+        if (this.config.type === 'sqlite') {
+          return await this.createSqliteConnection(this.config.config);
+        } else if (this.config.type === 'postgres') {
+          return await this.createPostgresConnection(this.config.config);
+        } else if (this.config.type === 'mysql') {
+          return await this.createMysqlConnection(this.config.config);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (i < this.options.retryCount) {
+          await this.sleep(this.options.retryDelay);
+        }
+      }
+    }
+
+    throw lastError ?? new Error('Failed to create database connection');
+  }
+
+  /**
+   * 创建 SQLite 连接
+   */
+  private async createSqliteConnection(
+    config: { path: string },
+  ): Promise<unknown> {
+    // 使用 Bun 原生 SQLite API
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(config.path);
+    return db;
+  }
+
+  /**
+   * 创建 PostgreSQL 连接（使用 Bun.SQL）
+   */
+  private async createPostgresConnection(
+    config: {
+      host: string;
+      port: number;
+      database: string;
+      user: string;
+      password: string;
+      ssl?: boolean;
+    },
+  ): Promise<unknown> {
+    // 使用 Bun.SQL API
+    // Bun.SQL 支持 postgres:// URL
+    const url = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+    const { SQL } = await import('bun');
+    return new SQL(url, {
+      max: 1, // 单个连接（连接池会在外部管理）
+      tls: config.ssl ?? false,
+    });
+  }
+
+  /**
+   * 创建 MySQL 连接（使用 Bun.SQL）
+   */
+  private async createMysqlConnection(
+    config: {
+      host: string;
+      port: number;
+      database: string;
+      user: string;
+      password: string;
+    },
+  ): Promise<unknown> {
+    // 使用 Bun.SQL API
+    // Bun.SQL 支持 mysql:// URL
+    const url = `mysql://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+    const { SQL } = await import('bun');
+    return new SQL(url, {
+      max: 1, // 单个连接（连接池会在外部管理）
+    });
+  }
+
+  /**
+   * 关闭连接
+   */
+  private async closeConnection(connection: unknown): Promise<void> {
+    const dbType = this.config.type;
+    if (dbType === 'sqlite') {
+      await this.closeSqliteConnection(connection);
+    } else if (dbType === 'postgres') {
+      await this.closePostgresConnection(connection);
+    } else if (dbType === 'mysql') {
+      await this.closeMysqlConnection(connection);
+    }
+  }
+
+  /**
+   * 关闭 SQLite 连接
+   */
+  private async closeSqliteConnection(connection: unknown): Promise<void> {
+    if (
+      connection &&
+      typeof connection === 'object' &&
+      'close' in connection &&
+      typeof connection.close === 'function'
+    ) {
+      (connection as { close: () => void }).close();
+    }
+  }
+
+  /**
+   * 关闭 PostgreSQL 连接（Bun.SQL 会自动管理连接）
+   */
+  private async closePostgresConnection(_connection: unknown): Promise<void> {
+    // Bun.SQL 会自动管理连接池，这里不需要手动关闭
+    // 如果需要强制关闭，可以调用 connection.close()
+    if (
+      _connection &&
+      typeof _connection === 'object' &&
+      'close' in _connection &&
+      typeof (_connection as { close: () => void }).close === 'function'
+    ) {
+      (_connection as { close: () => void }).close();
+    }
+  }
+
+  /**
+   * 关闭 MySQL 连接（Bun.SQL 会自动管理连接）
+   */
+  private async closeMysqlConnection(_connection: unknown): Promise<void> {
+    // Bun.SQL 会自动管理连接池，这里不需要手动关闭
+    // 如果需要强制关闭，可以调用 connection.close()
+    if (
+      _connection &&
+      typeof _connection === 'object' &&
+      'close' in _connection &&
+      typeof (_connection as { close: () => void }).close === 'function'
+    ) {
+      (_connection as { close: () => void }).close();
+    }
+  }
+
+  /**
+   * 等待连接可用
+   */
+  private async waitForConnection(): Promise<unknown> {
+    const startTime = Date.now();
+    const timeout = this.options.connectionTimeout;
+
+    while (Date.now() - startTime < timeout) {
+      const idleConnection = this.connections.find((conn) => !conn.inUse);
+      if (idleConnection) {
+        idleConnection.inUse = true;
+        idleConnection.lastUsedAt = Date.now();
+        return idleConnection.connection;
+      }
+
+      await this.sleep(100); // 等待 100ms 后重试
+    }
+
+    throw new Error(
+      `Connection timeout: No available connection within ${timeout}ms`,
+    );
+  }
+
+  /**
+   * 睡眠函数
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/database/database-extension.ts

@@ -0,0 +1,62 @@
+import type { Container } from '../di/container';
+import type { ApplicationExtension } from '../extensions/types';
+
+import { DATABASE_SERVICE_TOKEN } from './types';
+import type { DatabaseService } from './service';
+
+/**
+ * 数据库扩展
+ * 在应用启动时自动初始化数据库连接
+ */
+export class DatabaseExtension implements ApplicationExtension {
+  public register(container: Container): void {
+    // 扩展注册时不初始化，等待应用启动时初始化
+    // 这里只是标记需要初始化
+  }
+
+  /**
+   * 初始化数据库连接
+   * 应该在应用启动时调用
+   */
+  public async initialize(container: Container): Promise<void> {
+    try {
+      const databaseService = container.resolve<DatabaseService>(
+        DATABASE_SERVICE_TOKEN,
+      );
+      await databaseService.initialize();
+    } catch (error) {
+      // 如果 DatabaseService 未注册，忽略错误
+      // 这意味着用户可能没有使用 DatabaseModule
+      if (
+        error instanceof Error &&
+        error.message.includes('Provider not found')
+      ) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 关闭数据库连接
+   * 应该在应用停止时调用
+   */
+  public async close(container: Container): Promise<void> {
+    try {
+      const databaseService = container.resolve<DatabaseService>(
+        DATABASE_SERVICE_TOKEN,
+      );
+      // 关闭连接池（关闭所有连接）
+      await databaseService.closePool();
+    } catch (error) {
+      // 如果 DatabaseService 未注册，忽略错误
+      if (
+        error instanceof Error &&
+        error.message.includes('Provider not found')
+      ) {
+        return;
+      }
+      throw error;
+    }
+  }
+}