@dangao/bun-server 1.0.0 → 1.0.3

package/src/database/orm/types.ts

@@ -0,0 +1,99 @@
+import type { DatabaseService } from '../service';
+
+/**
+ * ORM 配置选项
+ */
+export interface OrmModuleOptions {
+  /**
+   * 是否启用 ORM
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Drizzle 数据库实例（如果使用 Drizzle ORM）
+   */
+  drizzle?: unknown;
+  /**
+   * 数据库服务（用于创建 Drizzle 实例）
+   */
+  databaseService?: DatabaseService;
+}
+
+/**
+ * Repository 基类接口
+ */
+export interface BaseRepository<T = unknown> {
+  /**
+   * 查找所有记录
+   */
+  findAll(): Promise<T[]>;
+  /**
+   * 根据 ID 查找记录
+   */
+  findById(id: string | number): Promise<T | null>;
+  /**
+   * 创建记录
+   */
+  create(data: Partial<T>): Promise<T>;
+  /**
+   * 更新记录
+   */
+  update(id: string | number, data: Partial<T>): Promise<T>;
+  /**
+   * 删除记录
+   */
+  delete(id: string | number): Promise<boolean>;
+}
+
+/**
+ * Entity 元数据
+ */
+export interface EntityMetadata {
+  /**
+   * 表名
+   */
+  tableName: string;
+  /**
+   * 主键字段名
+   */
+  primaryKey?: string;
+  /**
+   * 字段元数据
+   */
+  columns: ColumnMetadata[];
+}
+
+/**
+ * 列元数据
+ */
+export interface ColumnMetadata {
+  /**
+   * 字段名
+   */
+  name: string;
+  /**
+   * 字段类型
+   */
+  type: string;
+  /**
+   * 是否为主键
+   */
+  primaryKey?: boolean;
+  /**
+   * 是否自动递增
+   */
+  autoIncrement?: boolean;
+  /**
+   * 是否可为空
+   */
+  nullable?: boolean;
+  /**
+   * 默认值
+   */
+  defaultValue?: unknown;
+}
+
+/**
+ * ORM Service Token
+ */
+export const ORM_SERVICE_TOKEN = Symbol('@dangao/bun-server:orm:service');

package/src/database/service.ts

@@ -0,0 +1,221 @@
+import { Injectable } from '../di/decorators';
+
+import { DatabaseConnectionManager } from './connection-manager';
+import type {
+  ConnectionInfo,
+  DatabaseConfig,
+  DatabaseModuleOptions,
+} from './types';
+
+/**
+ * 数据库服务
+ * 提供数据库连接管理和查询接口
+ */
+@Injectable()
+export class DatabaseService {
+  private connectionManager: DatabaseConnectionManager;
+  private options: DatabaseModuleOptions;
+
+  public constructor(options: DatabaseModuleOptions) {
+    this.options = options;
+    this.connectionManager = new DatabaseConnectionManager(
+      options.database,
+      options.pool,
+    );
+  }
+
+  /**
+   * 初始化数据库连接
+   */
+  public async initialize(): Promise<void> {
+    await this.connectionManager.connect();
+  }
+
+  /**
+   * 关闭数据库连接（释放回池中）
+   */
+  public async close(): Promise<void> {
+    await this.connectionManager.disconnect();
+  }
+
+  /**
+   * 关闭连接池（关闭所有连接）
+   */
+  public async closePool(): Promise<void> {
+    await this.connectionManager.closePool();
+  }
+
+  /**
+   * 获取连接池统计信息
+   */
+  public getPoolStats() {
+    return this.connectionManager.getPoolStats();
+  }
+
+  /**
+   * 获取数据库连接
+   */
+  public getConnection(): unknown {
+    return this.connectionManager.getConnection();
+  }
+
+  /**
+   * 获取配置（供 TransactionManager 使用）
+   */
+  public get config(): DatabaseModuleOptions {
+    return this.options;
+  }
+
+  /**
+   * 获取数据库类型
+   */
+  public getDatabaseType(): DatabaseConfig['type'] {
+    return this.connectionManager.getDatabaseType();
+  }
+
+  /**
+   * 检查数据库连接健康状态
+   */
+  public async healthCheck(): Promise<boolean> {
+    if (!this.options.enableHealthCheck) {
+      return true;
+    }
+
+    return await this.connectionManager.healthCheck();
+  }
+
+  /**
+   * 获取连接信息
+   */
+  public getConnectionInfo(): ConnectionInfo {
+    return this.connectionManager.getConnectionInfo();
+  }
+
+  /**
+   * 执行 SQL 查询
+   * SQLite 返回同步结果，PostgreSQL/MySQL 返回异步结果
+   */
+  public query<T = unknown>(sql: string, params?: unknown[]): T[] | Promise<T[]> {
+    const connection = this.getConnection();
+    if (!connection) {
+      throw new Error('Database connection is not established');
+    }
+
+    const dbType = this.getDatabaseType();
+    if (dbType === 'sqlite') {
+      return this.querySqlite(connection, sql, params);
+    } else if (dbType === 'postgres' || dbType === 'mysql') {
+      return this.queryBunSQL(connection, sql, params);
+    }
+
+    throw new Error(`Query not supported for database type: ${dbType}`);
+  }
+
+  /**
+   * SQLite 查询实现
+   */
+  private querySqlite<T = unknown>(
+    connection: unknown,
+    sql: string,
+    params?: unknown[],
+  ): T[] {
+    // Bun SQLite Database 对象
+    if (
+      connection &&
+      typeof connection === 'object' &&
+      'query' in connection &&
+      typeof connection.query === 'function'
+    ) {
+      const db = connection as {
+        query: (sql: string) => {
+          all: (...params: unknown[]) => T[];
+          get: (...params: unknown[]) => T | undefined;
+        };
+      };
+
+      const statement = db.query(sql);
+      // Bun SQLite 的 all() 方法接受参数
+      const result =
+        params && params.length > 0 ? statement.all(...params) : statement.all();
+      return result;
+    }
+
+    throw new Error('Invalid SQLite connection');
+  }
+
+  /**
+   * Bun.SQL 查询实现（PostgreSQL/MySQL）
+   * 注意：Bun.SQL 主要使用模板字符串，但为了兼容性，我们尝试支持参数化查询
+   */
+  private async queryBunSQL<T = unknown>(
+    connection: unknown,
+    sql: string,
+    params?: unknown[],
+  ): Promise<T[]> {
+    // Bun.SQL 对象可以作为函数调用（模板字符串）
+    // 但我们需要支持参数化查询
+    if (connection && typeof connection === 'function') {
+      // Bun.SQL 模板字符串查询
+      // 注意：Bun.SQL 使用模板字符串，参数会自动转义
+      // 这里我们需要将 SQL 和参数组合成模板字符串调用
+      // 但由于 TypeScript 限制，我们使用动态调用
+      try {
+        // 尝试使用模板字符串方式
+        // 注意：这需要将参数插入到 SQL 中，但 Bun.SQL 会自动处理 SQL 注入防护
+        const sqlWithParams = this.interpolateParams(sql, params);
+        const result = await (connection as (
+          template: TemplateStringsArray,
+          ...values: unknown[]
+        ) => Promise<Array<Record<string, unknown>>>)`${sqlWithParams}`;
+        return result as T[];
+      } catch {
+        // 如果模板字符串方式失败，尝试其他方式
+        throw new Error(
+          'Bun.SQL parameterized queries are not fully supported. Consider using template string queries.',
+        );
+      }
+    }
+
+    // 尝试使用 query 方法（如果存在）
+    if (
+      connection &&
+      typeof connection === 'object' &&
+      'query' in connection &&
+      typeof connection.query === 'function'
+    ) {
+      const db = connection as {
+        query: (
+          sql: string,
+          ...params: unknown[]
+        ) => Promise<Array<Record<string, unknown>>>;
+      };
+      const result = await db.query(sql, ...(params ?? []));
+      return result as T[];
+    }
+
+    throw new Error('Invalid Bun.SQL connection');
+  }
+
+  /**
+   * 将参数插入到 SQL 中（用于 Bun.SQL 模板字符串）
+   * 注意：这只是临时方案，Bun.SQL 的模板字符串会自动处理 SQL 注入防护
+   */
+  private interpolateParams(sql: string, params?: unknown[]): string {
+    if (!params || params.length === 0) {
+      return sql;
+    }
+
+    // 简单的参数替换（实际应该使用 Bun.SQL 的模板字符串）
+    // 这里只是占位实现，实际使用时应该使用模板字符串
+    let result = sql;
+    for (let i = 0; i < params.length; i++) {
+      const param = params[i];
+      const value =
+        typeof param === 'string'
+          ? `'${param.replace(/'/g, "''")}'`
+          : String(param);
+      result = result.replace('?', value);
+    }
+    return result;
+  }
+}

package/src/database/types.ts

@@ -0,0 +1,171 @@
+/**
+ * 数据库类型
+ */
+export type DatabaseType = 'sqlite' | 'postgres' | 'mysql';
+
+/**
+ * SQLite 配置
+ */
+export interface SqliteConfig {
+  /**
+   * 数据库文件路径（相对或绝对路径）
+   * 例如：':memory:' 表示内存数据库，'./data.db' 表示文件数据库
+   */
+  path: string;
+}
+
+/**
+ * PostgreSQL 配置
+ */
+export interface PostgresConfig {
+  /**
+   * 数据库主机
+   */
+  host: string;
+  /**
+   * 数据库端口
+   */
+  port: number;
+  /**
+   * 数据库名称
+   */
+  database: string;
+  /**
+   * 用户名
+   */
+  user: string;
+  /**
+   * 密码
+   */
+  password: string;
+  /**
+   * SSL 配置（可选）
+   */
+  ssl?: boolean;
+}
+
+/**
+ * MySQL 配置
+ */
+export interface MysqlConfig {
+  /**
+   * 数据库主机
+   */
+  host: string;
+  /**
+   * 数据库端口
+   */
+  port: number;
+  /**
+   * 数据库名称
+   */
+  database: string;
+  /**
+   * 用户名
+   */
+  user: string;
+  /**
+   * 密码
+   */
+  password: string;
+}
+
+/**
+ * 数据库配置（联合类型）
+ */
+export type DatabaseConfig =
+  | { type: 'sqlite'; config: SqliteConfig }
+  | { type: 'postgres'; config: PostgresConfig }
+  | { type: 'mysql'; config: MysqlConfig };
+
+/**
+ * 连接池配置
+ */
+export interface ConnectionPoolOptions {
+  /**
+   * 最大连接数
+   * @default 10
+   */
+  maxConnections?: number;
+  /**
+   * 连接超时时间（毫秒）
+   * @default 30000
+   */
+  connectionTimeout?: number;
+  /**
+   * 连接重试次数
+   * @default 3
+   */
+  retryCount?: number;
+  /**
+   * 重试延迟（毫秒）
+   * @default 1000
+   */
+  retryDelay?: number;
+}
+
+/**
+ * DatabaseModule 配置选项
+ */
+export interface DatabaseModuleOptions {
+  /**
+   * 数据库配置
+   */
+  database: DatabaseConfig;
+  /**
+   * 连接池配置
+   */
+  pool?: ConnectionPoolOptions;
+  /**
+   * 是否启用连接健康检查
+   * @default true
+   */
+  enableHealthCheck?: boolean;
+  /**
+   * ORM 配置（可选）
+   */
+  orm?: {
+    /**
+     * 是否启用 ORM
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Drizzle 数据库实例（如果使用 Drizzle ORM）
+     */
+    drizzle?: unknown;
+  };
+}
+
+/**
+ * 数据库连接状态
+ */
+export type ConnectionStatus = 'connected' | 'disconnected' | 'connecting' | 'error';
+
+/**
+ * 数据库连接信息
+ */
+export interface ConnectionInfo {
+  /**
+   * 连接状态
+   */
+  status: ConnectionStatus;
+  /**
+   * 数据库类型
+   */
+  type: DatabaseType;
+  /**
+   * 连接错误信息（如果有）
+   */
+  error?: string;
+}
+
+/**
+ * DatabaseService Token
+ */
+export const DATABASE_SERVICE_TOKEN = Symbol('@dangao/bun-server:database:service');
+
+/**
+ * DatabaseModule Options Token
+ */
+export const DATABASE_OPTIONS_TOKEN = Symbol('@dangao/bun-server:database:options');