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

package/transaction/data-source-registry.js

@@ -0,0 +1,349 @@
+"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 DataSourceRegistryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceRegistryService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const transaction_context_service_1 = require("./transaction-context.service");
+const database_adapter_1 = require("./database-adapter");
+/**
+ * 数据源注册表管理器
+ * 负责管理所有动态注册的数据源
+ */
+let DataSourceRegistryService = DataSourceRegistryService_1 = class DataSourceRegistryService {
+    constructor(config) {
+        this.logger = new common_1.Logger(DataSourceRegistryService_1.name);
+        this.healthCheckInterval = null;
+        this.healthStatuses = new Map();
+        this.config = {
+            enableHealthCheck: false,
+            healthCheckInterval: 30000, // 30秒
+            connectionTimeout: 5000, // 5秒
+            maxReconnectAttempts: 3,
+            logLifecycleEvents: true,
+            autoCleanup: true,
+        };
+        if (config) {
+            this.config = Object.assign(Object.assign({}, this.config), config);
+        }
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.enableHealthCheck) {
+                this.startHealthCheck();
+            }
+            if (this.config.logLifecycleEvents) {
+                this.logger.log(`Initialized with config: ${JSON.stringify(this.config)}`);
+            }
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.healthCheckInterval) {
+                clearInterval(this.healthCheckInterval);
+                this.healthCheckInterval = null;
+            }
+            // 清理所有动态注册的数据源
+            yield this.cleanupAllDataSources();
+        });
+    }
+    /**
+     * 注册新的数据源
+     */
+    registerDataSource(name, options, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 创建数据源
+                const dataSource = new typeorm_1.DataSource(options);
+                // 初始化连接
+                if (!dataSource.isInitialized) {
+                    yield dataSource.initialize();
+                }
+                // 注册到事务上下文服务
+                yield transaction_context_service_1.TransactionContextService.addDataSource(name, dataSource, {
+                    options,
+                    metadata,
+                });
+                // 初始化健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: true,
+                        lastChecked: new Date(),
+                    });
+                }
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Registered DataSource: ${name}`);
+                }
+                return dataSource;
+            }
+            catch (error) {
+                this.logger.error(`Failed to register DataSource ${name}:`, error.stack);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 注册已存在的数据源
+     */
+    registerExistingDataSource(name, dataSource, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield transaction_context_service_1.TransactionContextService.addDataSource(name, dataSource, {
+                metadata,
+            });
+            if (this.config.enableHealthCheck) {
+                this.healthStatuses.set(name, {
+                    name,
+                    isConnected: dataSource.isInitialized,
+                    lastChecked: new Date(),
+                });
+            }
+        });
+    }
+    /**
+     * 注销数据源
+     */
+    unregisterDataSource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (config) {
+                // 关闭数据源连接
+                if (config.dataSource.isInitialized) {
+                    yield config.dataSource.destroy();
+                }
+                // 从注册表中移除
+                yield transaction_context_service_1.TransactionContextService.removeDataSource(name);
+                this.healthStatuses.delete(name);
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Unregistered DataSource: ${name}`);
+                }
+            }
+        });
+    }
+    /**
+     * 获取数据源
+     */
+    getDataSource(name) {
+        const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+        return (config === null || config === void 0 ? void 0 : config.dataSource) || null;
+    }
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    getRegisteredDataSources() {
+        return transaction_context_service_1.TransactionContextService.getRegisteredDataSources();
+    }
+    /**
+     * 批量注册数据源
+     */
+    registerDataSources(configs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSources = [];
+            if (options === null || options === void 0 ? void 0 : options.parallel) {
+                // 并行注册
+                const promises = configs.map((config) => __awaiter(this, void 0, void 0, function* () {
+                    const ds = yield this.registerDataSource(config.name, config.options, config.metadata);
+                    return ds;
+                }));
+                try {
+                    const results = yield Promise.all(promises);
+                    dataSources.push(...results);
+                }
+                catch (error) {
+                    if (!(options === null || options === void 0 ? void 0 : options.continueOnError)) {
+                        // 清理已注册的数据源
+                        yield this.cleanupDataSources(dataSources.map((ds) => ds.options));
+                        throw error;
+                    }
+                }
+            }
+            else {
+                // 串行注册
+                for (const config of configs) {
+                    try {
+                        const ds = yield this.registerDataSource(config.name, config.options, config.metadata);
+                        dataSources.push(ds);
+                    }
+                    catch (error) {
+                        if (!(options === null || options === void 0 ? void 0 : options.continueOnError)) {
+                            // 清理已注册的数据源
+                            yield this.cleanupDataSources(dataSources.map((ds) => ds.options));
+                            throw error;
+                        }
+                    }
+                }
+            }
+            return dataSources;
+        });
+    }
+    /**
+     * 测试数据源连接
+     */
+    testConnection(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (!config) {
+                return false;
+            }
+            const startTime = Date.now();
+            try {
+                // 使用数据库适配器执行健康检查
+                const isHealthy = yield database_adapter_1.DatabaseAdapter.healthCheck(config.dataSource);
+                const responseTime = Date.now() - startTime;
+                if (!isHealthy) {
+                    throw new Error('Health check query failed');
+                }
+                // 更新健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: true,
+                        lastChecked: new Date(),
+                        responseTime,
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                // 更新健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: false,
+                        lastChecked: new Date(),
+                        error: error.message,
+                        responseTime: Date.now() - startTime,
+                    });
+                }
+                return false;
+            }
+        });
+    }
+    /**
+     * 获取所有数据源的健康状态
+     */
+    getHealthStatuses() {
+        return new Map(this.healthStatuses);
+    }
+    /**
+     * 重新连接数据源
+     */
+    reconnectDataSource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (!config || !config.options) {
+                throw new Error(`Cannot reconnect: DataSource '${name}' has no connection options`);
+            }
+            try {
+                // 关闭现有连接
+                if (config.dataSource.isInitialized) {
+                    yield config.dataSource.destroy();
+                }
+                // 重新初始化
+                yield config.dataSource.initialize();
+                // 测试连接
+                const isConnected = yield this.testConnection(name);
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Reconnected DataSource: ${name}, Success: ${isConnected}`);
+                }
+                return isConnected;
+            }
+            catch (error) {
+                this.logger.error(`Failed to reconnect DataSource ${name}:`, error.stack);
+                return false;
+            }
+        });
+    }
+    /**
+     * 开始健康检查
+     */
+    startHealthCheck() {
+        this.healthCheckInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const dataSources = this.getRegisteredDataSources();
+            for (const name of dataSources) {
+                yield this.testConnection(name);
+                // 自动重连
+                const status = this.healthStatuses.get(name);
+                if (!(status === null || status === void 0 ? void 0 : status.isConnected) && this.config.autoCleanup) {
+                    this.logger.warn(`DataSource ${name} is unhealthy, attempting reconnect...`);
+                    let attempts = 0;
+                    const maxAttempts = this.config.maxReconnectAttempts || 3;
+                    while (attempts < maxAttempts) {
+                        const reconnected = yield this.reconnectDataSource(name);
+                        if (reconnected) {
+                            break;
+                        }
+                        attempts++;
+                    }
+                    if (!((_a = this.healthStatuses.get(name)) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+                        this.logger.error(`Failed to reconnect DataSource ${name} after ${maxAttempts} attempts`);
+                    }
+                }
+            }
+        }), this.config.healthCheckInterval);
+        this.logger.log('Health check started');
+    }
+    /**
+     * 清理指定数据源
+     */
+    cleanupDataSources(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 找到对应的数据源并清理
+            for (const opt of options) {
+                // 这里需要从配置反向查找数据源名称
+                // 简化实现：遍历所有已注册的数据源
+                const names = this.getRegisteredDataSources();
+                for (const name of names) {
+                    const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+                    if ((config === null || config === void 0 ? void 0 : config.dataSource.options) === opt) {
+                        yield this.unregisterDataSource(name);
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * 清理所有动态数据源
+     */
+    cleanupAllDataSources() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const names = this.getRegisteredDataSources();
+            for (const name of names) {
+                yield this.unregisterDataSource(name);
+            }
+            if (this.config.logLifecycleEvents) {
+                this.logger.log('All dynamic DataSources cleaned up');
+            }
+        });
+    }
+};
+exports.DataSourceRegistryService = DataSourceRegistryService;
+exports.DataSourceRegistryService = DataSourceRegistryService = DataSourceRegistryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)('DATA_SOURCE_REGISTRY_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], DataSourceRegistryService);

package/transaction/database-adapter.d.ts

@@ -0,0 +1,44 @@
+import { DataSource, QueryRunner } from 'typeorm';
+/**
+ * 数据库类型
+ */
+export type DatabaseType = 'mysql' | 'mariadb' | 'postgres' | 'cockroachdb' | 'sqlite' | 'better-sqlite3' | 'mssql' | 'oracle' | 'mongodb' | 'cordova' | 'react-native' | 'nativescript' | 'sqljs' | 'expo' | 'capacitor';
+/**
+ * 数据库适配器
+ * 处理不同数据库的 SQL 语法差异
+ */
+export declare class DatabaseAdapter {
+    /**
+     * 获取数据库类型
+     */
+    static getDatabaseType(dataSource: DataSource): DatabaseType;
+    /**
+     * 检查数据库是否支持 SAVEPOINT
+     */
+    static supportsSavepoint(dataSource: DataSource): boolean;
+    /**
+     * 创建保存点
+     */
+    static createSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 回滚到保存点
+     */
+    static rollbackToSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 释放保存点
+     */
+    static releaseSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 执行健康检查查询
+     */
+    static healthCheck(dataSource: DataSource): Promise<boolean>;
+    /**
+     * 获取数据库特定的信息
+     */
+    static getDatabaseInfo(dataSource: DataSource): {
+        type: DatabaseType;
+        supportsSavepoint: boolean;
+        supportsNestedTransactions: boolean;
+        requiresReleaseSavepoint: boolean;
+    };
+}

package/transaction/database-adapter.js

@@ -0,0 +1,240 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseAdapter = void 0;
+/**
+ * 数据库适配器
+ * 处理不同数据库的 SQL 语法差异
+ */
+class DatabaseAdapter {
+    /**
+     * 获取数据库类型
+     */
+    static getDatabaseType(dataSource) {
+        return dataSource.options.type;
+    }
+    /**
+     * 检查数据库是否支持 SAVEPOINT
+     */
+    static supportsSavepoint(dataSource) {
+        const type = this.getDatabaseType(dataSource);
+        // MongoDB 不支持传统事务和 SAVEPOINT
+        if (type === 'mongodb') {
+            return false;
+        }
+        // 其他关系型数据库都支持 SAVEPOINT
+        return true;
+    }
+    /**
+     * 创建保存点
+     */
+    static createSavepoint(queryRunner, savepointName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 检查 queryRunner.connection 是否存在
+            if (!queryRunner.connection) {
+                // 如果没有 connection，使用标准 SQL 语法（最常见的情况）
+                yield queryRunner.query(`SAVEPOINT ${savepointName}`);
+                return;
+            }
+            const type = this.getDatabaseType(queryRunner.connection);
+            switch (type) {
+                case 'mysql':
+                case 'mariadb':
+                case 'postgres':
+                case 'cockroachdb':
+                case 'sqlite':
+                case 'better-sqlite3':
+                case 'sqljs':
+                case 'cordova':
+                case 'react-native':
+                case 'nativescript':
+                case 'expo':
+                case 'capacitor':
+                    // 标准 SQL 语法
+                    yield queryRunner.query(`SAVEPOINT ${savepointName}`);
+                    break;
+                case 'mssql':
+                    // SQL Server 使用 SAVE TRANSACTION
+                    yield queryRunner.query(`SAVE TRANSACTION ${savepointName}`);
+                    break;
+                case 'oracle':
+                    // Oracle 使用标准 SAVEPOINT 语法
+                    yield queryRunner.query(`SAVEPOINT ${savepointName}`);
+                    break;
+                case 'mongodb':
+                    throw new Error('MongoDB does not support SAVEPOINT. Use transactions instead.');
+                default:
+                    // 对于未知的数据库类型，尝试使用标准 SQL 语法
+                    yield queryRunner.query(`SAVEPOINT ${savepointName}`);
+            }
+        });
+    }
+    /**
+     * 回滚到保存点
+     */
+    static rollbackToSavepoint(queryRunner, savepointName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 检查 queryRunner.connection 是否存在
+            if (!queryRunner.connection) {
+                // 如果没有 connection，使用标准 SQL 语法（最常见的情况）
+                yield queryRunner.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+                return;
+            }
+            const type = this.getDatabaseType(queryRunner.connection);
+            switch (type) {
+                case 'mysql':
+                case 'mariadb':
+                case 'postgres':
+                case 'cockroachdb':
+                case 'sqlite':
+                case 'better-sqlite3':
+                case 'sqljs':
+                case 'cordova':
+                case 'react-native':
+                case 'nativescript':
+                case 'expo':
+                case 'capacitor':
+                case 'oracle':
+                    // 标准 SQL 语法
+                    yield queryRunner.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+                    break;
+                case 'mssql':
+                    // SQL Server 使用 ROLLBACK TRANSACTION
+                    yield queryRunner.query(`ROLLBACK TRANSACTION ${savepointName}`);
+                    break;
+                case 'mongodb':
+                    throw new Error('MongoDB does not support SAVEPOINT. Use transactions instead.');
+                default:
+                    // 对于未知的数据库类型，尝试使用标准 SQL 语法
+                    yield queryRunner.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+            }
+        });
+    }
+    /**
+     * 释放保存点
+     */
+    static releaseSavepoint(queryRunner, savepointName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 检查 queryRunner.connection 是否存在
+            if (!queryRunner.connection) {
+                // 如果没有 connection，尝试使用标准 SQL 语法
+                try {
+                    yield queryRunner.query(`RELEASE SAVEPOINT ${savepointName}`);
+                }
+                catch (error) {
+                    // 静默失败，因为某些数据库不支持 RELEASE
+                }
+                return;
+            }
+            const type = this.getDatabaseType(queryRunner.connection);
+            switch (type) {
+                case 'mysql':
+                case 'mariadb':
+                case 'postgres':
+                case 'cockroachdb':
+                case 'sqlite':
+                case 'better-sqlite3':
+                case 'sqljs':
+                case 'cordova':
+                case 'react-native':
+                case 'nativescript':
+                case 'expo':
+                case 'capacitor':
+                    // 标准 SQL 语法
+                    yield queryRunner.query(`RELEASE SAVEPOINT ${savepointName}`);
+                    break;
+                case 'oracle':
+                    // Oracle 不支持 RELEASE SAVEPOINT，保存点会在提交时自动释放
+                    // 不执行任何操作
+                    break;
+                case 'mssql':
+                    // SQL Server 不支持 RELEASE，保存点会在提交或回滚时自动清理
+                    // 不执行任何操作
+                    break;
+                case 'mongodb':
+                    // MongoDB 不支持
+                    break;
+                default:
+                    // 对于未知的数据库类型，尝试使用标准 SQL 语法
+                    // 如果失败也不抛出错误，因为某些数据库不需要显式释放
+                    try {
+                        yield queryRunner.query(`RELEASE SAVEPOINT ${savepointName}`);
+                    }
+                    catch (error) {
+                        // 静默失败，因为某些数据库不支持 RELEASE
+                    }
+            }
+        });
+    }
+    /**
+     * 执行健康检查查询
+     */
+    static healthCheck(dataSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = this.getDatabaseType(dataSource);
+            try {
+                switch (type) {
+                    case 'mysql':
+                    case 'mariadb':
+                        yield dataSource.query('SELECT 1');
+                        break;
+                    case 'postgres':
+                    case 'cockroachdb':
+                        yield dataSource.query('SELECT 1');
+                        break;
+                    case 'mssql':
+                        yield dataSource.query('SELECT 1');
+                        break;
+                    case 'oracle':
+                        yield dataSource.query('SELECT 1 FROM DUAL');
+                        break;
+                    case 'sqlite':
+                    case 'better-sqlite3':
+                    case 'sqljs':
+                    case 'cordova':
+                    case 'react-native':
+                    case 'nativescript':
+                    case 'expo':
+                    case 'capacitor':
+                        yield dataSource.query('SELECT 1');
+                        break;
+                    case 'mongodb':
+                        // MongoDB 使用不同的健康检查方式
+                        yield dataSource.query('{ ping: 1 }');
+                        break;
+                    default:
+                        // 默认使用 SELECT 1
+                        yield dataSource.query('SELECT 1');
+                }
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    /**
+     * 获取数据库特定的信息
+     */
+    static getDatabaseInfo(dataSource) {
+        const type = this.getDatabaseType(dataSource);
+        const supportsSavepoint = this.supportsSavepoint(dataSource);
+        // 检查是否需要显式释放 SAVEPOINT
+        const requiresReleaseSavepoint = !['oracle', 'mssql', 'mongodb'].includes(type);
+        return {
+            type,
+            supportsSavepoint,
+            supportsNestedTransactions: supportsSavepoint,
+            requiresReleaseSavepoint,
+        };
+    }
+}
+exports.DatabaseAdapter = DatabaseAdapter;

package/transaction/decorators/entity-datasource.decorator.d.ts

@@ -0,0 +1,62 @@
+import 'reflect-metadata';
+/**
+ * Entity 数据源装饰器
+ * 用于指定 Entity 应该使用哪个数据源
+ */
+export declare const ENTITY_DATASOURCE_METADATA_KEY = "entity:datasource";
+/**
+ * 数据源装饰器 - 为 Entity 指定数据源
+ *
+ * @param dataSourceName 数据源名称
+ *
+ * 使用示例：
+ * ```typescript
+ * @Entity('users')
+ * @DataSource('user_db')
+ * export class User {
+ *   @PrimaryGeneratedColumn()
+ *   id: number;
+ *
+ *   @Column()
+ *   name: string;
+ * }
+ * ```
+ */
+export declare function DataSource(dataSourceName: string): ClassDecorator;
+/**
+ * 获取 Entity 的数据源名称
+ * @param entityClass Entity 类或构造函数
+ * @returns 数据源名称，如果未指定则返回 null
+ */
+export declare function getEntityDataSource(entityClass: any): string | null;
+/**
+ * 检查 Entity 是否指定了数据源
+ * @param entityClass Entity 类或构造函数
+ * @returns 是否指定了数据源
+ */
+export declare function hasEntityDataSource(entityClass: any): boolean;
+/**
+ * 带数据源的 Entity 基类
+ * 继承这个基类的 Entity 可以通过实现 useDataSource 方法动态指定数据源
+ */
+export declare abstract class BaseEntityWithDataSource {
+    /**
+     * 子类可以重写此方法来动态指定数据源
+     * @returns 数据源名称
+     */
+    static useDataSource?(): string;
+    /**
+     * 实例方法版本，用于动态获取数据源
+     * @returns 数据源名称
+     */
+    getDataSource?(): string;
+}
+/**
+ * 动态数据源装饰器
+ * 标记 Entity 使用动态数据源（通过 useDataSource 方法指定）
+ */
+export declare function DynamicDataSource(): ClassDecorator;
+/**
+ * 检查 Entity 是否使用动态数据源
+ */
+export declare function isDynamicDataSourceEntity(entityClass: any): boolean;