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

package/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 {};

package/transaction/transaction-context.service.js

@@ -0,0 +1,411 @@
+"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 TransactionContextService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionContextService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const typeorm_1 = require("@nestjs/typeorm");
+const async_hooks_1 = require("async_hooks");
+/**
+ * 全局数据源注册表
+ * 在模块初始化时设置，跨请求共享
+ */
+class GlobalDataSourceRegistry {
+    static setConfig(config) {
+        GlobalDataSourceRegistry.config = config;
+    }
+    static getConfig() {
+        return GlobalDataSourceRegistry.config;
+    }
+    static addDataSource(name, config) {
+        GlobalDataSourceRegistry.dataSources.set(name, config);
+    }
+    static removeDataSource(name) {
+        GlobalDataSourceRegistry.dataSources.delete(name);
+    }
+    static getDataSource(name) {
+        return GlobalDataSourceRegistry.dataSources.get(name);
+    }
+    static getAllDataSources() {
+        return Array.from(GlobalDataSourceRegistry.dataSources.keys());
+    }
+    static hasDataSource(name) {
+        return GlobalDataSourceRegistry.dataSources.has(name);
+    }
+    static clear() {
+        GlobalDataSourceRegistry.dataSources.clear();
+    }
+}
+GlobalDataSourceRegistry.dataSources = new Map();
+GlobalDataSourceRegistry.config = {};
+/**
+ * AsyncLocalStorage 实例
+ * 用于在每个请求上下文中存储 TransactionContextService
+ */
+const asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+/**
+ * 事务上下文管理器
+ * 使用 RequestScope 确保每个请求都有独立的事务上下文
+ */
+let TransactionContextService = TransactionContextService_1 = class TransactionContextService {
+    constructor(moduleRef, config) {
+        this.moduleRef = moduleRef;
+        this.config = config;
+        this.contextMap = new Map();
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 将配置存储到全局注册表
+            GlobalDataSourceRegistry.setConfig(this.config);
+            // 将当前实例存储到 AsyncLocalStorage
+            asyncLocalStorage.enterWith(this);
+        });
+    }
+    /**
+     * 获取当前请求的事务上下文服务
+     */
+    static getCurrent() {
+        return asyncLocalStorage.getStore();
+    }
+    /**
+     * 获取当前请求的数据源
+     * 方便其他模块快速访问数据源
+     * @param dataSourceName 数据源名称，默认为 'default'
+     * @returns DataSource 实例
+     */
+    static getDataSource(dataSourceName = 'default') {
+        const currentService = this.getCurrent();
+        if (currentService) {
+            // 从当前服务获取数据源
+            const dataSource = currentService.getDataSource(dataSourceName);
+            if (dataSource) {
+                return dataSource;
+            }
+        }
+        // 如果当前服务中没有，尝试从全局注册表获取
+        const globalDataSource = GlobalDataSourceRegistry.getDataSource(dataSourceName);
+        if (globalDataSource) {
+            return globalDataSource.dataSource;
+        }
+        throw new Error(`DataSource '${dataSourceName}' not found. Please ensure it is registered ` +
+            `either through TypeOrmModule or addDataSource(), and that the method is ` +
+            `called within a request context.`);
+    }
+    /**
+     * 设置事务上下文
+     */
+    setContext(dataSourceName, entityManager) {
+        const dataSource = this.moduleRef.get((0, typeorm_1.getDataSourceToken)(dataSourceName), {
+            strict: false,
+        });
+        this.contextMap.set(dataSourceName, {
+            dataSourceName,
+            entityManager,
+            dataSource,
+        });
+    }
+    /**
+     * 获取事务上下文中的 EntityManager
+     */
+    getEntityManager(dataSourceName = 'default') {
+        const context = this.contextMap.get(dataSourceName);
+        return (context === null || context === void 0 ? void 0 : context.entityManager) || null;
+    }
+    /**
+     * 获取事务上下文中的 DataSource
+     * 如果上下文中没有，则尝试从 TypeORM 模块或全局注册表获取
+     */
+    getDataSource(dataSourceName = 'default') {
+        // 1. 首先检查事务上下文
+        const context = this.contextMap.get(dataSourceName);
+        if (context === null || context === void 0 ? void 0 : context.dataSource) {
+            return context.dataSource;
+        }
+        // 2. 检查全局注册表中的动态数据源
+        const dynamicDataSource = GlobalDataSourceRegistry.getDataSource(dataSourceName);
+        if (dynamicDataSource) {
+            return dynamicDataSource.dataSource;
+        }
+        // 3. 尝试从 TypeORM 模块获取
+        try {
+            const dataSource = this.moduleRef.get((0, typeorm_1.getDataSourceToken)(dataSourceName), {
+                strict: false,
+            });
+            if (dataSource) {
+                return dataSource;
+            }
+        }
+        catch (error) {
+            // 忽略未找到数据源的错误
+        }
+        return null;
+    }
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName = 'default') {
+        var _a, _b;
+        const context = this.contextMap.get(dataSourceName);
+        return ((_b = (_a = context === null || context === void 0 ? void 0 : context.entityManager) === null || _a === void 0 ? void 0 : _a.queryRunner) === null || _b === void 0 ? void 0 : _b.isTransactionActive) || false;
+    }
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getAllActiveContexts() {
+        var _a, _b;
+        const activeContexts = new Map();
+        for (const [name, context] of this.contextMap) {
+            if ((_b = (_a = context.entityManager) === null || _a === void 0 ? void 0 : _a.queryRunner) === null || _b === void 0 ? void 0 : _b.isTransactionActive) {
+                activeContexts.set(name, context);
+            }
+        }
+        return activeContexts;
+    }
+    /**
+     * 清理所有事务上下文
+     */
+    clearContext() {
+        this.contextMap.clear();
+    }
+    /**
+     * 清理指定数据源的事务上下文
+     */
+    clearContextForDataSource(dataSourceName) {
+        this.contextMap.delete(dataSourceName);
+    }
+    /**
+     * 执行带事务的操作
+     * 如果已在事务中，使用现有的事务管理器
+     * 否则创建新事务
+     */
+    executeInTransaction(dataSourceName, operation, isolationLevel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const existingEntityManager = this.getEntityManager(dataSourceName);
+            if (existingEntityManager && ((_a = existingEntityManager.queryRunner) === null || _a === void 0 ? void 0 : _a.isTransactionActive)) {
+                // 已在事务中，直接使用现有的 EntityManager
+                return operation(existingEntityManager);
+            }
+            // 不在事务中，创建新事务
+            const dataSource = yield this.getDataSourceInstance(dataSourceName);
+            return yield dataSource.transaction((entityManager) => __awaiter(this, void 0, void 0, function* () {
+                this.setContext(dataSourceName, entityManager);
+                try {
+                    const result = yield operation(entityManager);
+                    return result;
+                }
+                finally {
+                    this.clearContextForDataSource(dataSourceName);
+                }
+            }));
+        });
+    }
+    /**
+     * 获取 DataSource 实例
+     */
+    getDataSourceInstance(dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 首先检查全局注册表中的动态数据源
+            const dynamicDataSource = GlobalDataSourceRegistry.getDataSource(dataSourceName);
+            if (dynamicDataSource) {
+                return dynamicDataSource.dataSource;
+            }
+            // 然后检查 TypeORM 模块注册的数据源
+            try {
+                const dataSource = this.moduleRef.get((0, typeorm_1.getDataSourceToken)(dataSourceName), {
+                    strict: false,
+                });
+                if (dataSource) {
+                    return dataSource;
+                }
+            }
+            catch (error) {
+                // 忽略未找到数据源的错误，继续检查其他地方
+            }
+            throw new Error(`DataSource '${dataSourceName}' not found. Please ensure it is registered either through TypeOrmModule or addDataSource()`);
+        });
+    }
+    /**
+     * 动态注册数据源
+     */
+    static addDataSource(name, dataSource, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = GlobalDataSourceRegistry.getConfig();
+            // 检查是否允许动态注册
+            if ((config === null || config === void 0 ? void 0 : config.enableDynamicRegistration) === false) {
+                throw new Error('Dynamic data source registration is disabled');
+            }
+            // 检查是否已存在
+            if (GlobalDataSourceRegistry.hasDataSource(name) && !(options === null || options === void 0 ? void 0 : options.replaceExisting)) {
+                throw new Error(`DataSource '${name}' already registered. Use replaceExisting: true to replace.`);
+            }
+            // 验证数据源
+            if (!dataSource || !dataSource.isInitialized) {
+                throw new Error(`DataSource '${name}' must be initialized before registration`);
+            }
+            // 注册数据源
+            const dsConfig = {
+                name,
+                dataSource,
+                options: options === null || options === void 0 ? void 0 : options.options,
+                metadata: options === null || options === void 0 ? void 0 : options.metadata,
+                createdAt: new Date(),
+            };
+            GlobalDataSourceRegistry.addDataSource(name, dsConfig);
+            // 记录日志
+            if ((config === null || config === void 0 ? void 0 : config.logDataSourceRegistration) !== false) {
+                TransactionContextService_1.logger.log(`Registered dynamic DataSource: ${name}`);
+            }
+        });
+    }
+    /**
+     * 移除动态注册的数据源
+     */
+    static removeDataSource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const removed = GlobalDataSourceRegistry.hasDataSource(name);
+            if (removed) {
+                GlobalDataSourceRegistry.removeDataSource(name);
+                // 清理当前请求中该数据源的事务上下文
+                const currentService = asyncLocalStorage.getStore();
+                if (currentService) {
+                    currentService.clearContextForDataSource(name);
+                }
+                TransactionContextService_1.logger.log(`Removed dynamic DataSource: ${name}`);
+            }
+        });
+    }
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    static getRegisteredDataSources() {
+        return GlobalDataSourceRegistry.getAllDataSources();
+    }
+    /**
+     * 获取动态数据源的配置
+     */
+    static getDataSourceConfig(name) {
+        return GlobalDataSourceRegistry.getDataSource(name);
+    }
+    /**
+     * 检查数据源是否已注册
+     */
+    static isDataSourceRegistered(name) {
+        return GlobalDataSourceRegistry.hasDataSource(name);
+    }
+    /**
+     * 批量注册数据源
+     */
+    static addDataSources(dataSources, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            for (const ds of dataSources) {
+                try {
+                    yield TransactionContextService_1.addDataSource(ds.name, ds.dataSource, {
+                        options: ds.options,
+                        metadata: ds.metadata,
+                        replaceExisting: options === null || options === void 0 ? void 0 : options.replaceExisting,
+                    });
+                }
+                catch (error) {
+                    if (options === null || options === void 0 ? void 0 : options.continueOnError) {
+                        errors.push(error);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            if (errors.length > 0) {
+                throw new Error(`Failed to register some DataSources: ${errors.map(e => e.message).join(', ')}`);
+            }
+        });
+    }
+    /**
+     * 清理全局注册表（用于测试）
+     */
+    static clearGlobalRegistry() {
+        GlobalDataSourceRegistry.clear();
+    }
+    /**
+     * 获取默认数据源名称
+     */
+    getDefaultDataSourceName() {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.defaultDataSource) || 'default';
+    }
+    /**
+     * 跨多个数据源执行分布式事务
+     * 使用两阶段提交模式
+     */
+    executeDistributedTransaction(dataSourceNames, operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entityManagers = new Map();
+            const dataSources = [];
+            try {
+                // 获取所有数据源
+                for (const dataSourceName of dataSourceNames) {
+                    const dataSource = yield this.getDataSourceInstance(dataSourceName);
+                    dataSources.push(dataSource);
+                }
+                // 开始分布式事务
+                const results = yield Promise.all(dataSources.map((dataSource) => __awaiter(this, void 0, void 0, function* () {
+                    return dataSource.transaction((entityManager) => __awaiter(this, void 0, void 0, function* () {
+                        const index = dataSources.indexOf(dataSource);
+                        const dataSourceName = dataSourceNames[index];
+                        entityManagers.set(dataSourceName, entityManager);
+                        this.setContext(dataSourceName, entityManager);
+                        // 第一阶段：准备
+                        // 这里只是执行操作，实际的提交将在所有操作成功后进行
+                        return { dataSourceName, entityManager };
+                    }));
+                })));
+                // 执行业务操作
+                const result = yield operation(entityManagers);
+                return result;
+            }
+            catch (error) {
+                // 发生错误时清理上下文
+                for (const dataSourceName of dataSourceNames) {
+                    this.clearContextForDataSource(dataSourceName);
+                }
+                throw error;
+            }
+            finally {
+                // 清理上下文
+                for (const dataSourceName of dataSourceNames) {
+                    this.clearContextForDataSource(dataSourceName);
+                }
+            }
+        });
+    }
+};
+exports.TransactionContextService = TransactionContextService;
+TransactionContextService.logger = new common_1.Logger(TransactionContextService_1.name);
+exports.TransactionContextService = TransactionContextService = TransactionContextService_1 = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('TRANSACTION_CONFIG')),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
+], TransactionContextService);