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

package/dist/transaction/transaction-manager.js

@@ -0,0 +1,1001 @@
+"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);