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

package/dist/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);

package/dist/transaction/transaction-manager.d.ts

@@ -0,0 +1,230 @@
+import { EntityManager, DataSource, QueryRunner } from 'typeorm';
+import { TransactionContextService } from './transaction-context.service';
+/**
+ * 事务传播行为
+ */
+export declare enum Propagation {
+    /**
+     * 支持当前事务，如果不存在就创建一个新事务
+     */
+    REQUIRED = 0,
+    /**
+     * 支持当前事务，如果不存在就以非事务方式执行
+     */
+    SUPPORTS = 1,
+    /**
+     * 支持当前事务，如果不存在就抛出异常
+     */
+    MANDATORY = 2,
+    /**
+     * 创建新事务，如果当前存在事务就挂起它
+     */
+    REQUIRES_NEW = 3,
+    /**
+     * 以非事务方式执行，如果当前存在事务就挂起它
+     */
+    NOT_SUPPORTED = 4,
+    /**
+     * 以非事务方式执行，如果当前存在事务就抛出异常
+     */
+    NEVER = 5,
+    /**
+     * 如果当前存在事务，就在嵌套事务中执行
+     */
+    NESTED = 6
+}
+/**
+ * 事务隔离级别
+ */
+export declare enum IsolationLevel {
+    DEFAULT = -1,
+    READ_UNCOMMITTED = 1,
+    READ_COMMITTED = 2,
+    REPEATABLE_READ = 3,
+    SERIALIZABLE = 4
+}
+/**
+ * 事务超时处理回调
+ */
+export interface TransactionTimeoutCallback {
+    (status: TransactionStatus): Promise<void> | void;
+}
+/**
+ * 事务定义
+ */
+export interface TransactionDefinition {
+    propagation: Propagation;
+    isolationLevel?: IsolationLevel;
+    readOnly?: boolean;
+    timeout?: number;
+    name?: string;
+    dataSourceName?: string;
+    onTimeout?: TransactionTimeoutCallback;
+}
+/**
+ * 事务状态
+ */
+export interface TransactionStatus {
+    isCompleted: boolean;
+    isRollbackOnly: boolean;
+    isNewTransaction: boolean;
+    dataSourceName: string;
+    startTime: Date;
+    definition: TransactionDefinition;
+    nestingLevel: number;
+    timeoutTimer?: NodeJS.Timeout;
+}
+/**
+ * 事务资源
+ */
+interface TransactionResource {
+    dataSourceName: string;
+    dataSource: DataSource;
+    queryRunner: QueryRunner;
+    transactionStarted: boolean;
+    nestingLevel: number;
+    savepoints: string[];
+}
+/**
+ * 挂起的事务资源
+ */
+interface SuspendedTransaction {
+    dataSourceName: string;
+    resource: TransactionResource;
+    status: TransactionStatus;
+}
+/**
+ * 统一的事务上下文管理类
+ * 减少状态管理复杂度，避免不一致
+ */
+export declare class TransactionContextManager {
+    private readonly resources;
+    private readonly activeTransactions;
+    private readonly suspendedTransactions;
+    getResource(name: string): TransactionResource | undefined;
+    getActiveTransaction(name: string): TransactionStatus | null;
+    getAllActiveTransactions(): Map<string, TransactionStatus>;
+    getAllResources(): Map<string, TransactionResource>;
+    setResource(name: string, resource: TransactionResource): void;
+    setActiveTransaction(name: string, status: TransactionStatus): void;
+    deleteResource(name: string): boolean;
+    deleteActiveTransaction(name: string): boolean;
+    suspendTransaction(name: string): SuspendedTransaction | null;
+    resumeSuspendedTransaction(name: string): SuspendedTransaction | null;
+    clear(): void;
+    getStats(): {
+        activeTransactions: {
+            dataSource: string;
+            nestingLevel: number;
+            startTime: Date;
+            propagation: Propagation;
+            isRollbackOnly: boolean;
+        }[];
+        resources: {
+            dataSource: string;
+            hasTransaction: boolean;
+            nestingLevel: number;
+        }[];
+        suspendedTransactions: number;
+    };
+}
+/**
+ * 事务管理器
+ * 统一管理多数据源事务，支持自动嵌套
+ */
+export declare class TransactionManager {
+    private readonly transactionContext;
+    private readonly contextManager;
+    private readonly config?;
+    private readonly logger;
+    constructor(transactionContext: TransactionContextService, contextManager: TransactionContextManager, config?: {
+        defaultTimeout?: number;
+        defaultReadOnly?: boolean;
+        logTransactionDetails?: boolean;
+    });
+    /**
+     * 获取或创建事务
+     * 处理各种传播行为
+     */
+    getTransaction(definition: TransactionDefinition): Promise<TransactionStatus>;
+    /**
+     * 提交事务
+     */
+    commit(status: TransactionStatus): Promise<void>;
+    /**
+     * 回滚事务
+     */
+    rollback(status: TransactionStatus): Promise<void>;
+    /**
+     * 获取当前事务的 EntityManager
+     */
+    getCurrentEntityManager(dataSourceName?: string): EntityManager | null;
+    /**
+     * 获取当前事务状态
+     */
+    getCurrentTransaction(dataSourceName?: string): TransactionStatus | null;
+    /**
+     * 获取事务统计
+     */
+    getTransactionStats(): {
+        activeTransactions: {
+            dataSource: string;
+            nestingLevel: number;
+            startTime: Date;
+            propagation: Propagation;
+            isRollbackOnly: boolean;
+        }[];
+        resources: {
+            dataSource: string;
+            hasTransaction: boolean;
+            nestingLevel: number;
+        }[];
+        suspendedTransactions: number;
+    };
+    /**
+     * 根据 Entity 获取数据源名称
+     * 支持装饰器、静态方法和动态方法
+     */
+    getDataSourceForEntity(entityClassOrInstance: Function | Object): string | null;
+    /**
+     * 为 Entity 获取或创建 EntityManager
+     * 自动检测 Entity 的数据源
+     */
+    getEntityManagerForEntity(entityClassOrInstance: any, fallbackDataSourceName?: string): EntityManager | null;
+    private handleRequired;
+    private handleRequiresNew;
+    private handleNested;
+    private handleSupports;
+    private handleNotSupported;
+    private handleMandatory;
+    private handleNever;
+    private createNewTransaction;
+    private createParticipatingTransaction;
+    private getActiveTransaction;
+    private getDataSource;
+    private convertIsolationLevel;
+    private markCompleted;
+    private removeActiveTransaction;
+    private markParentForRollback;
+    private rollbackOnCommitException;
+    private cleanupResource;
+    /**
+     * 恢复挂起的事务 - 已移到 TransactionContextManager 中
+     * 此方法保留以兼容
+     */
+    private resumeSuspendedTransaction;
+    /**
+     * 获取事务超时时间（毫秒）
+     */
+    private getTimeoutMs;
+    /**
+     * 处理事务超时
+     */
+    private handleTransactionTimeout;
+    /**
+     * 清理事务定时器
+     * 确保定时器被正确清理,避免内存泄漏
+     */
+    private clearTimeout;
+}
+export {};