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

package/dist/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/dist/transaction/data-source.util.d.ts

@@ -0,0 +1,142 @@
+import { DataSource } from 'typeorm';
+/**
+ * 数据源工具类
+ * 提供静态方法在任意位置获取数据源
+ */
+export declare class DataSourceUtil {
+    /**
+     * 获取数据源
+     * 按优先级从以下位置查找：
+     * 1. 当前请求上下文 (TransactionContextService)
+     * 2. 全局数据源存储 (GlobalDataSourceStorage)
+     *
+     * @param name 数据源名称，默认为 'default'
+     * @returns DataSource 实例
+     * @throws Error 如果数据源不存在
+     */
+    static getDataSource(name?: string): DataSource;
+    /**
+     * 安全获取数据源，不存在时返回 null
+     *
+     * @param name 数据源名称
+     * @returns DataSource 实例或 null
+     */
+    static getDataSourceSafe(name?: string): DataSource | null;
+    /**
+     * 获取默认数据源
+     */
+    static getDefaultDataSource(): DataSource;
+    /**
+     * 安全获取默认数据源
+     */
+    static getDefaultDataSourceSafe(): DataSource | null;
+    /**
+     * 检查数据源是否可用
+     *
+     * @param name 数据源名称
+     * @returns 是否可用
+     */
+    static isAvailable(name?: string): boolean;
+    /**
+     * 获取所有可用数据源名称
+     */
+    static getAvailableDataSourceNames(): string[];
+    /**
+     * 批量获取数据源
+     *
+     * @param names 数据源名称数组
+     * @returns 数据源 Map
+     */
+    static getDataSources(names: string[]): Map<string, DataSource>;
+    /**
+     * 获取所有已注册的数据源
+     */
+    static getAllDataSources(): Map<string, DataSource>;
+    /**
+     * 手动注册数据源（用于非模块场景）
+     *
+     * @param name 数据源名称
+     * @param dataSource DataSource 实例
+     * @param isDefault 是否设为默认数据源
+     */
+    static registerDataSource(name: string, dataSource: DataSource, isDefault?: boolean): void;
+    /**
+     * 批量注册数据源
+     *
+     * @param dataSources 数据源 Map
+     * @param defaultName 默认数据源名称
+     */
+    static registerDataSources(dataSources: Map<string, DataSource>, defaultName?: string): void;
+    /**
+     * 使用数据源执行操作
+     *
+     * @param name 数据源名称
+     * @param operation 要执行的操作
+     * @returns 操作结果
+     */
+    static withDataSource<T>(name: string, operation: (dataSource: DataSource) => Promise<T> | T): Promise<T>;
+    /**
+     * 使用默认数据源执行操作
+     *
+     * @param operation 要执行的操作
+     * @returns 操作结果
+     */
+    static withDefaultDataSource<T>(operation: (dataSource: DataSource) => Promise<T> | T): Promise<T>;
+    /**
+     * 在事务中执行操作
+     *
+     * @param name 数据源名称
+     * @param operation 要执行的操作
+     * @returns 操作结果
+     */
+    static withTransaction<T>(name: string, operation: (dataSource: DataSource) => Promise<T>): Promise<T>;
+    /**
+     * 在默认数据源的事务中执行操作
+     */
+    static withDefaultTransaction<T>(operation: (dataSource: DataSource) => Promise<T>): Promise<T>;
+    /**
+     * 测试数据源连接
+     *
+     * @param name 数据源名称
+     * @returns 连接是否正常
+     */
+    static testConnection(name?: string): Promise<boolean>;
+}
+/**
+ * 便捷的别名
+ */
+export declare const getDataSource: any;
+export declare const getDataSourceSafe: any;
+export declare const getDefaultDataSource: any;
+export declare const isDataSourceAvailable: any;
+export declare const withDataSource: any;
+export declare const withTransaction: any;
+/**
+ * 添加数据源到全局注册表
+ * 用于在 TypeOrmModule.forRootAsync 的 useFactory 中手动注册数据源
+ *
+ * @param name 数据源名称
+ * @param dataSource DataSource 实例
+ * @param isDefault 是否设为默认数据源
+ *
+ * @example
+ * ```typescript
+ * TypeOrmModule.forRootAsync({
+ *   inject: [ApiConfigService],
+ *   useFactory: (config: ApiConfigService) => {
+ *     const dsConfig = config.typeormConfig;
+ *     // 在这里注册，确保数据源初始化后立即可用
+ *     addDataSource('default', dataSource, true);
+ *     return dsConfig;
+ *   },
+ * }),
+ * ```
+ */
+export declare const addDataSource: any;
+/**
+ * 批量添加数据源
+ *
+ * @param dataSources 数据源 Map
+ * @param defaultName 默认数据源名称
+ */
+export declare const addDataSources: any;