@nest-omni/core 4.1.3-14 → 4.1.3-17

package/transaction/transaction-context.service.js

@@ -1,411 +0,0 @@
-"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/transaction/transaction-manager.d.ts

@@ -1,230 +0,0 @@
-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 {};