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

package/transaction/logging-transactional.interceptor.js

@@ -1,163 +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 __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 LoggingTransactionalInterceptor_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggingTransactionalInterceptor = void 0;
-const common_1 = require("@nestjs/common");
-const rxjs_1 = require("rxjs");
-const transaction_manager_1 = require("./transaction-manager");
-const nestjs_cls_1 = require("nestjs-cls");
-/**
- * 带日志的事务拦截器
- * 提供详细的事务执行日志
- */
-let LoggingTransactionalInterceptor = LoggingTransactionalInterceptor_1 = class LoggingTransactionalInterceptor {
-    constructor(transactionManager) {
-        this.transactionManager = transactionManager;
-        this.logger = new common_1.Logger(LoggingTransactionalInterceptor_1.name);
-    }
-    intercept(context, next) {
-        // 检查是否有事务元数据
-        const options = this.getTransactionOptions(context);
-        if (!options) {
-            return next.handle();
-        }
-        // 异步执行事务处理
-        return (0, rxjs_1.from)(this.handleTransaction(context, next, options));
-    }
-    handleTransaction(context, next, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const startTime = Date.now();
-            let status;
-            try {
-                // 获取事务定义
-                const definition = {
-                    propagation: options.propagation || transaction_manager_1.Propagation.REQUIRED,
-                    isolationLevel: options.isolation,
-                    readOnly: options.readOnly || false,
-                    timeout: options.timeout || 30,
-                    name: this.getTransactionName(context, options),
-                    dataSourceName: options.dataSource || 'default',
-                };
-                // 记录事务开始
-                this.logger.log(`Starting transaction: ${definition.name} ` +
-                    `(propagation: ${transaction_manager_1.Propagation[definition.propagation]}, ` +
-                    `dataSource: ${definition.dataSourceName}, ` +
-                    `timeout: ${definition.timeout}s)`);
-                // 获取事务
-                status = yield this.transactionManager.getTransaction(definition);
-                // 记录事务状态
-                if (status.isNewTransaction) {
-                    this.logger.debug(`New transaction created on ${definition.dataSourceName}`);
-                }
-                else {
-                    this.logger.debug(`Joined existing transaction on ${definition.dataSourceName} ` +
-                        `(level: ${status.nestingLevel})`);
-                }
-                // 设置 CLS 上下文
-                yield this.setClsContext(status);
-                // 执行方法
-                const result = yield next.handle().toPromise();
-                // 记录成功
-                const duration = Date.now() - startTime;
-                this.logger.log(`Transaction ${definition.name} completed successfully ` +
-                    `in ${duration}ms`);
-                // 提交事务
-                yield this.transactionManager.commit(status);
-                this.logger.debug(`Transaction ${definition.name} committed`);
-                return result;
-            }
-            catch (error) {
-                // 记录错误
-                const duration = Date.now() - startTime;
-                this.logger.error(`Transaction failed: ${error.message} ` +
-                    `(duration: ${duration}ms)`, error.stack);
-                // 回滚事务
-                if (status) {
-                    try {
-                        yield this.transactionManager.rollback(status);
-                        this.logger.debug(`Transaction rolled back successfully`);
-                    }
-                    catch (rollbackError) {
-                        this.logger.error(`Failed to rollback transaction: ${rollbackError.message}`, rollbackError.stack);
-                    }
-                }
-                throw error;
-            }
-            finally {
-                // 清理 CLS 上下文
-                this.clearClsContext();
-            }
-        });
-    }
-    getTransactionOptions(context) {
-        const handler = context.getHandler();
-        const controller = context.getClass();
-        // 检查方法级注解
-        const methodOptions = Reflect.getMetadata('transactional', handler);
-        if (methodOptions && !methodOptions.isClassLevel) {
-            return methodOptions;
-        }
-        // 检查类级注解
-        const classOptions = Reflect.getMetadata('transactional', controller);
-        if (classOptions && (classOptions.isClassLevel || !methodOptions)) {
-            return classOptions;
-        }
-        return null;
-    }
-    getTransactionName(context, options) {
-        if (options.name) {
-            return options.name;
-        }
-        const handler = context.getHandler();
-        const controller = context.getClass();
-        return `${controller.name}.${handler.name}`;
-    }
-    setClsContext(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const clsService = (_a = nestjs_cls_1.ClsServiceManager.getClsService) === null || _a === void 0 ? void 0 : _a.call(nestjs_cls_1.ClsServiceManager);
-            if (clsService) {
-                const em = this.transactionManager.getCurrentEntityManager(status.dataSourceName);
-                if (em) {
-                    clsService.set('entityManager', em);
-                }
-                clsService.set('transactionId', `${status.dataSourceName}_${Date.now()}`);
-                clsService.set('dataSource', status.dataSourceName);
-                clsService.set('startTime', status.startTime);
-            }
-        });
-    }
-    clearClsContext() {
-        var _a;
-        const clsService = (_a = nestjs_cls_1.ClsServiceManager.getClsService) === null || _a === void 0 ? void 0 : _a.call(nestjs_cls_1.ClsServiceManager);
-        if (clsService) {
-            clsService.set('entityManager', null);
-            clsService.set('transactionId', null);
-            clsService.set('dataSource', null);
-            clsService.set('startTime', null);
-        }
-    }
-};
-exports.LoggingTransactionalInterceptor = LoggingTransactionalInterceptor;
-exports.LoggingTransactionalInterceptor = LoggingTransactionalInterceptor = LoggingTransactionalInterceptor_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [transaction_manager_1.TransactionManager])
-], LoggingTransactionalInterceptor);

package/transaction/transaction-context.service.d.ts

@@ -1,137 +0,0 @@
-import { OnModuleInit } from '@nestjs/common';
-import { DataSource, EntityManager, DataSourceOptions } from 'typeorm';
-import { ModuleRef } from '@nestjs/core';
-/**
- * 事务上下文信息
- */
-interface TransactionContext {
-    dataSourceName: string;
-    entityManager: EntityManager;
-    dataSource: DataSource;
-}
-/**
- * 动态注册的数据源配置
- */
-export interface DynamicDataSourceConfig {
-    name: string;
-    dataSource: DataSource;
-    options?: DataSourceOptions;
-    metadata?: Record<string, any>;
-    createdAt: Date;
-}
-/**
- * 事务上下文管理器
- * 使用 RequestScope 确保每个请求都有独立的事务上下文
- */
-export declare class TransactionContextService implements OnModuleInit {
-    private readonly moduleRef;
-    private readonly config?;
-    private static readonly logger;
-    private readonly contextMap;
-    constructor(moduleRef: ModuleRef, config?: {
-        defaultDataSource?: string;
-        enableDynamicRegistration?: boolean;
-        logDataSourceRegistration?: boolean;
-    });
-    onModuleInit(): Promise<void>;
-    /**
-     * 获取当前请求的事务上下文服务
-     */
-    static getCurrent(): TransactionContextService | undefined;
-    /**
-     * 获取当前请求的数据源
-     * 方便其他模块快速访问数据源
-     * @param dataSourceName 数据源名称，默认为 'default'
-     * @returns DataSource 实例
-     */
-    static getDataSource(dataSourceName?: string): DataSource;
-    /**
-     * 设置事务上下文
-     */
-    setContext(dataSourceName: string, entityManager: EntityManager): void;
-    /**
-     * 获取事务上下文中的 EntityManager
-     */
-    getEntityManager(dataSourceName?: string): EntityManager | null;
-    /**
-     * 获取事务上下文中的 DataSource
-     * 如果上下文中没有，则尝试从 TypeORM 模块或全局注册表获取
-     */
-    getDataSource(dataSourceName?: string): DataSource | null;
-    /**
-     * 检查是否在事务中
-     */
-    isInTransaction(dataSourceName?: string): boolean;
-    /**
-     * 获取所有活跃的事务上下文
-     */
-    getAllActiveContexts(): Map<string, TransactionContext>;
-    /**
-     * 清理所有事务上下文
-     */
-    clearContext(): void;
-    /**
-     * 清理指定数据源的事务上下文
-     */
-    clearContextForDataSource(dataSourceName: string): void;
-    /**
-     * 执行带事务的操作
-     * 如果已在事务中，使用现有的事务管理器
-     * 否则创建新事务
-     */
-    executeInTransaction<T>(dataSourceName: string, operation: (entityManager: EntityManager) => Promise<T>, isolationLevel?: any): Promise<T>;
-    /**
-     * 获取 DataSource 实例
-     */
-    private getDataSourceInstance;
-    /**
-     * 动态注册数据源
-     */
-    static addDataSource(name: string, dataSource: DataSource, options?: {
-        options?: DataSourceOptions;
-        metadata?: Record<string, any>;
-        replaceExisting?: boolean;
-    }): Promise<void>;
-    /**
-     * 移除动态注册的数据源
-     */
-    static removeDataSource(name: string): Promise<void>;
-    /**
-     * 获取所有已注册的数据源名称
-     */
-    static getRegisteredDataSources(): string[];
-    /**
-     * 获取动态数据源的配置
-     */
-    static getDataSourceConfig(name: string): DynamicDataSourceConfig | undefined;
-    /**
-     * 检查数据源是否已注册
-     */
-    static isDataSourceRegistered(name: string): boolean;
-    /**
-     * 批量注册数据源
-     */
-    static addDataSources(dataSources: Array<{
-        name: string;
-        dataSource: DataSource;
-        options?: DataSourceOptions;
-        metadata?: Record<string, any>;
-    }>, options?: {
-        replaceExisting?: boolean;
-        continueOnError?: boolean;
-    }): Promise<void>;
-    /**
-     * 清理全局注册表（用于测试）
-     */
-    static clearGlobalRegistry(): void;
-    /**
-     * 获取默认数据源名称
-     */
-    getDefaultDataSourceName(): string;
-    /**
-     * 跨多个数据源执行分布式事务
-     * 使用两阶段提交模式
-     */
-    executeDistributedTransaction<T>(dataSourceNames: string[], operation: (entityManagers: Map<string, EntityManager>) => Promise<T>): Promise<T>;
-}
-export {};