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

package/dist/transaction/transactional.decorator.js

@@ -0,0 +1,319 @@
+"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 TransactionalInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tx = exports.TransactionalInterceptor = exports.TRANSACTION_METADATA_KEY = void 0;
+exports.Transactional = Transactional;
+exports.ClassTransactional = ClassTransactional;
+exports.UseTransactional = UseTransactional;
+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");
+/**
+ * 事务元数据键
+ */
+exports.TRANSACTION_METADATA_KEY = 'transactional';
+/**
+ * @Transactional 装饰器
+ * 统一的事务装饰器，自动处理嵌套和数据源
+ */
+function Transactional(options) {
+    const defaultOptions = {
+        propagation: transaction_manager_1.Propagation.REQUIRED,
+        readOnly: false,
+        timeout: 30,
+    };
+    const finalOptions = Object.assign(Object.assign({}, defaultOptions), options);
+    return function (target, propertyKey, descriptor) {
+        // 设置元数据
+        (0, common_1.SetMetadata)(exports.TRANSACTION_METADATA_KEY, finalOptions)(target, propertyKey, descriptor);
+        // 包装原始方法
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                // 获取事务管理器
+                const transactionManager = this.transactionManager;
+                const logger = new common_1.Logger('Transactional');
+                if (!transactionManager) {
+                    logger.warn('TransactionManager not found, executing without transaction');
+                    return yield originalMethod.apply(this, args);
+                }
+                // 获取事务定义
+                const isolation = (options === null || options === void 0 ? void 0 : options.isolation) || (options === null || options === void 0 ? void 0 : options.isolationLevel);
+                const definition = {
+                    propagation: finalOptions.propagation || transaction_manager_1.Propagation.REQUIRED,
+                    isolationLevel: isolation,
+                    readOnly: finalOptions.readOnly,
+                    timeout: finalOptions.timeout,
+                    name: finalOptions.name || `${target.constructor.name}.${String(propertyKey)}`,
+                    dataSourceName: (options === null || options === void 0 ? void 0 : options.dataSource) || 'default',
+                    onTimeout: options === null || options === void 0 ? void 0 : options.onTimeout,
+                };
+                let clsService = null;
+                let clsAvailable = false;
+                try {
+                    clsService = (_a = nestjs_cls_1.ClsServiceManager.getClsService) === null || _a === void 0 ? void 0 : _a.call(nestjs_cls_1.ClsServiceManager);
+                    if (clsService && typeof clsService.set === 'function') {
+                        clsAvailable = true;
+                    }
+                    else {
+                        logger.warn('[Transactional] ClsService found but not fully compatible. ' +
+                            'EntityManager will not be stored in CLS context.');
+                    }
+                }
+                catch (clsError) {
+                    logger.warn('[Transactional] CLS is not available or failed to initialize. ' +
+                        `Reason: ${clsError.message}. ` +
+                        'Transaction will proceed without CLS integration.');
+                }
+                // 开始事务
+                const status = yield transactionManager.getTransaction(definition);
+                try {
+                    // 安全地设置 CLS 中的 EntityManager
+                    if (clsAvailable && clsService) {
+                        try {
+                            const em = transactionManager.getCurrentEntityManager(definition.dataSourceName);
+                            if (em) {
+                                clsService.set('entityManager', em);
+                                logger.debug(`[Transactional] EntityManager set in CLS for ${definition.dataSourceName}`);
+                            }
+                            else {
+                                logger.warn(`[Transactional] No EntityManager available for ${definition.dataSourceName}`);
+                            }
+                        }
+                        catch (error) {
+                            logger.error('[Transactional] Failed to set EntityManager in CLS. ' +
+                                `DataSource: ${definition.dataSourceName}, ` +
+                                `Error: ${error.message}`, error.stack);
+                        }
+                    }
+                    // 执行方法
+                    const result = yield originalMethod.apply(this, args);
+                    // 提交事务
+                    yield transactionManager.commit(status);
+                    return result;
+                }
+                catch (error) {
+                    // 确保回滚事务
+                    let rollbackError = null;
+                    try {
+                        yield transactionManager.rollback(status);
+                    }
+                    catch (rbError) {
+                        rollbackError = rbError;
+                        logger.error('[Transactional] Failed to rollback transaction:', rbError);
+                    }
+                    // 如果回滚也失败，抛出聚合错误
+                    if (rollbackError) {
+                        const aggregateError = new Error(`Transaction failed and rollback also failed. ` +
+                            `Original error: ${error.message}. ` +
+                            `Rollback error: ${rollbackError.message}`);
+                        aggregateError.originalError = error;
+                        aggregateError.rollbackError = rollbackError;
+                        throw aggregateError;
+                    }
+                    throw error;
+                }
+                finally {
+                    // Clean up CLS context
+                    if (clsAvailable && clsService) {
+                        try {
+                            clsService.set('entityManager', null);
+                            logger.debug('[Transactional] CLS context cleaned up');
+                        }
+                        catch (cleanupError) {
+                            logger.error('[Transactional] Failed to clean up CLS context. ' +
+                                `This may lead to context leakage. Error: ${cleanupError.message}`, cleanupError.stack);
+                        }
+                    }
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+/**
+ * 类级别事务装饰器
+ */
+function ClassTransactional(options) {
+    return function (target) {
+        (0, common_1.SetMetadata)(exports.TRANSACTION_METADATA_KEY, Object.assign(Object.assign({}, options), { isClassLevel: true }))(target);
+    };
+}
+/**
+ * 事务拦截器
+ * 支持类级别和方法级别的事务管理
+ */
+let TransactionalInterceptor = TransactionalInterceptor_1 = class TransactionalInterceptor {
+    constructor(transactionManager) {
+        this.transactionManager = transactionManager;
+        this.logger = new common_1.Logger(TransactionalInterceptor_1.name);
+    }
+    intercept(context, next) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 获取处理器
+            const handler = context.getHandler();
+            const controller = context.getClass();
+            // 检查方法或类是否有事务元数据
+            const options = this.getTransactionOptions(handler, controller);
+            if (!options) {
+                // 没有事务注解，直接执行
+                return next.handle();
+            }
+            // 获取事务定义
+            const definition = {
+                propagation: options.propagation || transaction_manager_1.Propagation.REQUIRED,
+                isolationLevel: options.isolation,
+                readOnly: options.readOnly,
+                timeout: options.timeout || 30,
+                name: options.name || `${controller.name}.${handler.name}`,
+                dataSourceName: options.dataSource || 'default',
+                onTimeout: options.onTimeout,
+            };
+            // 开始事务
+            const status = yield this.transactionManager.getTransaction(definition);
+            // 包装执行
+            return new rxjs_1.Observable((subscriber) => {
+                this.executeWithTransaction(status, next, subscriber)
+                    .catch((error) => {
+                    subscriber.error(error);
+                });
+            });
+        });
+    }
+    executeWithTransaction(status, next, subscriber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 执行处理器
+                const result = yield next.handle().toPromise();
+                // 提交事务
+                yield this.transactionManager.commit(status);
+                subscriber.next(result);
+                subscriber.complete();
+            }
+            catch (error) {
+                // 回滚事务
+                try {
+                    yield this.transactionManager.rollback(status);
+                }
+                catch (rollbackError) {
+                    this.logger.error('Failed to rollback transaction:', rollbackError);
+                }
+                throw error;
+            }
+        });
+    }
+    getTransactionOptions(handler, controller) {
+        // 检查方法级注解
+        const methodOptions = Reflect.getMetadata(exports.TRANSACTION_METADATA_KEY, handler);
+        if (methodOptions && !methodOptions.isClassLevel) {
+            return methodOptions;
+        }
+        // 检查类级注解
+        const classOptions = Reflect.getMetadata(exports.TRANSACTION_METADATA_KEY, controller);
+        if (classOptions && (classOptions.isClassLevel || !methodOptions)) {
+            return classOptions;
+        }
+        return null;
+    }
+};
+exports.TransactionalInterceptor = TransactionalInterceptor;
+exports.TransactionalInterceptor = TransactionalInterceptor = TransactionalInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [transaction_manager_1.TransactionManager])
+], TransactionalInterceptor);
+/**
+ * 便捷装饰器工厂
+ */
+exports.Tx = {
+    /**
+     * 必须在事务中执行（默认）
+     */
+    Required: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.REQUIRED,
+        dataSource,
+    }),
+    /**
+     * 支持当前事务，非事务执行也行
+     */
+    Supports: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.SUPPORTS,
+        dataSource,
+    }),
+    /**
+     * 必须在事务中执行，否则抛异常
+     */
+    Mandatory: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.MANDATORY,
+        dataSource,
+    }),
+    /**
+     * 创建新事务
+     */
+    RequiresNew: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.REQUIRES_NEW,
+        dataSource,
+    }),
+    /**
+     * 不支持事务，挂起当前事务
+     */
+    NotSupported: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.NOT_SUPPORTED,
+        dataSource,
+    }),
+    /**
+     * 永不使用事务
+     */
+    Never: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.NEVER,
+        dataSource,
+    }),
+    /**
+     * 嵌套事务
+     */
+    Nested: (dataSource) => Transactional({
+        propagation: transaction_manager_1.Propagation.NESTED,
+        dataSource,
+    }),
+    /**
+     * 只读事务
+     */
+    ReadOnly: (dataSource) => Transactional({
+        readOnly: true,
+        dataSource,
+    }),
+};
+/**
+ * 组合装饰器：使用拦截器
+ */
+function UseTransactional(options) {
+    return function (target, propertyKey, descriptor) {
+        if (descriptor) {
+            // 方法装饰器
+            return Transactional(options)(target, propertyKey, descriptor);
+        }
+        else {
+            // 类装饰器
+            return ClassTransactional(options)(target);
+        }
+    };
+}

package/dist/transaction/typeorm-module-wrapper.d.ts

@@ -0,0 +1,96 @@
+import { DynamicModule } from '@nestjs/common';
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+import { DataSourceRegistryService } from './data-source-registry';
+/**
+ * TypeORM 数据源配置
+ */
+export interface TypeOrmDataSourceConfig {
+    name: string;
+    options: TypeOrmModuleOptions;
+    isDefault?: boolean;
+    metadata?: {
+        description?: string;
+        team?: string;
+        environment?: string;
+        tags?: string[];
+    };
+    healthCheck?: {
+        enabled?: boolean;
+        timeout?: number;
+        interval?: number;
+    };
+}
+/**
+ * 多数据源 TypeORM 模块配置
+ */
+export interface MultiTypeOrmModuleOptions {
+    dataSources: TypeOrmDataSourceConfig[];
+    transactionOptions?: {
+        defaultDataSource?: string;
+        enableDynamicRegistration?: boolean;
+        logDataSourceRegistration?: boolean;
+        globalTransactionOptions?: {
+            dataSources?: string[];
+            isolationLevel?: any;
+            rollbackOnError?: boolean;
+            timeout?: number;
+            logDetails?: boolean;
+        };
+        dataSourceRegistryConfig?: {
+            enableHealthCheck?: boolean;
+            healthCheckInterval?: number;
+            connectionTimeout?: number;
+            maxReconnectAttempts?: number;
+            logLifecycleEvents?: boolean;
+            autoCleanup?: boolean;
+        };
+    };
+    autoInitialize?: boolean;
+    global?: boolean;
+}
+/**
+ * TypeORM 模块包装器
+ * 提供批量注册和管理多个 TypeORM 数据源的功能
+ */
+export declare class TypeOrmModuleWrapper {
+    private static readonly logger;
+    /**
+     * 批量注册多个 TypeORM 数据源
+     */
+    static forRoot(options?: MultiTypeOrmModuleOptions): DynamicModule;
+    /**
+     * 为特定功能注册数据源
+     */
+    static forFeature(dataSourceNames: string[], entities?: any[]): DynamicModule;
+    /**
+     * 创建数据源提供者
+     */
+    static createDataSourceProvider(name: string): {
+        provide: string;
+        useFactory: (registry: DataSourceRegistryService) => Promise<DataSource>;
+        inject: (typeof DataSourceRegistryService)[];
+    };
+    /**
+     * 创建 EntityManager 提供者
+     */
+    static createEntityManagerProvider(name: string): {
+        provide: string;
+        useFactory: (registry: DataSourceRegistryService) => Promise<import("typeorm").EntityManager>;
+        inject: (typeof DataSourceRegistryService)[];
+    };
+    /**
+     * 创建 Repository 提供者
+     */
+    static createRepositoryProvider(entity: any, dataSourceName?: string): {
+        provide: string;
+        useFactory: (registry: DataSourceRegistryService) => Promise<import("typeorm").Repository<import("typeorm").ObjectLiteral>>;
+        inject: (typeof DataSourceRegistryService)[];
+    };
+}
+/**
+ * 全局多数据源 TypeORM 模块
+ */
+export declare class GlobalMultiTypeOrmModule {
+    static forRoot(options: MultiTypeOrmModuleOptions): DynamicModule;
+}

package/dist/transaction/typeorm-module-wrapper.js

@@ -0,0 +1,197 @@
+"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 __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 TypeOrmModuleWrapper_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalMultiTypeOrmModule = exports.TypeOrmModuleWrapper = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const transaction_module_1 = require("./transaction.module");
+const data_source_registry_1 = require("./data-source-registry");
+/**
+ * TypeORM 模块包装器
+ * 提供批量注册和管理多个 TypeORM 数据源的功能
+ */
+let TypeOrmModuleWrapper = TypeOrmModuleWrapper_1 = class TypeOrmModuleWrapper {
+    /**
+     * 批量注册多个 TypeORM 数据源
+     */
+    static forRoot(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const imports = [];
+        const providers = [];
+        const exports = [];
+        // 验证数据源配置
+        if (options === null || options === void 0 ? void 0 : options.dataSources) {
+            for (const config of options.dataSources) {
+                if (config.name === 'default') {
+                    throw new Error('DataSource name "default" is reserved and cannot be used. ' +
+                        'Please use a different name, such as "main", "primary", or "app".');
+                }
+            }
+        }
+        // 1. 导入 TypeORM 模块
+        const typeOrmModules = ((_a = options === null || options === void 0 ? void 0 : options.dataSources) === null || _a === void 0 ? void 0 : _a.map(config => {
+            return typeorm_1.TypeOrmModule.forRoot(Object.assign(Object.assign({}, config.options), { name: config.name, 
+                // 支持事务
+                retryAttempts: 3, retryDelay: 3000 }));
+        })) || [];
+        imports.push(...typeOrmModules);
+        // 2. 导入事务模块
+        const defaultDataSource = ((_c = (_b = options === null || options === void 0 ? void 0 : options.dataSources) === null || _b === void 0 ? void 0 : _b.find(ds => ds.isDefault)) === null || _c === void 0 ? void 0 : _c.name) ||
+            ((_d = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _d === void 0 ? void 0 : _d.defaultDataSource) ||
+            ((_f = (_e = options === null || options === void 0 ? void 0 : options.dataSources) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.name) ||
+            'main';
+        imports.push(transaction_module_1.TransactionModule.forRoot({
+            defaultDataSource,
+            enableDynamicRegistration: (_h = (_g = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _g === void 0 ? void 0 : _g.enableDynamicRegistration) !== null && _h !== void 0 ? _h : true,
+            logDataSourceRegistration: (_k = (_j = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _j === void 0 ? void 0 : _j.logDataSourceRegistration) !== null && _k !== void 0 ? _k : true,
+            globalTransactionOptions: (_l = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _l === void 0 ? void 0 : _l.globalTransactionOptions,
+            dataSourceRegistryConfig: (_m = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _m === void 0 ? void 0 : _m.dataSourceRegistryConfig,
+        }));
+        // 3. 创建数据源配置提供者
+        providers.push({
+            provide: 'TYPEORM_DATASOURCE_CONFIGS',
+            useValue: (options === null || options === void 0 ? void 0 : options.dataSources) || [],
+        });
+        // 4. 创建数据源初始化服务
+        if ((options === null || options === void 0 ? void 0 : options.autoInitialize) !== false) {
+            providers.push({
+                provide: 'DATASOURCE_INITIALIZER',
+                useFactory: (registry) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    // 将配置的数据源注册到注册表
+                    for (const config of (options === null || options === void 0 ? void 0 : options.dataSources) || []) {
+                        try {
+                            // 获取已初始化的数据源
+                            // 注意：TypeORMModule.forRoot 已经初始化了数据源
+                            // 这里我们只是注册到注册表以便管理
+                            TypeOrmModuleWrapper_1.logger.log(`Configuring DataSource: ${config.name}`);
+                        }
+                        catch (error) {
+                            TypeOrmModuleWrapper_1.logger.error(`Failed to configure DataSource ${config.name}:`, error.stack);
+                            if (!((_b = (_a = options === null || options === void 0 ? void 0 : options.transactionOptions) === null || _a === void 0 ? void 0 : _a.globalTransactionOptions) === null || _b === void 0 ? void 0 : _b.rollbackOnError)) {
+                                throw error;
+                            }
+                        }
+                    }
+                }),
+                inject: [data_source_registry_1.DataSourceRegistryService],
+            });
+        }
+        // 5. 导出所有注册的数据源（通过 token）- 需要先添加到 providers
+        for (const config of (options === null || options === void 0 ? void 0 : options.dataSources) || []) {
+            const dataSourceProvider = {
+                provide: `DATASOURCE_${config.name.toUpperCase()}`,
+                useFactory: (registry) => {
+                    return registry.getDataSource(config.name);
+                },
+                inject: [data_source_registry_1.DataSourceRegistryService],
+            };
+            providers.push(dataSourceProvider);
+            exports.push(`DATASOURCE_${config.name.toUpperCase()}`);
+        }
+        // 6. 重新导出 TransactionModule（它会导出 DataSourceRegistryService 等）
+        exports.push(transaction_module_1.TransactionModule);
+        // 7. 重新导出 TypeORM 模块
+        exports.push(...typeOrmModules);
+        return {
+            module: TypeOrmModuleWrapper_1,
+            imports,
+            providers,
+            exports,
+            global: options === null || options === void 0 ? void 0 : options.global,
+        };
+    }
+    /**
+     * 为特定功能注册数据源
+     */
+    static forFeature(dataSourceNames, entities) {
+        const imports = dataSourceNames.map(name => typeorm_1.TypeOrmModule.forFeature(entities || [], name));
+        return {
+            module: TypeOrmModuleWrapper_1,
+            imports,
+            exports: imports,
+        };
+    }
+    /**
+     * 创建数据源提供者
+     */
+    static createDataSourceProvider(name) {
+        return {
+            provide: `DATASOURCE_${name.toUpperCase()}`,
+            useFactory: (registry) => __awaiter(this, void 0, void 0, function* () {
+                const dataSource = registry.getDataSource(name);
+                if (!dataSource) {
+                    throw new Error(`DataSource '${name}' not found`);
+                }
+                return dataSource;
+            }),
+            inject: [data_source_registry_1.DataSourceRegistryService],
+        };
+    }
+    /**
+     * 创建 EntityManager 提供者
+     */
+    static createEntityManagerProvider(name) {
+        return {
+            provide: `ENTITY_MANAGER_${name.toUpperCase()}`,
+            useFactory: (registry) => __awaiter(this, void 0, void 0, function* () {
+                const dataSource = registry.getDataSource(name);
+                if (!dataSource) {
+                    throw new Error(`DataSource '${name}' not found`);
+                }
+                return dataSource.manager;
+            }),
+            inject: [data_source_registry_1.DataSourceRegistryService],
+        };
+    }
+    /**
+     * 创建 Repository 提供者
+     */
+    static createRepositoryProvider(entity, dataSourceName) {
+        return {
+            provide: `${entity.name}Repository`,
+            useFactory: (registry) => __awaiter(this, void 0, void 0, function* () {
+                const dsName = dataSourceName || 'default';
+                const dataSource = registry.getDataSource(dsName);
+                if (!dataSource) {
+                    throw new Error(`DataSource '${dsName}' not found`);
+                }
+                return dataSource.getRepository(entity);
+            }),
+            inject: [data_source_registry_1.DataSourceRegistryService],
+        };
+    }
+};
+exports.TypeOrmModuleWrapper = TypeOrmModuleWrapper;
+TypeOrmModuleWrapper.logger = new common_1.Logger(TypeOrmModuleWrapper_1.name);
+exports.TypeOrmModuleWrapper = TypeOrmModuleWrapper = TypeOrmModuleWrapper_1 = __decorate([
+    (0, common_1.Module)({})
+], TypeOrmModuleWrapper);
+/**
+ * 全局多数据源 TypeORM 模块
+ */
+let GlobalMultiTypeOrmModule = class GlobalMultiTypeOrmModule {
+    static forRoot(options) {
+        return TypeOrmModuleWrapper.forRoot(Object.assign(Object.assign({}, options), { global: true }));
+    }
+};
+exports.GlobalMultiTypeOrmModule = GlobalMultiTypeOrmModule;
+exports.GlobalMultiTypeOrmModule = GlobalMultiTypeOrmModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], GlobalMultiTypeOrmModule);

package/{validators → dist/validators}/file-mimetype.validator.d.ts

@@ -5,8 +5,6 @@ export type FileMimetypeValidatorOptions = {
     message?: string;
 };
 export declare class FileMimetypeValidator extends FileValidator<FileMimetypeValidatorOptions, IFile> {
-    private allowedMimetypes;
-    private message;
     constructor(options: FileMimetypeValidatorOptions);
     buildErrorMessage(): string;
     isValid(file?: IFile): boolean;

package/{validators → dist/validators}/file-mimetype.validator.js

@@ -5,17 +5,15 @@ const file_validator_interface_1 = require("@nestjs/common/pipes/file/file-valid
 class FileMimetypeValidator extends file_validator_interface_1.FileValidator {
     constructor(options) {
         super(options);
-        this.allowedMimetypes = options.allowedMimetypes;
-        this.message = options.message;
     }
     buildErrorMessage() {
-        if (this.message) {
-            return this.message;
+        if (this.validationOptions.message) {
+            return this.validationOptions.message;
         }
-        return `Invalid file type. Only ${this.allowedMimetypes.join(', ')} are allowed.`;
+        return `Invalid file type. Only ${this.validationOptions.allowedMimetypes.join(', ')} are allowed.`;
     }
     isValid(file) {
-        return this.allowedMimetypes.includes(file.mimetype);
+        return this.validationOptions.allowedMimetypes.includes(file.mimetype);
     }
 }
 exports.FileMimetypeValidator = FileMimetypeValidator;