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

package/dist/transaction/decorators/entity-datasource.decorator.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntityWithDataSource = exports.ENTITY_DATASOURCE_METADATA_KEY = void 0;
+exports.DataSource = DataSource;
+exports.getEntityDataSource = getEntityDataSource;
+exports.hasEntityDataSource = hasEntityDataSource;
+exports.DynamicDataSource = DynamicDataSource;
+exports.isDynamicDataSourceEntity = isDynamicDataSourceEntity;
+require("reflect-metadata");
+/**
+ * Entity 数据源装饰器
+ * 用于指定 Entity 应该使用哪个数据源
+ */
+exports.ENTITY_DATASOURCE_METADATA_KEY = 'entity:datasource';
+/**
+ * 数据源装饰器 - 为 Entity 指定数据源
+ *
+ * @param dataSourceName 数据源名称
+ *
+ * 使用示例：
+ * ```typescript
+ * @Entity('users')
+ * @DataSource('user_db')
+ * export class User {
+ *   @PrimaryGeneratedColumn()
+ *   id: number;
+ *
+ *   @Column()
+ *   name: string;
+ * }
+ * ```
+ */
+function DataSource(dataSourceName) {
+    return function (target) {
+        // 使用 Reflect.metadata 存储数据源信息
+        Reflect.defineMetadata(exports.ENTITY_DATASOURCE_METADATA_KEY, dataSourceName, target);
+        // 同时在原型上设置属性，方便运行时访问
+        target.prototype._dataSourceName = dataSourceName;
+        // 静态属性，方便类级别访问
+        target._dataSourceName = dataSourceName;
+        // 如果类有 metadata 属性（一些 ORM 框架支持），也设置在那里
+        if (target.metadata) {
+            target.metadata.dataSource = dataSourceName;
+        }
+    };
+}
+/**
+ * 获取 Entity 的数据源名称
+ * @param entityClass Entity 类或构造函数
+ * @returns 数据源名称，如果未指定则返回 null
+ */
+function getEntityDataSource(entityClass) {
+    if (!entityClass)
+        return null;
+    // 尝试从多个位置获取数据源名称
+    // 1. 从 Reflect.metadata 获取
+    const metadataSource = Reflect.getMetadata(exports.ENTITY_DATASOURCE_METADATA_KEY, entityClass);
+    if (metadataSource)
+        return metadataSource;
+    // 2. 从静态属性获取
+    if (entityClass._dataSourceName)
+        return entityClass._dataSourceName;
+    // 3. 从原型获取
+    if (entityClass.prototype && entityClass.prototype._dataSourceName) {
+        return entityClass.prototype._dataSourceName;
+    }
+    // 4. 从实例获取（如果传入的是实例）
+    if (entityClass.constructor && entityClass.constructor._dataSourceName) {
+        return entityClass.constructor._dataSourceName;
+    }
+    return null;
+}
+/**
+ * 检查 Entity 是否指定了数据源
+ * @param entityClass Entity 类或构造函数
+ * @returns 是否指定了数据源
+ */
+function hasEntityDataSource(entityClass) {
+    return getEntityDataSource(entityClass) !== null;
+}
+/**
+ * 带数据源的 Entity 基类
+ * 继承这个基类的 Entity 可以通过实现 useDataSource 方法动态指定数据源
+ */
+class BaseEntityWithDataSource {
+}
+exports.BaseEntityWithDataSource = BaseEntityWithDataSource;
+/**
+ * 动态数据源装饰器
+ * 标记 Entity 使用动态数据源（通过 useDataSource 方法指定）
+ */
+function DynamicDataSource() {
+    return function (target) {
+        // 设置标记，表示使用动态数据源
+        Reflect.defineMetadata('entity:dynamic-datasource', true, target);
+        target._useDynamicDataSource = true;
+    };
+}
+/**
+ * 检查 Entity 是否使用动态数据源
+ */
+function isDynamicDataSourceEntity(entityClass) {
+    return Reflect.getMetadata('entity:dynamic-datasource', entityClass) === true ||
+        entityClass._useDynamicDataSource === true;
+}

package/dist/transaction/index.d.ts

@@ -0,0 +1,15 @@
+export { TransactionManager, TransactionDefinition, TransactionStatus, Propagation, IsolationLevel, TransactionTimeoutCallback, TransactionContextManager } from './transaction-manager';
+export { TransactionSynchronizationManager, TransactionSynchronization, TransactionSynchronizationStatus, } from './transaction-synchronization';
+export { Transactional, ClassTransactional, TransactionalInterceptor, Tx, UseTransactional, TransactionalOptions } from './transactional.decorator';
+export { BaseService } from './base-service-transaction';
+export { TypeOrmModuleWrapper, TypeOrmDataSourceConfig, MultiTypeOrmModuleOptions, GlobalMultiTypeOrmModule } from './typeorm-module-wrapper';
+export { DataSourceRegistryService, DataSourceRegistryConfig, DataSourceHealthStatus } from './data-source-registry';
+export { TransactionContextService, DynamicDataSourceConfig } from './transaction-context.service';
+export { ClsCompatibilityService, ClsServiceManager } from './cls-compatibility.service';
+export { DataSource, DynamicDataSource, BaseEntityWithDataSource, getEntityDataSource, hasEntityDataSource, isDynamicDataSourceEntity } from './decorators/entity-datasource.decorator';
+export { LoggingTransactionalInterceptor } from './logging-transactional.interceptor';
+export { LoggingTransactionalInterceptor as TRANSACTION_LOGGING_INTERCEPTOR } from './logging-transactional.interceptor';
+export { TransactionError, TransactionErrorHandler } from './transaction.errors';
+export { DatabaseAdapter, DatabaseType } from './database-adapter';
+export { DataSourceUtil, getDataSource, getDataSourceSafe, getDefaultDataSource, isDataSourceAvailable, withDataSource, withTransaction, addDataSource, addDataSources, } from './data-source.util';
+export { TransactionModule } from './transaction.module';

package/dist/transaction/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionModule = exports.addDataSources = exports.addDataSource = exports.withTransaction = exports.withDataSource = exports.isDataSourceAvailable = exports.getDefaultDataSource = exports.getDataSourceSafe = exports.getDataSource = exports.DataSourceUtil = exports.DatabaseAdapter = exports.TransactionErrorHandler = exports.TransactionError = exports.TRANSACTION_LOGGING_INTERCEPTOR = exports.LoggingTransactionalInterceptor = exports.isDynamicDataSourceEntity = exports.hasEntityDataSource = exports.getEntityDataSource = exports.BaseEntityWithDataSource = exports.DynamicDataSource = exports.DataSource = exports.ClsServiceManager = exports.ClsCompatibilityService = exports.TransactionContextService = exports.DataSourceRegistryService = exports.GlobalMultiTypeOrmModule = exports.TypeOrmModuleWrapper = exports.BaseService = exports.UseTransactional = exports.Tx = exports.TransactionalInterceptor = exports.ClassTransactional = exports.Transactional = exports.TransactionSynchronizationStatus = exports.TransactionSynchronizationManager = exports.TransactionContextManager = exports.IsolationLevel = exports.Propagation = exports.TransactionManager = void 0;
+// 核心事务管理
+var transaction_manager_1 = require("./transaction-manager");
+Object.defineProperty(exports, "TransactionManager", { enumerable: true, get: function () { return transaction_manager_1.TransactionManager; } });
+Object.defineProperty(exports, "Propagation", { enumerable: true, get: function () { return transaction_manager_1.Propagation; } });
+Object.defineProperty(exports, "IsolationLevel", { enumerable: true, get: function () { return transaction_manager_1.IsolationLevel; } });
+Object.defineProperty(exports, "TransactionContextManager", { enumerable: true, get: function () { return transaction_manager_1.TransactionContextManager; } });
+// 事务同步机制（对标 Spring TransactionSynchronization）
+var transaction_synchronization_1 = require("./transaction-synchronization");
+Object.defineProperty(exports, "TransactionSynchronizationManager", { enumerable: true, get: function () { return transaction_synchronization_1.TransactionSynchronizationManager; } });
+Object.defineProperty(exports, "TransactionSynchronizationStatus", { enumerable: true, get: function () { return transaction_synchronization_1.TransactionSynchronizationStatus; } });
+// 装饰器
+var transactional_decorator_1 = require("./transactional.decorator");
+Object.defineProperty(exports, "Transactional", { enumerable: true, get: function () { return transactional_decorator_1.Transactional; } });
+Object.defineProperty(exports, "ClassTransactional", { enumerable: true, get: function () { return transactional_decorator_1.ClassTransactional; } });
+Object.defineProperty(exports, "TransactionalInterceptor", { enumerable: true, get: function () { return transactional_decorator_1.TransactionalInterceptor; } });
+Object.defineProperty(exports, "Tx", { enumerable: true, get: function () { return transactional_decorator_1.Tx; } });
+Object.defineProperty(exports, "UseTransactional", { enumerable: true, get: function () { return transactional_decorator_1.UseTransactional; } });
+var base_service_transaction_1 = require("./base-service-transaction");
+Object.defineProperty(exports, "BaseService", { enumerable: true, get: function () { return base_service_transaction_1.BaseService; } });
+// 数据源管理
+var typeorm_module_wrapper_1 = require("./typeorm-module-wrapper");
+Object.defineProperty(exports, "TypeOrmModuleWrapper", { enumerable: true, get: function () { return typeorm_module_wrapper_1.TypeOrmModuleWrapper; } });
+Object.defineProperty(exports, "GlobalMultiTypeOrmModule", { enumerable: true, get: function () { return typeorm_module_wrapper_1.GlobalMultiTypeOrmModule; } });
+var data_source_registry_1 = require("./data-source-registry");
+Object.defineProperty(exports, "DataSourceRegistryService", { enumerable: true, get: function () { return data_source_registry_1.DataSourceRegistryService; } });
+var transaction_context_service_1 = require("./transaction-context.service");
+Object.defineProperty(exports, "TransactionContextService", { enumerable: true, get: function () { return transaction_context_service_1.TransactionContextService; } });
+// 兼容性支持
+var cls_compatibility_service_1 = require("./cls-compatibility.service");
+Object.defineProperty(exports, "ClsCompatibilityService", { enumerable: true, get: function () { return cls_compatibility_service_1.ClsCompatibilityService; } });
+Object.defineProperty(exports, "ClsServiceManager", { enumerable: true, get: function () { return cls_compatibility_service_1.ClsServiceManager; } });
+// Entity 级别的数据源装饰器
+var entity_datasource_decorator_1 = require("./decorators/entity-datasource.decorator");
+Object.defineProperty(exports, "DataSource", { enumerable: true, get: function () { return entity_datasource_decorator_1.DataSource; } });
+Object.defineProperty(exports, "DynamicDataSource", { enumerable: true, get: function () { return entity_datasource_decorator_1.DynamicDataSource; } });
+Object.defineProperty(exports, "BaseEntityWithDataSource", { enumerable: true, get: function () { return entity_datasource_decorator_1.BaseEntityWithDataSource; } });
+Object.defineProperty(exports, "getEntityDataSource", { enumerable: true, get: function () { return entity_datasource_decorator_1.getEntityDataSource; } });
+Object.defineProperty(exports, "hasEntityDataSource", { enumerable: true, get: function () { return entity_datasource_decorator_1.hasEntityDataSource; } });
+Object.defineProperty(exports, "isDynamicDataSourceEntity", { enumerable: true, get: function () { return entity_datasource_decorator_1.isDynamicDataSourceEntity; } });
+// 日志增强
+var logging_transactional_interceptor_1 = require("./logging-transactional.interceptor");
+Object.defineProperty(exports, "LoggingTransactionalInterceptor", { enumerable: true, get: function () { return logging_transactional_interceptor_1.LoggingTransactionalInterceptor; } });
+var logging_transactional_interceptor_2 = require("./logging-transactional.interceptor");
+Object.defineProperty(exports, "TRANSACTION_LOGGING_INTERCEPTOR", { enumerable: true, get: function () { return logging_transactional_interceptor_2.LoggingTransactionalInterceptor; } });
+// 错误处理
+var transaction_errors_1 = require("./transaction.errors");
+Object.defineProperty(exports, "TransactionError", { enumerable: true, get: function () { return transaction_errors_1.TransactionError; } });
+Object.defineProperty(exports, "TransactionErrorHandler", { enumerable: true, get: function () { return transaction_errors_1.TransactionErrorHandler; } });
+// 数据库适配器
+var database_adapter_1 = require("./database-adapter");
+Object.defineProperty(exports, "DatabaseAdapter", { enumerable: true, get: function () { return database_adapter_1.DatabaseAdapter; } });
+// 数据源工具（可在任意位置获取数据源）
+var data_source_util_1 = require("./data-source.util");
+Object.defineProperty(exports, "DataSourceUtil", { enumerable: true, get: function () { return data_source_util_1.DataSourceUtil; } });
+Object.defineProperty(exports, "getDataSource", { enumerable: true, get: function () { return data_source_util_1.getDataSource; } });
+Object.defineProperty(exports, "getDataSourceSafe", { enumerable: true, get: function () { return data_source_util_1.getDataSourceSafe; } });
+Object.defineProperty(exports, "getDefaultDataSource", { enumerable: true, get: function () { return data_source_util_1.getDefaultDataSource; } });
+Object.defineProperty(exports, "isDataSourceAvailable", { enumerable: true, get: function () { return data_source_util_1.isDataSourceAvailable; } });
+Object.defineProperty(exports, "withDataSource", { enumerable: true, get: function () { return data_source_util_1.withDataSource; } });
+Object.defineProperty(exports, "withTransaction", { enumerable: true, get: function () { return data_source_util_1.withTransaction; } });
+Object.defineProperty(exports, "addDataSource", { enumerable: true, get: function () { return data_source_util_1.addDataSource; } });
+Object.defineProperty(exports, "addDataSources", { enumerable: true, get: function () { return data_source_util_1.addDataSources; } });
+// 模块导出
+var transaction_module_1 = require("./transaction.module");
+Object.defineProperty(exports, "TransactionModule", { enumerable: true, get: function () { return transaction_module_1.TransactionModule; } });

package/dist/transaction/logging-transactional.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { ExecutionContext, CallHandler, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { TransactionManager } from './transaction-manager';
+/**
+ * 带日志的事务拦截器
+ * 提供详细的事务执行日志
+ */
+export declare class LoggingTransactionalInterceptor implements NestInterceptor {
+    private readonly transactionManager;
+    private readonly logger;
+    constructor(transactionManager: TransactionManager);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private handleTransaction;
+    private getTransactionOptions;
+    private getTransactionName;
+    private setClsContext;
+    private clearClsContext;
+}

package/dist/transaction/logging-transactional.interceptor.js

@@ -0,0 +1,163 @@
+"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 __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 LoggingTransactionalInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingTransactionalInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const transaction_manager_1 = require("./transaction-manager");
+const nestjs_cls_1 = require("nestjs-cls");
+/**
+ * 带日志的事务拦截器
+ * 提供详细的事务执行日志
+ */
+let LoggingTransactionalInterceptor = LoggingTransactionalInterceptor_1 = class LoggingTransactionalInterceptor {
+    constructor(transactionManager) {
+        this.transactionManager = transactionManager;
+        this.logger = new common_1.Logger(LoggingTransactionalInterceptor_1.name);
+    }
+    intercept(context, next) {
+        // 检查是否有事务元数据
+        const options = this.getTransactionOptions(context);
+        if (!options) {
+            return next.handle();
+        }
+        // 异步执行事务处理
+        return (0, rxjs_1.from)(this.handleTransaction(context, next, options));
+    }
+    handleTransaction(context, next, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            let status;
+            try {
+                // 获取事务定义
+                const definition = {
+                    propagation: options.propagation || transaction_manager_1.Propagation.REQUIRED,
+                    isolationLevel: options.isolation,
+                    readOnly: options.readOnly || false,
+                    timeout: options.timeout || 30,
+                    name: this.getTransactionName(context, options),
+                    dataSourceName: options.dataSource || 'default',
+                };
+                // 记录事务开始
+                this.logger.log(`Starting transaction: ${definition.name} ` +
+                    `(propagation: ${transaction_manager_1.Propagation[definition.propagation]}, ` +
+                    `dataSource: ${definition.dataSourceName}, ` +
+                    `timeout: ${definition.timeout}s)`);
+                // 获取事务
+                status = yield this.transactionManager.getTransaction(definition);
+                // 记录事务状态
+                if (status.isNewTransaction) {
+                    this.logger.debug(`New transaction created on ${definition.dataSourceName}`);
+                }
+                else {
+                    this.logger.debug(`Joined existing transaction on ${definition.dataSourceName} ` +
+                        `(level: ${status.nestingLevel})`);
+                }
+                // 设置 CLS 上下文
+                yield this.setClsContext(status);
+                // 执行方法
+                const result = yield next.handle().toPromise();
+                // 记录成功
+                const duration = Date.now() - startTime;
+                this.logger.log(`Transaction ${definition.name} completed successfully ` +
+                    `in ${duration}ms`);
+                // 提交事务
+                yield this.transactionManager.commit(status);
+                this.logger.debug(`Transaction ${definition.name} committed`);
+                return result;
+            }
+            catch (error) {
+                // 记录错误
+                const duration = Date.now() - startTime;
+                this.logger.error(`Transaction failed: ${error.message} ` +
+                    `(duration: ${duration}ms)`, error.stack);
+                // 回滚事务
+                if (status) {
+                    try {
+                        yield this.transactionManager.rollback(status);
+                        this.logger.debug(`Transaction rolled back successfully`);
+                    }
+                    catch (rollbackError) {
+                        this.logger.error(`Failed to rollback transaction: ${rollbackError.message}`, rollbackError.stack);
+                    }
+                }
+                throw error;
+            }
+            finally {
+                // 清理 CLS 上下文
+                this.clearClsContext();
+            }
+        });
+    }
+    getTransactionOptions(context) {
+        const handler = context.getHandler();
+        const controller = context.getClass();
+        // 检查方法级注解
+        const methodOptions = Reflect.getMetadata('transactional', handler);
+        if (methodOptions && !methodOptions.isClassLevel) {
+            return methodOptions;
+        }
+        // 检查类级注解
+        const classOptions = Reflect.getMetadata('transactional', controller);
+        if (classOptions && (classOptions.isClassLevel || !methodOptions)) {
+            return classOptions;
+        }
+        return null;
+    }
+    getTransactionName(context, options) {
+        if (options.name) {
+            return options.name;
+        }
+        const handler = context.getHandler();
+        const controller = context.getClass();
+        return `${controller.name}.${handler.name}`;
+    }
+    setClsContext(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const clsService = (_a = nestjs_cls_1.ClsServiceManager.getClsService) === null || _a === void 0 ? void 0 : _a.call(nestjs_cls_1.ClsServiceManager);
+            if (clsService) {
+                const em = this.transactionManager.getCurrentEntityManager(status.dataSourceName);
+                if (em) {
+                    clsService.set('entityManager', em);
+                }
+                clsService.set('transactionId', `${status.dataSourceName}_${Date.now()}`);
+                clsService.set('dataSource', status.dataSourceName);
+                clsService.set('startTime', status.startTime);
+            }
+        });
+    }
+    clearClsContext() {
+        var _a;
+        const clsService = (_a = nestjs_cls_1.ClsServiceManager.getClsService) === null || _a === void 0 ? void 0 : _a.call(nestjs_cls_1.ClsServiceManager);
+        if (clsService) {
+            clsService.set('entityManager', null);
+            clsService.set('transactionId', null);
+            clsService.set('dataSource', null);
+            clsService.set('startTime', null);
+        }
+    }
+};
+exports.LoggingTransactionalInterceptor = LoggingTransactionalInterceptor;
+exports.LoggingTransactionalInterceptor = LoggingTransactionalInterceptor = LoggingTransactionalInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [transaction_manager_1.TransactionManager])
+], LoggingTransactionalInterceptor);

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

@@ -0,0 +1,137 @@
+import { OnModuleInit } from '@nestjs/common';
+import { DataSource, EntityManager, DataSourceOptions } from 'typeorm';
+import { ModuleRef } from '@nestjs/core';
+/**
+ * 事务上下文信息
+ */
+interface TransactionContext {
+    dataSourceName: string;
+    entityManager: EntityManager;
+    dataSource: DataSource;
+}
+/**
+ * 动态注册的数据源配置
+ */
+export interface DynamicDataSourceConfig {
+    name: string;
+    dataSource: DataSource;
+    options?: DataSourceOptions;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+}
+/**
+ * 事务上下文管理器
+ * 使用 RequestScope 确保每个请求都有独立的事务上下文
+ */
+export declare class TransactionContextService implements OnModuleInit {
+    private readonly moduleRef;
+    private readonly config?;
+    private static readonly logger;
+    private readonly contextMap;
+    constructor(moduleRef: ModuleRef, config?: {
+        defaultDataSource?: string;
+        enableDynamicRegistration?: boolean;
+        logDataSourceRegistration?: boolean;
+    });
+    onModuleInit(): Promise<void>;
+    /**
+     * 获取当前请求的事务上下文服务
+     */
+    static getCurrent(): TransactionContextService | undefined;
+    /**
+     * 获取当前请求的数据源
+     * 方便其他模块快速访问数据源
+     * @param dataSourceName 数据源名称，默认为 'default'
+     * @returns DataSource 实例
+     */
+    static getDataSource(dataSourceName?: string): DataSource;
+    /**
+     * 设置事务上下文
+     */
+    setContext(dataSourceName: string, entityManager: EntityManager): void;
+    /**
+     * 获取事务上下文中的 EntityManager
+     */
+    getEntityManager(dataSourceName?: string): EntityManager | null;
+    /**
+     * 获取事务上下文中的 DataSource
+     * 如果上下文中没有，则尝试从 TypeORM 模块或全局注册表获取
+     */
+    getDataSource(dataSourceName?: string): DataSource | null;
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName?: string): boolean;
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getAllActiveContexts(): Map<string, TransactionContext>;
+    /**
+     * 清理所有事务上下文
+     */
+    clearContext(): void;
+    /**
+     * 清理指定数据源的事务上下文
+     */
+    clearContextForDataSource(dataSourceName: string): void;
+    /**
+     * 执行带事务的操作
+     * 如果已在事务中，使用现有的事务管理器
+     * 否则创建新事务
+     */
+    executeInTransaction<T>(dataSourceName: string, operation: (entityManager: EntityManager) => Promise<T>, isolationLevel?: any): Promise<T>;
+    /**
+     * 获取 DataSource 实例
+     */
+    private getDataSourceInstance;
+    /**
+     * 动态注册数据源
+     */
+    static addDataSource(name: string, dataSource: DataSource, options?: {
+        options?: DataSourceOptions;
+        metadata?: Record<string, any>;
+        replaceExisting?: boolean;
+    }): Promise<void>;
+    /**
+     * 移除动态注册的数据源
+     */
+    static removeDataSource(name: string): Promise<void>;
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    static getRegisteredDataSources(): string[];
+    /**
+     * 获取动态数据源的配置
+     */
+    static getDataSourceConfig(name: string): DynamicDataSourceConfig | undefined;
+    /**
+     * 检查数据源是否已注册
+     */
+    static isDataSourceRegistered(name: string): boolean;
+    /**
+     * 批量注册数据源
+     */
+    static addDataSources(dataSources: Array<{
+        name: string;
+        dataSource: DataSource;
+        options?: DataSourceOptions;
+        metadata?: Record<string, any>;
+    }>, options?: {
+        replaceExisting?: boolean;
+        continueOnError?: boolean;
+    }): Promise<void>;
+    /**
+     * 清理全局注册表（用于测试）
+     */
+    static clearGlobalRegistry(): void;
+    /**
+     * 获取默认数据源名称
+     */
+    getDefaultDataSourceName(): string;
+    /**
+     * 跨多个数据源执行分布式事务
+     * 使用两阶段提交模式
+     */
+    executeDistributedTransaction<T>(dataSourceNames: string[], operation: (entityManagers: Map<string, EntityManager>) => Promise<T>): Promise<T>;
+}
+export {};