@nest-omni/core 4.1.3-11 → 4.1.3-13

package/dist/transaction/__tests__/mocks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockTransactionStatus = createMockTransactionStatus;
+exports.createMockEntityManager = createMockEntityManager;
+/**
+ * 创建 Mock TransactionStatus
+ */
+function createMockTransactionStatus(overrides) {
+    return Object.assign({ isCompleted: false, isRollbackOnly: false, isNewTransaction: false, dataSourceName: 'default', startTime: new Date(), definition: {
+            propagation: 0, // Propagation.REQUIRED
+        }, nestingLevel: 1 }, overrides);
+}
+/**
+ * 创建 Mock EntityManager
+ */
+function createMockEntityManager() {
+    const mockEntityManager = {
+        save: jest.fn().mockResolvedValue({}),
+        find: jest.fn().mockResolvedValue([]),
+        findOne: jest.fn().mockResolvedValue(null),
+        update: jest.fn().mockResolvedValue(undefined),
+        delete: jest.fn().mockResolvedValue(undefined),
+        remove: jest.fn().mockResolvedValue({}),
+        count: jest.fn().mockResolvedValue(0),
+        query: jest.fn().mockResolvedValue([]),
+        createQueryBuilder: jest.fn().mockReturnValue({}),
+        getRepository: jest.fn().mockReturnValue({}),
+        queryRunner: {
+            isTransactionActive: false,
+        },
+    };
+    return mockEntityManager;
+}

package/dist/transaction/base-service-transaction.d.ts

@@ -0,0 +1,99 @@
+import { Logger } from '@nestjs/common';
+import { Repository, EntityManager } from 'typeorm';
+import { TransactionManager, Propagation, IsolationLevel, TransactionStatus } from './transaction-manager';
+/**
+ * 事务感知的基础服务类
+ * 提供统一的数据操作接口，自动处理事务
+ */
+export declare abstract class BaseService {
+    protected readonly transactionManager: TransactionManager;
+    protected readonly defaultDataSourceName: string;
+    protected readonly logger: Logger;
+    constructor(transactionManager: TransactionManager, defaultDataSourceName?: string);
+    /**
+     * 获取指定数据源的 EntityManager
+     */
+    protected getEntityManager(dataSourceName?: string): EntityManager;
+    /**
+     * 手动在事务中执行
+     */
+    protected executeInTransaction<T>(callback: (em: EntityManager) => Promise<T>, options?: {
+        propagation?: Propagation;
+        readOnly?: boolean;
+        isolation?: IsolationLevel;
+        dataSource?: string;
+    }): Promise<T>;
+    /**
+     * 保存实体
+     */
+    protected save<T>(entity: T, dataSourceName?: string): Promise<T>;
+    /**
+     * 批量保存实体
+     */
+    protected saveMany<T>(entities: T[], dataSourceName?: string): Promise<T[]>;
+    /**
+     * 更新实体
+     */
+    protected update<T>(entityClass: any, criteria: any, partialEntity: Partial<T>, dataSourceName?: string): Promise<void>;
+    /**
+     * 删除实体
+     */
+    protected remove<T>(entity: T, dataSourceName?: string): Promise<T>;
+    /**
+     * 根据 ID 删除实体
+     */
+    protected delete<T>(entityClass: any, id: string | number | (string | number)[], dataSourceName?: string): Promise<void>;
+    /**
+     * 查找实体
+     */
+    protected find<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<T[]>;
+    /**
+     * 查找一个实体
+     */
+    protected findOne<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<T | null>;
+    /**
+     * 根据 ID 查找实体
+     */
+    protected findById<T>(entityClass: any, id: string | number, dataSourceName?: string): Promise<T | null>;
+    /**
+     * 计数
+     */
+    protected count<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<number>;
+    /**
+     * 执行原生 SQL
+     */
+    protected query<T = any>(query: string, parameters?: any[], dataSourceName?: string): Promise<T[]>;
+    /**
+     * 创建 Query Builder
+     */
+    protected createQueryBuilder<T>(entityClass: any, alias?: string, dataSourceName?: string): Promise<import("typeorm").SelectQueryBuilder<import("typeorm").ObjectLiteral>>;
+    /**
+     * 获取 Repository
+     */
+    protected getRepository<T>(entity: any, dataSourceName?: string): Promise<Repository<T>>;
+    /**
+     * 执行跨数据源操作
+     */
+    protected executeAcrossDataSources<T>(operations: Array<{
+        dataSourceName: string;
+        operation: (em: EntityManager) => Promise<any>;
+    }>, options?: {
+        rollbackOnError?: boolean;
+    }): Promise<T[]>;
+    /**
+     * 批量操作优化
+     */
+    protected batchOperation<T, R>(items: T[], batchSize: number, operation: (batch: T[], em: EntityManager) => Promise<R[]>, options?: {
+        continueOnError?: boolean;
+        isolation?: IsolationLevel;
+        dataSourceName?: string;
+    }): Promise<R[]>;
+    /**
+     * 检查是否在事务中
+     */
+    protected isInTransaction(dataSourceName?: string): boolean;
+    /**
+     * 获取当前事务状态
+     */
+    protected getCurrentTransactionStatus(dataSourceName?: string): TransactionStatus;
+}

package/dist/transaction/base-service-transaction.js

@@ -0,0 +1,286 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var BaseService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const common_1 = require("@nestjs/common");
+const transaction_manager_1 = require("./transaction-manager");
+/**
+ * 事务感知的基础服务类
+ * 提供统一的数据操作接口，自动处理事务
+ */
+let BaseService = BaseService_1 = class BaseService {
+    constructor(transactionManager, defaultDataSourceName = 'default') {
+        this.transactionManager = transactionManager;
+        this.defaultDataSourceName = defaultDataSourceName;
+        this.logger = new common_1.Logger(BaseService_1.name);
+    }
+    /**
+     * 获取指定数据源的 EntityManager
+     */
+    getEntityManager(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        const em = this.transactionManager.getCurrentEntityManager(dsName);
+        if (!em) {
+            throw new Error(`No active transaction for dataSource: ${dsName}. ` +
+                `Use @Transactional decorator to start a transaction.`);
+        }
+        return em;
+    }
+    /**
+     * 手动在事务中执行
+     */
+    executeInTransaction(callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield this.transactionManager.getTransaction({
+                propagation: (options === null || options === void 0 ? void 0 : options.propagation) || transaction_manager_1.Propagation.REQUIRED,
+                readOnly: (options === null || options === void 0 ? void 0 : options.readOnly) || false,
+                isolationLevel: options === null || options === void 0 ? void 0 : options.isolation,
+                dataSourceName: (options === null || options === void 0 ? void 0 : options.dataSource) || this.defaultDataSourceName,
+                name: `executeInTransaction-${this.constructor.name}`,
+            });
+            try {
+                const em = this.getEntityManager(options === null || options === void 0 ? void 0 : options.dataSource);
+                const result = yield callback(em);
+                yield this.transactionManager.commit(status);
+                return result;
+            }
+            catch (error) {
+                yield this.transactionManager.rollback(status);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 保存实体
+     */
+    save(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.save(entity);
+        });
+    }
+    /**
+     * 批量保存实体
+     */
+    saveMany(entities, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.save(entities);
+        });
+    }
+    /**
+     * 更新实体
+     */
+    update(entityClass, criteria, partialEntity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            yield em.update(entityClass, criteria, partialEntity);
+        });
+    }
+    /**
+     * 删除实体
+     */
+    remove(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.remove(entity);
+        });
+    }
+    /**
+     * 根据 ID 删除实体
+     */
+    delete(entityClass, id, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            yield em.delete(entityClass, id);
+        });
+    }
+    /**
+     * 查找实体
+     */
+    find(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.find(entityClass, options);
+        });
+    }
+    /**
+     * 查找一个实体
+     */
+    findOne(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.findOne(entityClass, options);
+        });
+    }
+    /**
+     * 根据 ID 查找实体
+     */
+    findById(entityClass, id, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.findOne(entityClass, {
+                where: { id },
+            });
+        });
+    }
+    /**
+     * 计数
+     */
+    count(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.count(entityClass, options);
+        });
+    }
+    /**
+     * 执行原生 SQL
+     */
+    query(query, parameters, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.query(query, parameters);
+        });
+    }
+    /**
+     * 创建 Query Builder
+     */
+    createQueryBuilder(entityClass, alias, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.createQueryBuilder(entityClass, alias || entityClass.name.toLowerCase());
+        });
+    }
+    /**
+     * 获取 Repository
+     */
+    getRepository(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.getRepository(entity);
+        });
+    }
+    /**
+     * 执行跨数据源操作
+     */
+    executeAcrossDataSources(operations, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            const startedTransactions = [];
+            try {
+                // 在每个数据源上开始事务
+                for (const op of operations) {
+                    const status = yield this.transactionManager.getTransaction({
+                        propagation: transaction_manager_1.Propagation.REQUIRED,
+                        dataSourceName: op.dataSourceName,
+                    });
+                    startedTransactions.push(status);
+                }
+                // 执行所有操作
+                for (const op of operations) {
+                    const em = this.getEntityManager(op.dataSourceName);
+                    const result = yield op.operation(em);
+                    results.push(result);
+                }
+                // 提交所有事务
+                for (const status of startedTransactions) {
+                    yield this.transactionManager.commit(status);
+                }
+                return results;
+            }
+            catch (error) {
+                // 回滚所有事务
+                if ((options === null || options === void 0 ? void 0 : options.rollbackOnError) !== false) {
+                    for (const status of startedTransactions.reverse()) {
+                        try {
+                            yield this.transactionManager.rollback(status);
+                        }
+                        catch (rollbackError) {
+                            this.logger.error(`Failed to rollback transaction on ${status.dataSourceName}:`, rollbackError);
+                        }
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * 批量操作优化
+     */
+    batchOperation(items, batchSize, operation, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allResults = [];
+            let processedCount = 0;
+            return yield this.executeInTransaction((em) => __awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < items.length; i += batchSize) {
+                    const batch = items.slice(i, i + batchSize);
+                    const batchNumber = Math.floor(i / batchSize) + 1;
+                    try {
+                        this.logger.log(`Processing batch ${batchNumber}/${Math.ceil(items.length / batchSize)}`);
+                        const results = yield operation(batch, em);
+                        allResults.push(...results);
+                        processedCount += batch.length;
+                    }
+                    catch (error) {
+                        this.logger.error(`Batch ${batchNumber} failed:`, error);
+                        if (options === null || options === void 0 ? void 0 : options.continueOnError) {
+                            // 记录失败但继续
+                            processedCount += batch.length;
+                            continue;
+                        }
+                        else {
+                            throw new Error(`Batch operation failed at batch ${batchNumber}. Processed ${processedCount}/${items.length} items.`);
+                        }
+                    }
+                }
+                return allResults;
+            }), {
+                isolation: options === null || options === void 0 ? void 0 : options.isolation,
+                dataSource: options === null || options === void 0 ? void 0 : options.dataSourceName,
+            });
+        });
+    }
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        const status = this.transactionManager.getCurrentTransaction(dsName);
+        return status !== null && !status.isCompleted;
+    }
+    /**
+     * 获取当前事务状态
+     */
+    getCurrentTransactionStatus(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        return this.transactionManager.getCurrentTransaction(dsName);
+    }
+};
+exports.BaseService = BaseService;
+exports.BaseService = BaseService = BaseService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('DEFAULT_DATA_SOURCE_NAME')),
+    __metadata("design:paramtypes", [transaction_manager_1.TransactionManager, String])
+], BaseService);

package/dist/transaction/cls-compatibility.service.d.ts

@@ -0,0 +1,55 @@
+import { EntityManager } from 'typeorm';
+import { TransactionContextService } from './transaction-context.service';
+/**
+ * CLS (Continuation Local Storage) 兼容服务
+ * 提供与 nestjs-cls 兼容的 API，但底层使用事务上下文服务
+ */
+export declare class ClsCompatibilityService {
+    private readonly transactionContext;
+    private readonly defaultDataSource?;
+    private readonly store;
+    constructor(transactionContext: TransactionContextService, defaultDataSource?: string);
+    /**
+     * 设置值到存储中
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * 从存储中获取值
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * 根据数据源名称获取 EntityManager
+     */
+    getEntityManager(dataSourceName?: string): EntityManager | null;
+    /**
+     * 设置指定数据源的 EntityManager
+     */
+    setEntityManager(dataSourceName: string, entityManager: EntityManager): void;
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName?: string): boolean;
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getActiveTransactions(): Map<string, {
+        entityManager: EntityManager;
+        dataSource: any;
+    }>;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+/**
+ * CLS 服务管理器（静态类，模拟 nestjs-cls 的 API）
+ */
+export declare class ClsServiceManager {
+    private static clsService;
+    static setClsService(clsService: ClsCompatibilityService): void;
+    static getClsService(): ClsCompatibilityService;
+}
+/**
+ * CLS 装饰器（兼容性）
+ */
+export declare function SetCls(key?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/transaction/cls-compatibility.service.js

@@ -0,0 +1,127 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClsServiceManager = exports.ClsCompatibilityService = void 0;
+exports.SetCls = SetCls;
+const common_1 = require("@nestjs/common");
+const transaction_context_service_1 = require("./transaction-context.service");
+/**
+ * CLS (Continuation Local Storage) 兼容服务
+ * 提供与 nestjs-cls 兼容的 API，但底层使用事务上下文服务
+ */
+let ClsCompatibilityService = class ClsCompatibilityService {
+    constructor(transactionContext, defaultDataSource) {
+        this.transactionContext = transactionContext;
+        this.defaultDataSource = defaultDataSource;
+        this.store = new Map();
+    }
+    /**
+     * 设置值到存储中
+     */
+    set(key, value) {
+        if (key === 'entityManager') {
+            // 如果设置 entityManager，则根据数据源名称设置到事务上下文
+            const dataSourceName = this.defaultDataSource || 'default';
+            this.transactionContext.setContext(dataSourceName, value);
+        }
+        else {
+            this.store.set(key, value);
+        }
+    }
+    /**
+     * 从存储中获取值
+     */
+    get(key) {
+        if (key === 'entityManager') {
+            // 获取默认数据源的 EntityManager
+            const dataSourceName = this.defaultDataSource || 'default';
+            return this.transactionContext.getEntityManager(dataSourceName);
+        }
+        else {
+            return this.store.get(key);
+        }
+    }
+    /**
+     * 根据数据源名称获取 EntityManager
+     */
+    getEntityManager(dataSourceName) {
+        return this.transactionContext.getEntityManager(dataSourceName || this.defaultDataSource || 'default');
+    }
+    /**
+     * 设置指定数据源的 EntityManager
+     */
+    setEntityManager(dataSourceName, entityManager) {
+        this.transactionContext.setContext(dataSourceName, entityManager);
+    }
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName) {
+        return this.transactionContext.isInTransaction(dataSourceName || this.defaultDataSource || 'default');
+    }
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getActiveTransactions() {
+        const contexts = this.transactionContext.getAllActiveContexts();
+        const result = new Map();
+        for (const [name, context] of contexts) {
+            result.set(name, {
+                entityManager: context.entityManager,
+                dataSource: context.dataSource,
+            });
+        }
+        return result;
+    }
+    /**
+     * 清理存储
+     */
+    clear() {
+        this.store.clear();
+        this.transactionContext.clearContext();
+    }
+};
+exports.ClsCompatibilityService = ClsCompatibilityService;
+exports.ClsCompatibilityService = ClsCompatibilityService = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('CLS_DEFAULT_DATA_SOURCE')),
+    __metadata("design:paramtypes", [transaction_context_service_1.TransactionContextService, String])
+], ClsCompatibilityService);
+/**
+ * CLS 服务管理器（静态类，模拟 nestjs-cls 的 API）
+ */
+class ClsServiceManager {
+    static setClsService(clsService) {
+        ClsServiceManager.clsService = clsService;
+    }
+    static getClsService() {
+        if (!ClsServiceManager.clsService) {
+            throw new Error('CLS service not initialized. Please ensure TransactionModule is imported.');
+        }
+        return ClsServiceManager.clsService;
+    }
+}
+exports.ClsServiceManager = ClsServiceManager;
+ClsServiceManager.clsService = null;
+/**
+ * CLS 装饰器（兼容性）
+ */
+function SetCls(key) {
+    return function (target, propertyKey, parameterIndex) {
+        const existing = Reflect.getMetadata('cls_params', target) || {};
+        existing[parameterIndex] = { key };
+        Reflect.defineMetadata('cls_params', existing, target);
+    };
+}

package/dist/transaction/data-source-registry.d.ts

@@ -0,0 +1,91 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { DataSource, DataSourceOptions } from 'typeorm';
+/**
+ * 数据源注册表配置
+ */
+export interface DataSourceRegistryConfig {
+    enableHealthCheck?: boolean;
+    healthCheckInterval?: number;
+    connectionTimeout?: number;
+    maxReconnectAttempts?: number;
+    logLifecycleEvents?: boolean;
+    autoCleanup?: boolean;
+}
+/**
+ * 数据源健康状态
+ */
+export interface DataSourceHealthStatus {
+    name: string;
+    isConnected: boolean;
+    lastChecked: Date;
+    error?: string;
+    responseTime?: number;
+}
+/**
+ * 数据源注册表管理器
+ * 负责管理所有动态注册的数据源
+ */
+export declare class DataSourceRegistryService implements OnModuleInit, OnModuleDestroy {
+    private readonly logger;
+    private healthCheckInterval;
+    private healthStatuses;
+    private config;
+    constructor(config?: DataSourceRegistryConfig);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * 注册新的数据源
+     */
+    registerDataSource(name: string, options: DataSourceOptions, metadata?: Record<string, any>): Promise<DataSource>;
+    /**
+     * 注册已存在的数据源
+     */
+    registerExistingDataSource(name: string, dataSource: DataSource, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * 注销数据源
+     */
+    unregisterDataSource(name: string): Promise<void>;
+    /**
+     * 获取数据源
+     */
+    getDataSource(name: string): DataSource | null;
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    getRegisteredDataSources(): string[];
+    /**
+     * 批量注册数据源
+     */
+    registerDataSources(configs: Array<{
+        name: string;
+        options: DataSourceOptions;
+        metadata?: Record<string, any>;
+    }>, options?: {
+        continueOnError?: boolean;
+        parallel?: boolean;
+    }): Promise<DataSource[]>;
+    /**
+     * 测试数据源连接
+     */
+    testConnection(name: string): Promise<boolean>;
+    /**
+     * 获取所有数据源的健康状态
+     */
+    getHealthStatuses(): Map<string, DataSourceHealthStatus>;
+    /**
+     * 重新连接数据源
+     */
+    reconnectDataSource(name: string): Promise<boolean>;
+    /**
+     * 开始健康检查
+     */
+    private startHealthCheck;
+    /**
+     * 清理指定数据源
+     */
+    private cleanupDataSources;
+    /**
+     * 清理所有动态数据源
+     */
+    private cleanupAllDataSources;
+}