@nest-omni/core 4.1.3-15 → 4.1.3-18

package/transaction/transaction-manager.js

@@ -1,1001 +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 TransactionManager_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionManager = exports.TransactionContextManager = exports.IsolationLevel = exports.Propagation = void 0;
-const common_1 = require("@nestjs/common");
-const transaction_context_service_1 = require("./transaction-context.service");
-const entity_datasource_decorator_1 = require("./decorators/entity-datasource.decorator");
-const transaction_errors_1 = require("./transaction.errors");
-const transaction_synchronization_1 = require("./transaction-synchronization");
-const database_adapter_1 = require("./database-adapter");
-/**
- * 事务传播行为
- */
-var Propagation;
-(function (Propagation) {
-    /**
-     * 支持当前事务，如果不存在就创建一个新事务
-     */
-    Propagation[Propagation["REQUIRED"] = 0] = "REQUIRED";
-    /**
-     * 支持当前事务，如果不存在就以非事务方式执行
-     */
-    Propagation[Propagation["SUPPORTS"] = 1] = "SUPPORTS";
-    /**
-     * 支持当前事务，如果不存在就抛出异常
-     */
-    Propagation[Propagation["MANDATORY"] = 2] = "MANDATORY";
-    /**
-     * 创建新事务，如果当前存在事务就挂起它
-     */
-    Propagation[Propagation["REQUIRES_NEW"] = 3] = "REQUIRES_NEW";
-    /**
-     * 以非事务方式执行，如果当前存在事务就挂起它
-     */
-    Propagation[Propagation["NOT_SUPPORTED"] = 4] = "NOT_SUPPORTED";
-    /**
-     * 以非事务方式执行，如果当前存在事务就抛出异常
-     */
-    Propagation[Propagation["NEVER"] = 5] = "NEVER";
-    /**
-     * 如果当前存在事务，就在嵌套事务中执行
-     */
-    Propagation[Propagation["NESTED"] = 6] = "NESTED";
-})(Propagation || (exports.Propagation = Propagation = {}));
-/**
- * 事务隔离级别
- */
-var IsolationLevel;
-(function (IsolationLevel) {
-    IsolationLevel[IsolationLevel["DEFAULT"] = -1] = "DEFAULT";
-    IsolationLevel[IsolationLevel["READ_UNCOMMITTED"] = 1] = "READ_UNCOMMITTED";
-    IsolationLevel[IsolationLevel["READ_COMMITTED"] = 2] = "READ_COMMITTED";
-    IsolationLevel[IsolationLevel["REPEATABLE_READ"] = 3] = "REPEATABLE_READ";
-    IsolationLevel[IsolationLevel["SERIALIZABLE"] = 4] = "SERIALIZABLE";
-})(IsolationLevel || (exports.IsolationLevel = IsolationLevel = {}));
-/**
- * 统一的事务上下文管理类
- * 减少状态管理复杂度，避免不一致
- */
-let TransactionContextManager = class TransactionContextManager {
-    constructor() {
-        this.resources = new Map();
-        this.activeTransactions = new Map();
-        this.suspendedTransactions = new Map();
-    }
-    // 获取方法
-    getResource(name) {
-        return this.resources.get(name);
-    }
-    getActiveTransaction(name) {
-        return this.activeTransactions.get(name) || null;
-    }
-    getAllActiveTransactions() {
-        return new Map(this.activeTransactions);
-    }
-    getAllResources() {
-        return new Map(this.resources);
-    }
-    // 设置方法
-    setResource(name, resource) {
-        this.resources.set(name, resource);
-    }
-    setActiveTransaction(name, status) {
-        this.activeTransactions.set(name, status);
-    }
-    // 删除方法
-    deleteResource(name) {
-        return this.resources.delete(name);
-    }
-    deleteActiveTransaction(name) {
-        return this.activeTransactions.delete(name);
-    }
-    // 挂起和恢复
-    suspendTransaction(name) {
-        const resource = this.resources.get(name);
-        const status = this.activeTransactions.get(name);
-        if (resource && status) {
-            const suspended = {
-                dataSourceName: name,
-                resource,
-                status,
-            };
-            // Use Map for O(1) lookup
-            if (!this.suspendedTransactions.has(name)) {
-                this.suspendedTransactions.set(name, []);
-            }
-            this.suspendedTransactions.get(name).push(suspended);
-            this.resources.delete(name);
-            this.activeTransactions.delete(name);
-            return suspended;
-        }
-        return null;
-    }
-    resumeSuspendedTransaction(name) {
-        const stack = this.suspendedTransactions.get(name);
-        if (stack && stack.length > 0) {
-            const suspended = stack.pop(); // LIFO order
-            if (stack.length === 0) {
-                this.suspendedTransactions.delete(name);
-            }
-            this.resources.set(name, suspended.resource);
-            this.activeTransactions.set(name, suspended.status);
-            return suspended;
-        }
-        return null;
-    }
-    // 清理所有状态
-    clear() {
-        this.resources.clear();
-        this.activeTransactions.clear();
-        this.suspendedTransactions.clear();
-    }
-    // 获取统计信息
-    getStats() {
-        let totalSuspended = 0;
-        this.suspendedTransactions.forEach(stack => {
-            totalSuspended += stack.length;
-        });
-        return {
-            activeTransactions: Array.from(this.activeTransactions.values()).map(tx => ({
-                dataSource: tx.dataSourceName,
-                nestingLevel: tx.nestingLevel,
-                startTime: tx.startTime,
-                propagation: tx.definition.propagation,
-                isRollbackOnly: tx.isRollbackOnly,
-            })),
-            resources: Array.from(this.resources.entries()).map(([name, resource]) => ({
-                dataSource: name,
-                hasTransaction: resource.transactionStarted,
-                nestingLevel: resource.nestingLevel,
-            })),
-            suspendedTransactions: totalSuspended,
-        };
-    }
-};
-exports.TransactionContextManager = TransactionContextManager;
-exports.TransactionContextManager = TransactionContextManager = __decorate([
-    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST })
-], TransactionContextManager);
-/**
- * 事务管理器
- * 统一管理多数据源事务，支持自动嵌套
- */
-let TransactionManager = TransactionManager_1 = class TransactionManager {
-    constructor(transactionContext, contextManager, config) {
-        this.transactionContext = transactionContext;
-        this.contextManager = contextManager;
-        this.config = config;
-        this.logger = new common_1.Logger(TransactionManager_1.name);
-    }
-    /**
-     * 获取或创建事务
-     * 处理各种传播行为
-     */
-    getTransaction(definition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Validate input
-            if (!definition) {
-                throw transaction_errors_1.TransactionError.invalidState('Transaction definition is required');
-            }
-            if (definition.timeout !== undefined && definition.timeout < 0) {
-                throw transaction_errors_1.TransactionError.invalidState('Transaction timeout must be non-negative');
-            }
-            // Set default propagation if not specified
-            if (definition.propagation === undefined) {
-                definition.propagation = Propagation.REQUIRED;
-            }
-            const dataSourceName = definition.dataSourceName || 'default';
-            const existingTx = this.contextManager.getActiveTransaction(dataSourceName);
-            switch (definition.propagation) {
-                case Propagation.REQUIRED:
-                    return this.handleRequired(definition, existingTx, dataSourceName);
-                case Propagation.REQUIRES_NEW:
-                    return this.handleRequiresNew(definition, dataSourceName);
-                case Propagation.NESTED:
-                    return this.handleNested(definition, existingTx, dataSourceName);
-                case Propagation.SUPPORTS:
-                    return this.handleSupports(definition, existingTx, dataSourceName);
-                case Propagation.NOT_SUPPORTED:
-                    return this.handleNotSupported(definition, dataSourceName);
-                case Propagation.MANDATORY:
-                    return this.handleMandatory(definition, existingTx, dataSourceName);
-                case Propagation.NEVER:
-                    return this.handleNever(definition, existingTx, dataSourceName);
-                default:
-                    throw transaction_errors_1.TransactionError.unsupportedPropagation(definition.propagation);
-            }
-        });
-    }
-    /**
-     * 提交事务
-     */
-    commit(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (status.isCompleted) {
-                return;
-            }
-            if (status.isRollbackOnly) {
-                yield this.rollback(status);
-                return;
-            }
-            const resource = this.contextManager.getResource(status.dataSourceName);
-            let actualCompletionStatus = transaction_synchronization_1.TransactionSynchronizationStatus.STATUS_COMMITTED;
-            try {
-                // 触发 beforeCommit 回调
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerBeforeCommit(status.definition.readOnly || false, status.dataSourceName);
-                }
-                // 触发 beforeCompletion 回调
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerBeforeCompletion(status.dataSourceName);
-                }
-                if (status.isNewTransaction && (resource === null || resource === void 0 ? void 0 : resource.transactionStarted)) {
-                    try {
-                        yield resource.queryRunner.commitTransaction();
-                        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                            this.logger.log(`Committed transaction on ${status.dataSourceName}`);
-                        }
-                    }
-                    catch (commitError) {
-                        this.logger.error(`Failed to commit transaction on ${status.dataSourceName}`, commitError);
-                        throw commitError;
-                    }
-                }
-                else if (status.nestingLevel > 1 && (resource === null || resource === void 0 ? void 0 : resource.transactionStarted) && resource.savepoints.length > 0) {
-                    // 嵌套事务提交：释放最近的保存点
-                    const savepointName = resource.savepoints.pop();
-                    try {
-                        yield database_adapter_1.DatabaseAdapter.releaseSavepoint(resource.queryRunner, savepointName);
-                        if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logTransactionDetails) {
-                            this.logger.log(`Released savepoint ${savepointName} on ${status.dataSourceName}`);
-                        }
-                    }
-                    catch (releaseError) {
-                        this.logger.error(`Failed to release savepoint ${savepointName}`, releaseError);
-                        throw releaseError;
-                    }
-                }
-                this.markCompleted(status);
-                this.contextManager.deleteActiveTransaction(status.dataSourceName);
-                // 触发 afterCommit 回调
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerAfterCommit(status.dataSourceName);
-                }
-                // 清理超时定时器
-                this.clearTimeout(status);
-            }
-            catch (error) {
-                actualCompletionStatus = transaction_synchronization_1.TransactionSynchronizationStatus.STATUS_ROLLED_BACK;
-                yield this.rollbackOnCommitException(status, error);
-                throw error;
-            }
-            finally {
-                // 触发 afterCompletion 回调 - 使用实际完成状态
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerAfterCompletion(actualCompletionStatus, status.dataSourceName);
-                    // 清理同步状态
-                    if (status.isNewTransaction) {
-                        transaction_synchronization_1.TransactionSynchronizationManager.clearSynchronization(status.dataSourceName);
-                    }
-                }
-                // 只有新事务才需要释放 QueryRunner
-                // 嵌套事务（NESTED）使用保存点，不应该释放 QueryRunner
-                // 注意: 非事务连接(transactionStarted=false)也需要释放QueryRunner
-                if ((resource === null || resource === void 0 ? void 0 : resource.queryRunner) && status.isNewTransaction) {
-                    try {
-                        yield resource.queryRunner.release();
-                        if ((_c = this.config) === null || _c === void 0 ? void 0 : _c.logTransactionDetails) {
-                            this.logger.log(`Released QueryRunner for ${status.dataSourceName}`);
-                        }
-                    }
-                    catch (releaseError) {
-                        this.logger.error(`Failed to release QueryRunner for ${status.dataSourceName}`, releaseError);
-                        // 不抛出错误，避免覆盖原始错误
-                    }
-                }
-                // 最后恢复挂起的事务 - 在所有清理完成后
-                if (status.isNewTransaction) {
-                    const suspended = this.contextManager.resumeSuspendedTransaction(status.dataSourceName);
-                    if (suspended && ((_d = this.config) === null || _d === void 0 ? void 0 : _d.logTransactionDetails)) {
-                        this.logger.log(`Resumed suspended transaction on ${status.dataSourceName}`);
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * 回滚事务
-     */
-    rollback(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (status.isCompleted) {
-                return;
-            }
-            const resource = this.contextManager.getResource(status.dataSourceName);
-            try {
-                // 触发 beforeCompletion 回调
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerBeforeCompletion(status.dataSourceName);
-                }
-                if (status.nestingLevel > 1 && (resource === null || resource === void 0 ? void 0 : resource.transactionStarted) && resource.savepoints.length > 0) {
-                    // 嵌套事务：回滚到最近的保存点
-                    const savepointName = resource.savepoints.pop();
-                    try {
-                        yield database_adapter_1.DatabaseAdapter.rollbackToSavepoint(resource.queryRunner, savepointName);
-                        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                            this.logger.log(`Rolled back to savepoint ${savepointName} on ${status.dataSourceName}`);
-                        }
-                    }
-                    catch (rollbackError) {
-                        this.logger.error(`Failed to rollback to savepoint ${savepointName}`, rollbackError);
-                        throw rollbackError;
-                    }
-                }
-                else if (resource === null || resource === void 0 ? void 0 : resource.transactionStarted) {
-                    // 根事务或无保存点：完全回滚
-                    try {
-                        yield resource.queryRunner.rollbackTransaction();
-                    }
-                    catch (rollbackError) {
-                        this.logger.error(`Failed to rollback transaction on ${status.dataSourceName}`, rollbackError);
-                        throw rollbackError;
-                    }
-                    if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logTransactionDetails) {
-                        this.logger.log(`Rolled back transaction on ${status.dataSourceName}`);
-                    }
-                }
-                this.markCompleted(status);
-                this.contextManager.deleteActiveTransaction(status.dataSourceName);
-                // 清理超时定时器
-                this.clearTimeout(status);
-            }
-            finally {
-                // 触发 afterCompletion 回调
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                    yield transaction_synchronization_1.TransactionSynchronizationManager.triggerAfterCompletion(transaction_synchronization_1.TransactionSynchronizationStatus.STATUS_ROLLED_BACK, status.dataSourceName);
-                    // 清理同步状态
-                    if (status.isNewTransaction) {
-                        transaction_synchronization_1.TransactionSynchronizationManager.clearSynchronization(status.dataSourceName);
-                    }
-                }
-                // Ensure QueryRunner is always released regardless of transaction state
-                if (resource === null || resource === void 0 ? void 0 : resource.queryRunner) {
-                    try {
-                        yield resource.queryRunner.release();
-                        if ((_c = this.config) === null || _c === void 0 ? void 0 : _c.logTransactionDetails) {
-                            this.logger.log(`Released QueryRunner for ${status.dataSourceName}`);
-                        }
-                    }
-                    catch (releaseError) {
-                        this.logger.error(`Failed to release QueryRunner for ${status.dataSourceName}`, releaseError);
-                        // Don't throw error to avoid masking the original error
-                    }
-                }
-                // Clean up resource
-                this.contextManager.deleteResource(status.dataSourceName);
-                // 最后恢复挂起的事务 - 在所有清理完成后
-                if (status.isNewTransaction) {
-                    const suspended = this.contextManager.resumeSuspendedTransaction(status.dataSourceName);
-                    if (suspended && ((_d = this.config) === null || _d === void 0 ? void 0 : _d.logTransactionDetails)) {
-                        this.logger.log(`Resumed suspended transaction on ${status.dataSourceName}`);
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * 获取当前事务的 EntityManager
-     */
-    getCurrentEntityManager(dataSourceName = 'default') {
-        const resource = this.contextManager.getResource(dataSourceName);
-        if (resource === null || resource === void 0 ? void 0 : resource.transactionStarted) {
-            return resource.queryRunner.manager;
-        }
-        // 如果没有活跃事务，尝试从事务上下文获取
-        return this.transactionContext.getEntityManager(dataSourceName);
-    }
-    /**
-     * 获取当前事务状态
-     */
-    getCurrentTransaction(dataSourceName = 'default') {
-        return this.contextManager.getActiveTransaction(dataSourceName);
-    }
-    /**
-     * 获取事务统计
-     */
-    getTransactionStats() {
-        return this.contextManager.getStats();
-    }
-    /**
-     * 根据 Entity 获取数据源名称
-     * 支持装饰器、静态方法和动态方法
-     */
-    getDataSourceForEntity(entityClassOrInstance) {
-        // 1. 尝试从装饰器获取
-        const decoratorDataSource = (0, entity_datasource_decorator_1.getEntityDataSource)(entityClassOrInstance);
-        if (decoratorDataSource) {
-            return decoratorDataSource;
-        }
-        // 2. 检查是否使用动态数据源
-        if ((0, entity_datasource_decorator_1.isDynamicDataSourceEntity)(entityClassOrInstance)) {
-            const entity = entityClassOrInstance;
-            // 如果有 useDataSource 静态方法，调用它
-            if (typeof entity.useDataSource === 'function') {
-                return entity.useDataSource();
-            }
-            // 如果有实例方法，调用它
-            if (entity.getDataSource && typeof entity.getDataSource === 'function') {
-                return entity.getDataSource();
-            }
-        }
-        // 3. 检查基类（如果有继承关系）
-        let prototype = entityClassOrInstance;
-        while (prototype && prototype !== Object.prototype) {
-            const parentDataSource = (0, entity_datasource_decorator_1.getEntityDataSource)(prototype.constructor || prototype);
-            if (parentDataSource) {
-                return parentDataSource;
-            }
-            prototype = Object.getPrototypeOf(prototype);
-        }
-        return null;
-    }
-    /**
-     * 为 Entity 获取或创建 EntityManager
-     * 自动检测 Entity 的数据源
-     */
-    getEntityManagerForEntity(entityClassOrInstance, fallbackDataSourceName = 'default') {
-        // 优先使用 Entity 指定的数据源
-        const entityDataSource = this.getDataSourceForEntity(entityClassOrInstance);
-        const dataSourceName = entityDataSource || fallbackDataSourceName;
-        return this.getCurrentEntityManager(dataSourceName);
-    }
-    // ===== 私有方法 =====
-    handleRequired(definition, existingTx, dataSourceName) {
-        if (existingTx && !existingTx.isCompleted) {
-            // 加入现有事务
-            return Promise.resolve(this.createParticipatingTransaction(definition, existingTx.nestingLevel + 1, dataSourceName));
-        }
-        else {
-            // 创建新事务
-            return this.createNewTransaction(definition, 1, dataSourceName);
-        }
-    }
-    handleRequiresNew(definition, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // 挂起当前事务（如果存在）
-            const existingResource = this.contextManager.getResource(dataSourceName);
-            const existingStatus = this.contextManager.getActiveTransaction(dataSourceName);
-            if (existingResource && existingStatus) {
-                // 挂起当前事务
-                const suspended = this.contextManager.suspendTransaction(dataSourceName);
-                if (suspended) {
-                    this.transactionContext.clearContextForDataSource(dataSourceName);
-                }
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                    this.logger.log(`Suspended transaction on ${dataSourceName} for REQUIRES_NEW`);
-                }
-            }
-            // 创建新事务
-            return this.createNewTransaction(definition, 1, dataSourceName);
-        });
-    }
-    handleNested(definition, existingTx, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (existingTx && !existingTx.isCompleted) {
-                // 创建真正的嵌套事务，使用 SAVEPOINT
-                const resource = this.contextManager.getResource(dataSourceName);
-                if (!resource || !resource.transactionStarted) {
-                    throw transaction_errors_1.TransactionError.invalidState('No active transaction found for NESTED propagation', dataSourceName);
-                }
-                // 创建保存点
-                const savepointName = `sp_${dataSourceName}_L${existingTx.nestingLevel + 1}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-                let savepointCreated = false;
-                try {
-                    // 创建保存点
-                    yield database_adapter_1.DatabaseAdapter.createSavepoint(resource.queryRunner, savepointName);
-                    savepointCreated = true;
-                    // 只有创建成功后才更新状态
-                    resource.savepoints.push(savepointName);
-                    if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                        this.logger.log(`Created savepoint ${savepointName} for nested transaction on ${dataSourceName}`);
-                    }
-                    // 创建参与性事务状态
-                    return this.createParticipatingTransaction(definition, existingTx.nestingLevel + 1, dataSourceName);
-                }
-                catch (error) {
-                    // 如果保存点已创建但后续失败，需要清理
-                    if (savepointCreated) {
-                        // 从 savepoints 数组中移除（如果已添加）
-                        const lastSavepoint = resource.savepoints[resource.savepoints.length - 1];
-                        if (lastSavepoint === savepointName) {
-                            resource.savepoints.pop();
-                        }
-                        // 尝试回滚 Savepoint（如果数据库已创建）
-                        try {
-                            yield database_adapter_1.DatabaseAdapter.rollbackToSavepoint(resource.queryRunner, savepointName);
-                            if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logTransactionDetails) {
-                                this.logger.log(`Rolled back savepoint ${savepointName} during cleanup`);
-                            }
-                        }
-                        catch (rollbackError) {
-                            this.logger.error(`Failed to rollback savepoint ${savepointName} during cleanup: ${rollbackError.message}`, rollbackError.stack);
-                        }
-                    }
-                    throw transaction_errors_1.TransactionError.nestedTransactionFailed(`Failed to create nested transaction with savepoint ${savepointName}: ${error.message}`, dataSourceName, error);
-                }
-            }
-            else {
-                // 没有外部事务，创建新事务
-                return this.createNewTransaction(definition, 1, dataSourceName);
-            }
-        });
-    }
-    handleSupports(definition, existingTx, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (existingTx && !existingTx.isCompleted) {
-                // 有事务，参与现有事务
-                return this.createParticipatingTransaction(definition, existingTx.nestingLevel + 1, dataSourceName);
-            }
-            else {
-                // 没有事务，创建非事务连接
-                const dataSource = yield this.getDataSource(dataSourceName);
-                const queryRunner = dataSource.createQueryRunner();
-                yield queryRunner.connect();
-                // 不启动事务
-                const resource = {
-                    dataSourceName,
-                    dataSource,
-                    queryRunner,
-                    transactionStarted: false,
-                    nestingLevel: 1,
-                    savepoints: [],
-                };
-                this.contextManager.setResource(dataSourceName, resource);
-                this.transactionContext.setContext(dataSourceName, queryRunner.manager);
-                const status = {
-                    isCompleted: false,
-                    isRollbackOnly: false,
-                    isNewTransaction: true, // 需要清理资源
-                    dataSourceName,
-                    startTime: new Date(),
-                    definition,
-                    nestingLevel: 1,
-                };
-                this.contextManager.setActiveTransaction(dataSourceName, status);
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                    this.logger.log(`Created non-transactional connection for SUPPORTS on ${dataSourceName}`);
-                }
-                return status;
-            }
-        });
-    }
-    handleNotSupported(definition, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // 挂起当前事务（如果存在）
-            const existingResource = this.contextManager.getResource(dataSourceName);
-            const existingStatus = this.contextManager.getActiveTransaction(dataSourceName);
-            if (existingResource && existingStatus) {
-                // 挂起当前事务
-                const suspended = this.contextManager.suspendTransaction(dataSourceName);
-                if (suspended) {
-                    this.transactionContext.clearContextForDataSource(dataSourceName);
-                }
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                    this.logger.log(`Suspended transaction on ${dataSourceName} for NOT_SUPPORTED`);
-                }
-            }
-            // 创建非事务的数据库连接
-            const dataSource = yield this.getDataSource(dataSourceName);
-            const queryRunner = dataSource.createQueryRunner();
-            yield queryRunner.connect();
-            // 注意: 不调用 startTransaction()，以非事务方式执行
-            const resource = {
-                dataSourceName,
-                dataSource,
-                queryRunner,
-                transactionStarted: false, // 标记为非事务
-                nestingLevel: 1,
-                savepoints: [],
-            };
-            this.contextManager.setResource(dataSourceName, resource);
-            this.transactionContext.setContext(dataSourceName, queryRunner.manager);
-            const status = {
-                isCompleted: false,
-                isRollbackOnly: false,
-                isNewTransaction: true, // 需要清理资源
-                dataSourceName,
-                startTime: new Date(),
-                definition,
-                nestingLevel: 1,
-            };
-            this.contextManager.setActiveTransaction(dataSourceName, status);
-            if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logTransactionDetails) {
-                this.logger.log(`Created non-transactional connection for ${dataSourceName}`);
-            }
-            return status;
-        });
-    }
-    handleMandatory(definition, existingTx, dataSourceName) {
-        if (!existingTx || existingTx.isCompleted) {
-            throw transaction_errors_1.TransactionError.invalidState('No existing transaction found for MANDATORY propagation', dataSourceName);
-        }
-        return this.createParticipatingTransaction(definition, existingTx.nestingLevel + 1, dataSourceName);
-    }
-    handleNever(definition, existingTx, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (existingTx && !existingTx.isCompleted) {
-                throw transaction_errors_1.TransactionError.invalidState('Existing transaction found for NEVER propagation', dataSourceName);
-            }
-            // 创建非事务的数据库连接
-            const dataSource = yield this.getDataSource(dataSourceName);
-            const queryRunner = dataSource.createQueryRunner();
-            yield queryRunner.connect();
-            // 注意: 不调用 startTransaction()，以非事务方式执行
-            const resource = {
-                dataSourceName,
-                dataSource,
-                queryRunner,
-                transactionStarted: false, // 标记为非事务
-                nestingLevel: 1,
-                savepoints: [],
-            };
-            this.contextManager.setResource(dataSourceName, resource);
-            this.transactionContext.setContext(dataSourceName, queryRunner.manager);
-            const status = {
-                isCompleted: false,
-                isRollbackOnly: false,
-                isNewTransaction: true, // 需要清理资源
-                dataSourceName,
-                startTime: new Date(),
-                definition,
-                nestingLevel: 1,
-            };
-            this.contextManager.setActiveTransaction(dataSourceName, status);
-            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                this.logger.log(`Created non-transactional connection for NEVER propagation on ${dataSourceName}`);
-            }
-            return status;
-        });
-    }
-    createNewTransaction(definition, nestingLevel, dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            let queryRunner = null;
-            let status = null;
-            let transactionStarted = false;
-            try {
-                const dataSource = yield this.getDataSource(dataSourceName);
-                queryRunner = dataSource.createQueryRunner();
-                yield queryRunner.connect();
-                yield queryRunner.startTransaction(this.convertIsolationLevel(definition.isolationLevel));
-                transactionStarted = true;
-                const resource = {
-                    dataSourceName,
-                    dataSource,
-                    queryRunner,
-                    transactionStarted: true,
-                    nestingLevel,
-                    savepoints: [],
-                };
-                this.contextManager.setResource(dataSourceName, resource);
-                this.transactionContext.setContext(dataSourceName, queryRunner.manager);
-                // 初始化事务同步
-                if (!transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(dataSourceName)) {
-                    transaction_synchronization_1.TransactionSynchronizationManager.initSynchronization(dataSourceName);
-                }
-                // 设置事务信息到同步管理器
-                transaction_synchronization_1.TransactionSynchronizationManager.setActualTransactionActive(true, dataSourceName);
-                transaction_synchronization_1.TransactionSynchronizationManager.setCurrentTransactionName(definition.name || null, dataSourceName);
-                transaction_synchronization_1.TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.readOnly || false, dataSourceName);
-                if (definition.isolationLevel !== undefined) {
-                    transaction_synchronization_1.TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(definition.isolationLevel, dataSourceName);
-                }
-                status = {
-                    isCompleted: false,
-                    isRollbackOnly: false,
-                    isNewTransaction: true,
-                    dataSourceName,
-                    startTime: new Date(),
-                    definition,
-                    nestingLevel,
-                };
-                // 设置事务超时
-                const timeoutMs = this.getTimeoutMs(definition);
-                if (timeoutMs > 0) {
-                    status.timeoutTimer = setTimeout(() => {
-                        this.handleTransactionTimeout(status);
-                    }, timeoutMs);
-                    if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                        this.logger.log(`Set transaction timeout ${timeoutMs}ms for ${dataSourceName}`);
-                    }
-                }
-                this.contextManager.setActiveTransaction(dataSourceName, status);
-                if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.logTransactionDetails) {
-                    this.logger.log(`Started new transaction on ${dataSourceName} (level: ${nestingLevel})`);
-                }
-                return status;
-            }
-            catch (error) {
-                // 增强的错误清理逻辑
-                this.logger.error(`Failed to create transaction on ${dataSourceName}: ${error.message}`, error.stack);
-                // Clean up timer if setup fails
-                if (status === null || status === void 0 ? void 0 : status.timeoutTimer) {
-                    clearTimeout(status.timeoutTimer);
-                    status.timeoutTimer = undefined;
-                }
-                // Clean up transaction if started
-                if (queryRunner && transactionStarted) {
-                    try {
-                        if (queryRunner.isTransactionActive) {
-                            yield queryRunner.rollbackTransaction();
-                        }
-                    }
-                    catch (rollbackError) {
-                        this.logger.error(`Failed to rollback during setup cleanup: ${rollbackError.message}`);
-                    }
-                }
-                // Clean up QueryRunner
-                if (queryRunner) {
-                    try {
-                        yield queryRunner.release();
-                    }
-                    catch (releaseError) {
-                        this.logger.error(`Failed to release QueryRunner during setup error cleanup: ${releaseError.message}`);
-                    }
-                }
-                // Clean up context and synchronization
-                this.contextManager.deleteResource(dataSourceName);
-                this.contextManager.deleteActiveTransaction(dataSourceName);
-                if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(dataSourceName)) {
-                    transaction_synchronization_1.TransactionSynchronizationManager.clearSynchronization(dataSourceName);
-                }
-                throw transaction_errors_1.TransactionError.beginFailed(`Failed to create transaction: ${error.message}`, dataSourceName, error);
-            }
-        });
-    }
-    createParticipatingTransaction(definition, nestingLevel, dataSourceName) {
-        // 验证必须有现有资源
-        const resource = this.contextManager.getResource(dataSourceName);
-        if (!resource) {
-            throw transaction_errors_1.TransactionError.invalidState('Cannot create participating transaction without existing resource', dataSourceName);
-        }
-        const status = {
-            isCompleted: false,
-            isRollbackOnly: false,
-            isNewTransaction: false,
-            dataSourceName,
-            startTime: new Date(),
-            definition,
-            nestingLevel,
-        };
-        // 验证 activeTransaction 状态
-        const existingTx = this.contextManager.getActiveTransaction(dataSourceName);
-        if (!existingTx) {
-            // 如果没有 activeTransaction 但有 resource，说明状态不一致
-            this.logger.warn(`Creating participating transaction but no active transaction found for ${dataSourceName}. ` +
-                `This may indicate a state inconsistency.`);
-            this.contextManager.setActiveTransaction(dataSourceName, status);
-        }
-        return status;
-    }
-    getActiveTransaction(dataSourceName) {
-        return this.contextManager.getActiveTransaction(dataSourceName);
-    }
-    getDataSource(dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return transaction_errors_1.TransactionErrorHandler.safeExecute(() => __awaiter(this, void 0, void 0, function* () {
-                const dataSource = this.transactionContext.getDataSource(dataSourceName);
-                if (!dataSource) {
-                    throw transaction_errors_1.TransactionError.dataSourceNotFound(dataSourceName);
-                }
-                return dataSource;
-            }), (error) => transaction_errors_1.TransactionError.beginFailed(`Failed to get data source: ${error.message}`, dataSourceName, error), 'getDataSource');
-        });
-    }
-    convertIsolationLevel(level) {
-        if (!level || level === IsolationLevel.DEFAULT) {
-            return undefined;
-        }
-        const mapping = {
-            [IsolationLevel.READ_UNCOMMITTED]: 'READ UNCOMMITTED',
-            [IsolationLevel.READ_COMMITTED]: 'READ COMMITTED',
-            [IsolationLevel.REPEATABLE_READ]: 'REPEATABLE READ',
-            [IsolationLevel.SERIALIZABLE]: 'SERIALIZABLE',
-        };
-        return mapping[level];
-    }
-    markCompleted(status) {
-        status.isCompleted = true;
-    }
-    removeActiveTransaction(dataSourceName) {
-        this.contextManager.deleteActiveTransaction(dataSourceName);
-    }
-    markParentForRollback(dataSourceName, currentLevel) {
-        const activeTx = this.contextManager.getActiveTransaction(dataSourceName);
-        if (activeTx && activeTx.nestingLevel < currentLevel) {
-            activeTx.isRollbackOnly = true;
-        }
-    }
-    rollbackOnCommitException(status, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.rollback(status);
-            }
-            catch (rollbackError) {
-                this.logger.error('Rollback after commit exception failed:', rollbackError);
-            }
-        });
-    }
-    cleanupResource(dataSourceName) {
-        // 清理事务上下文
-        this.transactionContext.clearContextForDataSource(dataSourceName);
-        this.contextManager.deleteResource(dataSourceName);
-    }
-    /**
-     * 恢复挂起的事务 - 已移到 TransactionContextManager 中
-     * 此方法保留以兼容
-     */
-    resumeSuspendedTransaction(dataSourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const suspended = this.contextManager.resumeSuspendedTransaction(dataSourceName);
-            if (suspended) {
-                try {
-                    this.transactionContext.setContext(dataSourceName, suspended.resource.queryRunner.manager);
-                    if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                        this.logger.log(`Resumed suspended transaction on ${dataSourceName}`);
-                    }
-                }
-                catch (error) {
-                    throw transaction_errors_1.TransactionError.rollbackFailed(`Failed to resume suspended transaction: ${error.message}`, dataSourceName, suspended.status.definition.name, error);
-                }
-            }
-        });
-    }
-    /**
-     * 获取事务超时时间（毫秒）
-     */
-    getTimeoutMs(definition) {
-        var _a;
-        // 优先使用定义中的超时时间
-        if (definition.timeout !== undefined) {
-            return definition.timeout * 1000; // 转换为毫秒
-        }
-        // 使用配置中的默认超时时间
-        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.defaultTimeout) !== undefined) {
-            return this.config.defaultTimeout * 1000;
-        }
-        return 0; // 不设置超时
-    }
-    /**
-     * 处理事务超时
-     */
-    handleTransactionTimeout(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // 原子性检查并设置状态
-            if (status.isCompleted) {
-                return; // 事务已完成，无需处理
-            }
-            const timeoutMs = this.getTimeoutMs(status.definition);
-            const timeoutError = transaction_errors_1.TransactionErrorHandler.handleTimeout(timeoutMs, status.dataSourceName, status.definition.name);
-            this.logger.error(transaction_errors_1.TransactionErrorHandler.formatMessage(timeoutError));
-            // 如果有自定义超时回调，在独立的 try-catch 中执行
-            if (status.definition.onTimeout) {
-                try {
-                    // 限制回调不能修改事务状态
-                    yield status.definition.onTimeout(status);
-                    this.logger.log(`Custom timeout handler executed for transaction on ${status.dataSourceName}`);
-                }
-                catch (callbackError) {
-                    this.logger.error(`Custom timeout handler failed:`, callbackError);
-                }
-            }
-            // 标记为仅回滚
-            status.isRollbackOnly = true;
-            let rollbackSuccessful = false;
-            // 默认处理：回滚事务
-            // 使用 try-catch 确保即使回滚失败也会清理资源
-            try {
-                const resource = this.contextManager.getResource(status.dataSourceName);
-                if ((resource === null || resource === void 0 ? void 0 : resource.queryRunner) && resource.transactionStarted) {
-                    if (resource.queryRunner.isTransactionActive) {
-                        yield resource.queryRunner.rollbackTransaction();
-                        rollbackSuccessful = true;
-                        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                            this.logger.log(`Rolled back timed out transaction on ${status.dataSourceName}`);
-                        }
-                    }
-                    yield resource.queryRunner.release();
-                }
-                else {
-                    // 资源不可用，视为回滚成功（无需回滚）
-                    rollbackSuccessful = true;
-                }
-            }
-            catch (rollbackError) {
-                this.logger.error(`Failed to rollback timed out transaction on ${status.dataSourceName}. ` +
-                    `Transaction may be left in inconsistent state. Manual intervention may be required.`, rollbackError);
-                // 回滚失败，尝试强制释放资源
-                try {
-                    const resource = this.contextManager.getResource(status.dataSourceName);
-                    if (resource === null || resource === void 0 ? void 0 : resource.queryRunner) {
-                        yield resource.queryRunner.release();
-                        this.logger.warn(`Forcefully released QueryRunner after rollback failure on ${status.dataSourceName}`);
-                    }
-                }
-                catch (releaseError) {
-                    this.logger.error(`Failed to release QueryRunner after rollback failure:`, releaseError);
-                }
-            }
-            finally {
-                // 只有在回滚成功或资源已清理后才标记为完成
-                if (rollbackSuccessful) {
-                    this.markCompleted(status);
-                }
-                // 确保资源被清理
-                try {
-                    this.contextManager.deleteResource(status.dataSourceName);
-                    this.contextManager.deleteActiveTransaction(status.dataSourceName);
-                    if (transaction_synchronization_1.TransactionSynchronizationManager.isSynchronizationActive(status.dataSourceName)) {
-                        transaction_synchronization_1.TransactionSynchronizationManager.clearSynchronization(status.dataSourceName);
-                    }
-                }
-                catch (cleanupError) {
-                    this.logger.error(`Failed to cleanup timed out transaction:`, cleanupError);
-                }
-            }
-        });
-    }
-    /**
-     * 清理事务定时器
-     * 确保定时器被正确清理,避免内存泄漏
-     */
-    clearTimeout(status) {
-        var _a;
-        if (status.timeoutTimer) {
-            clearTimeout(status.timeoutTimer);
-            status.timeoutTimer = undefined;
-            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.logTransactionDetails) {
-                this.logger.log(`Cleared timeout timer for ${status.dataSourceName}`);
-            }
-        }
-    }
-};
-exports.TransactionManager = TransactionManager;
-exports.TransactionManager = TransactionManager = TransactionManager_1 = __decorate([
-    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
-    __param(2, (0, common_1.Optional)()),
-    __param(2, (0, common_1.Inject)('TRANSACTION_CONFIG')),
-    __metadata("design:paramtypes", [transaction_context_service_1.TransactionContextService,
-        TransactionContextManager, Object])
-], TransactionManager);