@dangao/bun-server 1.0.0 → 1.0.3

package/src/database/database-module.ts

@@ -0,0 +1,115 @@
+import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../di/module';
+import type { ApplicationExtension } from '../extensions/types';
+
+import { DatabaseExtension } from './database-extension';
+import { DatabaseHealthIndicator } from './health-indicator';
+import { OrmService } from './orm/service';
+import { TransactionManager } from './orm/transaction-manager';
+import { DatabaseService } from './service';
+import {
+  DATABASE_OPTIONS_TOKEN,
+  DATABASE_SERVICE_TOKEN,
+  type DatabaseModuleOptions,
+} from './types';
+import { ORM_SERVICE_TOKEN } from './orm/types';
+import { TRANSACTION_SERVICE_TOKEN } from './orm/transaction-types';
+
+@Module({
+  providers: [],
+})
+export class DatabaseModule {
+  /**
+   * 创建数据库模块
+   * @param options - 模块配置
+   */
+  public static forRoot(
+    options: DatabaseModuleOptions,
+  ): typeof DatabaseModule {
+    const providers: ModuleProvider[] = [];
+
+    const service = new DatabaseService(options);
+
+    providers.push(
+      {
+        provide: DATABASE_SERVICE_TOKEN,
+        useValue: service,
+      },
+      {
+        provide: DATABASE_OPTIONS_TOKEN,
+        useValue: options,
+      },
+      DatabaseService,
+    );
+
+    // 如果启用了 ORM，注册 ORM 服务
+    if (options.orm?.enabled) {
+      const ormService = new OrmService(service, {
+        enabled: true,
+        drizzle: options.orm.drizzle,
+        databaseService: service,
+      });
+      providers.push(
+        {
+          provide: ORM_SERVICE_TOKEN,
+          useValue: ormService,
+        },
+        OrmService,
+      );
+    }
+
+    // 注册事务管理器（总是注册，即使 ORM 未启用）
+    const transactionManager = new TransactionManager(service);
+    providers.push(
+      {
+        provide: TRANSACTION_SERVICE_TOKEN,
+        useValue: transactionManager,
+      },
+      TransactionManager,
+    );
+
+    // 数据库健康检查指示器可以通过 DatabaseModule.createHealthIndicator() 方法获取
+    // 然后在 HealthModule.forRoot() 中手动添加
+
+    // 动态更新模块元数据
+    const existingMetadata =
+      Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule) || {};
+    
+    // 创建数据库扩展，用于在应用启动时初始化连接
+    const databaseExtension = new DatabaseExtension();
+    
+    const metadata = {
+      ...existingMetadata,
+      providers: [...(existingMetadata.providers || []), ...providers],
+      exports: [
+        ...(existingMetadata.exports || []),
+        DATABASE_SERVICE_TOKEN,
+        DATABASE_OPTIONS_TOKEN,
+        DatabaseService,
+        TRANSACTION_SERVICE_TOKEN,
+        TransactionManager,
+        ...(options.orm?.enabled
+          ? [ORM_SERVICE_TOKEN, OrmService]
+          : []),
+      ],
+      extensions: [
+        ...(existingMetadata.extensions || []),
+        databaseExtension,
+      ],
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DatabaseModule);
+
+    return DatabaseModule;
+  }
+
+  /**
+   * 创建数据库健康检查指示器
+   * 用于在 HealthModule 中注册数据库健康检查
+   * @param databaseService - 数据库服务实例
+   * @returns 数据库健康检查指示器
+   */
+  public static createHealthIndicator(
+    databaseService: DatabaseService,
+  ): DatabaseHealthIndicator {
+    return new DatabaseHealthIndicator(databaseService);
+  }
+}

package/src/database/health-indicator.ts

@@ -0,0 +1,51 @@
+import type {
+  HealthIndicator,
+  HealthIndicatorResult,
+} from '../health/types';
+import { DATABASE_SERVICE_TOKEN } from './types';
+import type { DatabaseService } from './service';
+
+/**
+ * 数据库健康检查指示器
+ */
+export class DatabaseHealthIndicator implements HealthIndicator {
+  public readonly name = 'database';
+
+  public constructor(private readonly databaseService: DatabaseService) {}
+
+  /**
+   * 执行数据库健康检查
+   */
+  public async check(): Promise<HealthIndicatorResult> {
+    try {
+      const isHealthy = await this.databaseService.healthCheck();
+      const connectionInfo = this.databaseService.getConnectionInfo();
+
+      if (isHealthy) {
+        return {
+          status: 'up',
+          details: {
+            type: connectionInfo.type,
+            status: connectionInfo.status,
+          },
+        };
+      }
+
+      return {
+        status: 'down',
+        details: {
+          type: connectionInfo.type,
+          status: connectionInfo.status,
+          error: connectionInfo.error,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'down',
+        details: {
+          error: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+  }
+}

package/src/database/index.ts

@@ -0,0 +1,47 @@
+export { DatabaseModule } from './database-module';
+export { DatabaseService } from './service';
+export { DatabaseConnectionManager } from './connection-manager';
+export { ConnectionPool } from './connection-pool';
+export { DatabaseHealthIndicator } from './health-indicator';
+export { DatabaseExtension } from './database-extension';
+export {
+  DATABASE_OPTIONS_TOKEN,
+  DATABASE_SERVICE_TOKEN,
+  type ConnectionInfo,
+  type ConnectionPoolOptions,
+  type DatabaseConfig,
+  type DatabaseModuleOptions,
+  type DatabaseType,
+  type MysqlConfig,
+  type PostgresConfig,
+  type SqliteConfig,
+} from './types';
+// ORM 导出
+export {
+  Entity,
+  Column,
+  PrimaryKey,
+  Repository,
+  BaseRepository,
+  DrizzleBaseRepository,
+  OrmService,
+  ORM_SERVICE_TOKEN,
+  getEntityMetadata,
+  getColumnMetadata,
+  getRepositoryMetadata,
+  type OrmModuleOptions,
+  type BaseRepository as BaseRepositoryInterface,
+  type EntityMetadata,
+  type ColumnMetadata,
+  // Transaction exports
+  Transactional,
+  TransactionManager,
+  TransactionInterceptor,
+  Propagation,
+  IsolationLevel,
+  TransactionStatus,
+  TRANSACTION_SERVICE_TOKEN,
+  getTransactionMetadata,
+  type TransactionOptions,
+  type TransactionContext,
+} from './orm';

package/src/database/orm/decorators.ts

@@ -0,0 +1,155 @@
+import 'reflect-metadata';
+
+/**
+ * Entity 元数据键
+ */
+export const ENTITY_METADATA_KEY = Symbol('@dangao/bun-server:orm:entity');
+
+/**
+ * Column 元数据键
+ */
+export const COLUMN_METADATA_KEY = Symbol('@dangao/bun-server:orm:column');
+
+/**
+ * Entity 装饰器
+ * 标记一个类为数据库实体
+ * @param tableName - 表名
+ */
+export function Entity(tableName: string): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata(ENTITY_METADATA_KEY, { tableName }, target);
+  };
+}
+
+/**
+ * Column 装饰器
+ * 标记一个属性为数据库列
+ * @param options - 列选项
+ */
+export function Column(options?: {
+  /**
+   * 列名（默认为属性名）
+   */
+  name?: string;
+  /**
+   * 列类型
+   */
+  type?: string;
+  /**
+   * 是否为主键
+   */
+  primaryKey?: boolean;
+  /**
+   * 是否自动递增
+   */
+  autoIncrement?: boolean;
+  /**
+   * 是否可为空
+   */
+  nullable?: boolean;
+  /**
+   * 默认值
+   */
+  defaultValue?: unknown;
+}): PropertyDecorator {
+  return (target, propertyKey) => {
+    const existingColumns =
+      Reflect.getMetadata(COLUMN_METADATA_KEY, target.constructor) || [];
+    
+    // 检查是否已存在该属性的列定义
+    const existingIndex = existingColumns.findIndex(
+      (col: { propertyKey: string }) => col.propertyKey === String(propertyKey),
+    );
+    
+    const columnDef = {
+      name: options?.name ?? String(propertyKey),
+      type: options?.type ?? 'TEXT',
+      primaryKey: options?.primaryKey ?? false,
+      autoIncrement: options?.autoIncrement ?? false,
+      nullable: options?.nullable !== undefined ? options.nullable : true,
+      defaultValue: options?.defaultValue,
+      propertyKey: String(propertyKey),
+    };
+    
+    if (existingIndex >= 0) {
+      // 合并现有定义（保留已有的 primaryKey、nullable 等设置）
+      const existing = existingColumns[existingIndex] as {
+        primaryKey: boolean;
+        nullable: boolean;
+        autoIncrement: boolean;
+        type: string;
+        name: string;
+        defaultValue?: unknown;
+      };
+      existingColumns[existingIndex] = {
+        ...existing,
+        // 合并时，如果新定义中明确设置了属性，使用新值；否则保留旧值
+        name: options?.name ?? existing.name,
+        type: options?.type ?? existing.type,
+        primaryKey:
+          options?.primaryKey !== undefined
+            ? options.primaryKey
+            : existing.primaryKey,
+        nullable:
+          options?.nullable !== undefined ? options.nullable : existing.nullable,
+        autoIncrement:
+          options?.autoIncrement !== undefined
+            ? options.autoIncrement
+            : existing.autoIncrement,
+        defaultValue:
+          options?.defaultValue !== undefined
+            ? options.defaultValue
+            : existing.defaultValue,
+        propertyKey: String(propertyKey),
+      };
+    } else {
+      existingColumns.push(columnDef);
+    }
+    
+    Reflect.defineMetadata(
+      COLUMN_METADATA_KEY,
+      existingColumns,
+      target.constructor,
+    );
+  };
+}
+
+/**
+ * PrimaryKey 装饰器
+ * 标记一个属性为主键
+ */
+export function PrimaryKey(): PropertyDecorator {
+  return Column({ primaryKey: true, nullable: false });
+}
+
+/**
+ * 获取 Entity 元数据
+ */
+export function getEntityMetadata(
+  target: unknown,
+): { tableName: string } | undefined {
+  if (typeof target === 'function' || (typeof target === 'object' && target !== null)) {
+    return Reflect.getMetadata(ENTITY_METADATA_KEY, target as object);
+  }
+  return undefined;
+}
+
+/**
+ * 获取 Column 元数据
+ */
+export function getColumnMetadata(
+  target: unknown,
+): Array<{
+  name: string;
+  type: string;
+  primaryKey: boolean;
+  autoIncrement: boolean;
+  nullable: boolean;
+  defaultValue?: unknown;
+  propertyKey: string;
+}> {
+  if (typeof target === 'function' || (typeof target === 'object' && target !== null)) {
+    return Reflect.getMetadata(COLUMN_METADATA_KEY, target as object) || [];
+  }
+  return [];
+}

package/src/database/orm/drizzle-repository.ts

@@ -0,0 +1,39 @@
+import type { DatabaseService } from '../service';
+
+/**
+ * Drizzle Repository 基类
+ * 使用 Drizzle ORM 提供类型安全的查询
+ * 注意：这是一个抽象基类，供使用 Drizzle ORM 的 Repository 继承
+ * 继承此类的 Repository 需要自己添加 @Injectable() 装饰器
+ */
+export abstract class DrizzleBaseRepository<TTable, TSelect, TInsert, TUpdate> {
+  protected abstract table: TTable;
+  protected abstract drizzle: unknown;
+
+  public constructor(protected readonly databaseService: DatabaseService) {}
+
+  /**
+   * 查找所有记录
+   */
+  public abstract findAll(): Promise<TSelect[]>;
+
+  /**
+   * 根据 ID 查找记录
+   */
+  public abstract findById(id: string | number): Promise<TSelect | null>;
+
+  /**
+   * 创建记录
+   */
+  public abstract create(data: TInsert): Promise<TSelect>;
+
+  /**
+   * 更新记录
+   */
+  public abstract update(id: string | number, data: TUpdate): Promise<TSelect>;
+
+  /**
+   * 删除记录
+   */
+  public abstract delete(id: string | number): Promise<boolean>;
+}

package/src/database/orm/index.ts

@@ -0,0 +1,23 @@
+export { Entity, Column, PrimaryKey, getEntityMetadata, getColumnMetadata } from './decorators';
+export { Repository, getRepositoryMetadata } from './repository-decorator';
+export { Transactional, getTransactionMetadata } from './transaction-decorator';
+export { BaseRepository } from './repository';
+export { DrizzleBaseRepository } from './drizzle-repository';
+export { OrmService } from './service';
+export { TransactionManager } from './transaction-manager';
+export { TransactionInterceptor } from './transaction-interceptor';
+export {
+  ORM_SERVICE_TOKEN,
+  type OrmModuleOptions,
+  type BaseRepository as BaseRepositoryInterface,
+  type EntityMetadata,
+  type ColumnMetadata,
+} from './types';
+export {
+  Propagation,
+  IsolationLevel,
+  TransactionStatus,
+  TRANSACTION_SERVICE_TOKEN,
+  type TransactionOptions,
+  type TransactionContext,
+} from './transaction-types';

package/src/database/orm/repository-decorator.ts

@@ -0,0 +1,39 @@
+import 'reflect-metadata';
+import { Injectable } from '../../di/decorators';
+import type { Constructor } from '../../core/types';
+
+/**
+ * Repository 元数据键
+ */
+export const REPOSITORY_METADATA_KEY = Symbol('@dangao/bun-server:orm:repository');
+
+/**
+ * Repository 装饰器
+ * 标记一个类为 Repository
+ * @param tableName - 表名
+ * @param primaryKey - 主键字段名（默认为 'id'）
+ */
+export function Repository(tableName: string, primaryKey: string = 'id') {
+  return function <T extends Constructor<unknown>>(target: T): T {
+    // 标记为 Injectable
+    Injectable()(target);
+
+    // 添加元数据
+    Reflect.defineMetadata(REPOSITORY_METADATA_KEY, { tableName, primaryKey }, target);
+
+    return target;
+  };
+}
+
+/**
+ * 获取 Repository 元数据
+ */
+export function getRepositoryMetadata(target: unknown): {
+  tableName: string;
+  primaryKey: string;
+} | undefined {
+  if (typeof target === 'function' || (typeof target === 'object' && target !== null)) {
+    return Reflect.getMetadata(REPOSITORY_METADATA_KEY, target as object);
+  }
+  return undefined;
+}

package/src/database/orm/repository.ts

@@ -0,0 +1,103 @@
+import { Injectable, Inject } from '../../di/decorators';
+import { DATABASE_SERVICE_TOKEN } from '../types';
+import type { DatabaseService } from '../service';
+
+/**
+ * Repository 基类
+ * 提供基础的 CRUD 操作
+ */
+export abstract class BaseRepository<T = unknown> {
+  protected abstract tableName: string;
+  protected abstract primaryKey: string;
+
+  public constructor(
+    @Inject(DATABASE_SERVICE_TOKEN)
+    protected readonly databaseService: DatabaseService,
+  ) {}
+
+  /**
+   * 查找所有记录
+   */
+  public async findAll(): Promise<T[]> {
+    const sql = `SELECT * FROM ${this.tableName}`;
+    const result = await this.executeQuery<T>(sql);
+    return Array.isArray(result) ? result : [];
+  }
+
+  /**
+   * 根据 ID 查找记录
+   */
+  public async findById(id: string | number): Promise<T | null> {
+    const sql = `SELECT * FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
+    const result = await this.executeQuery<T>(sql, [id]);
+    if (Array.isArray(result) && result.length > 0) {
+      return result[0] as T;
+    }
+    return null;
+  }
+
+  /**
+   * 创建记录
+   */
+  public async create(data: Partial<T>): Promise<T> {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => '?').join(', ');
+    const sql = `INSERT INTO ${this.tableName} (${keys.join(', ')}) VALUES (${placeholders})`;
+
+    await this.executeQuery(sql, values);
+
+    // 获取最后插入的 ID
+    const lastIdResult = await this.executeQuery<{ id: number }>(
+      'SELECT last_insert_rowid() as id',
+    );
+    const lastId = Array.isArray(lastIdResult) && lastIdResult[0]
+      ? lastIdResult[0].id
+      : null;
+
+    if (lastId !== null) {
+      return (await this.findById(lastId)) as T;
+    }
+
+    return data as T;
+  }
+
+  /**
+   * 更新记录
+   */
+  public async update(id: string | number, data: Partial<T>): Promise<T> {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const setClause = keys.map((key) => `${key} = ?`).join(', ');
+    const sql = `UPDATE ${this.tableName} SET ${setClause} WHERE ${this.primaryKey} = ?`;
+
+    await this.executeQuery(sql, [...values, id]);
+
+    return (await this.findById(id)) as T;
+  }
+
+  /**
+   * 删除记录
+   */
+  public async delete(id: string | number): Promise<boolean> {
+    const sql = `DELETE FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
+    await this.executeQuery(sql, [id]);
+    return true;
+  }
+
+  /**
+   * 执行查询
+   */
+  protected async executeQuery<T = unknown>(
+    sql: string,
+    params?: unknown[],
+  ): Promise<T[]> {
+    const result = this.databaseService.query<T>(sql, params);
+    // SQLite 返回同步结果，PostgreSQL/MySQL 返回 Promise
+    if (result instanceof Promise) {
+      const resolved = await result;
+      return Array.isArray(resolved) ? resolved : [resolved];
+    }
+    return Array.isArray(result) ? result : [result];
+  }
+}

package/src/database/orm/service.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '../../di/decorators';
+import type { DatabaseService } from '../service';
+import type { OrmModuleOptions } from './types';
+
+/**
+ * ORM 服务
+ * 提供 ORM 相关的功能，如 Drizzle 实例管理
+ */
+@Injectable()
+export class OrmService {
+  private drizzleInstance: unknown | null = null;
+
+  public constructor(
+    private readonly databaseService: DatabaseService,
+    private readonly options: OrmModuleOptions = {},
+  ) {}
+
+  /**
+   * 获取 Drizzle 实例
+   * 如果未提供，则根据数据库类型创建
+   */
+  public getDrizzle(): unknown {
+    if (this.options.drizzle) {
+      return this.options.drizzle;
+    }
+
+    if (this.drizzleInstance) {
+      return this.drizzleInstance;
+    }
+
+    // 如果未提供 Drizzle 实例，返回 null
+    // 用户需要手动创建并传入
+    return null;
+  }
+
+  /**
+   * 设置 Drizzle 实例
+   */
+  public setDrizzle(drizzle: unknown): void {
+    this.drizzleInstance = drizzle;
+  }
+
+  /**
+   * 获取数据库服务
+   */
+  public getDatabaseService(): DatabaseService {
+    return this.databaseService;
+  }
+}

package/src/database/orm/transaction-decorator.ts

@@ -0,0 +1,45 @@
+import 'reflect-metadata';
+import { Propagation } from './transaction-types';
+import type { TransactionOptions } from './transaction-types';
+
+/**
+ * Transaction 元数据键
+ */
+export const TRANSACTION_METADATA_KEY = Symbol('@dangao/bun-server:orm:transaction');
+
+/**
+ * Transactional 装饰器
+ * 标记方法需要在事务中执行
+ * @param options - 事务配置选项
+ */
+export function Transactional(options?: TransactionOptions): MethodDecorator {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== 'function') {
+      throw new Error('@Transactional() can only be applied to methods');
+    }
+
+    const metadata = {
+      propagation: options?.propagation ?? Propagation.REQUIRED,
+      isolationLevel: options?.isolationLevel,
+      timeout: options?.timeout,
+      readOnly: options?.readOnly ?? false,
+      rollbackFor: options?.rollbackFor ?? [],
+      noRollbackFor: options?.noRollbackFor ?? [],
+    };
+
+    Reflect.defineMetadata(TRANSACTION_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+
+/**
+ * 获取 Transaction 元数据
+ */
+export function getTransactionMetadata(
+  target: unknown,
+  propertyKey: string | symbol,
+): TransactionOptions | undefined {
+  if (typeof target === 'object' && target !== null) {
+    return Reflect.getMetadata(TRANSACTION_METADATA_KEY, target, propertyKey);
+  }
+  return undefined;
+}