@nest-omni/core 4.1.3-10 → 4.1.3-12

package/transaction/cls-compatibility.service.d.ts

@@ -0,0 +1,55 @@
+import { EntityManager } from 'typeorm';
+import { TransactionContextService } from './transaction-context.service';
+/**
+ * CLS (Continuation Local Storage) 兼容服务
+ * 提供与 nestjs-cls 兼容的 API，但底层使用事务上下文服务
+ */
+export declare class ClsCompatibilityService {
+    private readonly transactionContext;
+    private readonly defaultDataSource?;
+    private readonly store;
+    constructor(transactionContext: TransactionContextService, defaultDataSource?: string);
+    /**
+     * 设置值到存储中
+     */
+    set<T>(key: string, value: T): void;
+    /**
+     * 从存储中获取值
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * 根据数据源名称获取 EntityManager
+     */
+    getEntityManager(dataSourceName?: string): EntityManager | null;
+    /**
+     * 设置指定数据源的 EntityManager
+     */
+    setEntityManager(dataSourceName: string, entityManager: EntityManager): void;
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName?: string): boolean;
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getActiveTransactions(): Map<string, {
+        entityManager: EntityManager;
+        dataSource: any;
+    }>;
+    /**
+     * 清理存储
+     */
+    clear(): void;
+}
+/**
+ * CLS 服务管理器（静态类，模拟 nestjs-cls 的 API）
+ */
+export declare class ClsServiceManager {
+    private static clsService;
+    static setClsService(clsService: ClsCompatibilityService): void;
+    static getClsService(): ClsCompatibilityService;
+}
+/**
+ * CLS 装饰器（兼容性）
+ */
+export declare function SetCls(key?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/transaction/cls-compatibility.service.js

@@ -0,0 +1,127 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClsServiceManager = exports.ClsCompatibilityService = void 0;
+exports.SetCls = SetCls;
+const common_1 = require("@nestjs/common");
+const transaction_context_service_1 = require("./transaction-context.service");
+/**
+ * CLS (Continuation Local Storage) 兼容服务
+ * 提供与 nestjs-cls 兼容的 API，但底层使用事务上下文服务
+ */
+let ClsCompatibilityService = class ClsCompatibilityService {
+    constructor(transactionContext, defaultDataSource) {
+        this.transactionContext = transactionContext;
+        this.defaultDataSource = defaultDataSource;
+        this.store = new Map();
+    }
+    /**
+     * 设置值到存储中
+     */
+    set(key, value) {
+        if (key === 'entityManager') {
+            // 如果设置 entityManager，则根据数据源名称设置到事务上下文
+            const dataSourceName = this.defaultDataSource || 'default';
+            this.transactionContext.setContext(dataSourceName, value);
+        }
+        else {
+            this.store.set(key, value);
+        }
+    }
+    /**
+     * 从存储中获取值
+     */
+    get(key) {
+        if (key === 'entityManager') {
+            // 获取默认数据源的 EntityManager
+            const dataSourceName = this.defaultDataSource || 'default';
+            return this.transactionContext.getEntityManager(dataSourceName);
+        }
+        else {
+            return this.store.get(key);
+        }
+    }
+    /**
+     * 根据数据源名称获取 EntityManager
+     */
+    getEntityManager(dataSourceName) {
+        return this.transactionContext.getEntityManager(dataSourceName || this.defaultDataSource || 'default');
+    }
+    /**
+     * 设置指定数据源的 EntityManager
+     */
+    setEntityManager(dataSourceName, entityManager) {
+        this.transactionContext.setContext(dataSourceName, entityManager);
+    }
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName) {
+        return this.transactionContext.isInTransaction(dataSourceName || this.defaultDataSource || 'default');
+    }
+    /**
+     * 获取所有活跃的事务上下文
+     */
+    getActiveTransactions() {
+        const contexts = this.transactionContext.getAllActiveContexts();
+        const result = new Map();
+        for (const [name, context] of contexts) {
+            result.set(name, {
+                entityManager: context.entityManager,
+                dataSource: context.dataSource,
+            });
+        }
+        return result;
+    }
+    /**
+     * 清理存储
+     */
+    clear() {
+        this.store.clear();
+        this.transactionContext.clearContext();
+    }
+};
+exports.ClsCompatibilityService = ClsCompatibilityService;
+exports.ClsCompatibilityService = ClsCompatibilityService = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('CLS_DEFAULT_DATA_SOURCE')),
+    __metadata("design:paramtypes", [transaction_context_service_1.TransactionContextService, String])
+], ClsCompatibilityService);
+/**
+ * CLS 服务管理器（静态类，模拟 nestjs-cls 的 API）
+ */
+class ClsServiceManager {
+    static setClsService(clsService) {
+        ClsServiceManager.clsService = clsService;
+    }
+    static getClsService() {
+        if (!ClsServiceManager.clsService) {
+            throw new Error('CLS service not initialized. Please ensure TransactionModule is imported.');
+        }
+        return ClsServiceManager.clsService;
+    }
+}
+exports.ClsServiceManager = ClsServiceManager;
+ClsServiceManager.clsService = null;
+/**
+ * CLS 装饰器（兼容性）
+ */
+function SetCls(key) {
+    return function (target, propertyKey, parameterIndex) {
+        const existing = Reflect.getMetadata('cls_params', target) || {};
+        existing[parameterIndex] = { key };
+        Reflect.defineMetadata('cls_params', existing, target);
+    };
+}

package/transaction/data-source-registry.d.ts

@@ -0,0 +1,91 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import { DataSource, DataSourceOptions } from 'typeorm';
+/**
+ * 数据源注册表配置
+ */
+export interface DataSourceRegistryConfig {
+    enableHealthCheck?: boolean;
+    healthCheckInterval?: number;
+    connectionTimeout?: number;
+    maxReconnectAttempts?: number;
+    logLifecycleEvents?: boolean;
+    autoCleanup?: boolean;
+}
+/**
+ * 数据源健康状态
+ */
+export interface DataSourceHealthStatus {
+    name: string;
+    isConnected: boolean;
+    lastChecked: Date;
+    error?: string;
+    responseTime?: number;
+}
+/**
+ * 数据源注册表管理器
+ * 负责管理所有动态注册的数据源
+ */
+export declare class DataSourceRegistryService implements OnModuleInit, OnModuleDestroy {
+    private readonly logger;
+    private healthCheckInterval;
+    private healthStatuses;
+    private config;
+    constructor(config?: DataSourceRegistryConfig);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * 注册新的数据源
+     */
+    registerDataSource(name: string, options: DataSourceOptions, metadata?: Record<string, any>): Promise<DataSource>;
+    /**
+     * 注册已存在的数据源
+     */
+    registerExistingDataSource(name: string, dataSource: DataSource, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * 注销数据源
+     */
+    unregisterDataSource(name: string): Promise<void>;
+    /**
+     * 获取数据源
+     */
+    getDataSource(name: string): DataSource | null;
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    getRegisteredDataSources(): string[];
+    /**
+     * 批量注册数据源
+     */
+    registerDataSources(configs: Array<{
+        name: string;
+        options: DataSourceOptions;
+        metadata?: Record<string, any>;
+    }>, options?: {
+        continueOnError?: boolean;
+        parallel?: boolean;
+    }): Promise<DataSource[]>;
+    /**
+     * 测试数据源连接
+     */
+    testConnection(name: string): Promise<boolean>;
+    /**
+     * 获取所有数据源的健康状态
+     */
+    getHealthStatuses(): Map<string, DataSourceHealthStatus>;
+    /**
+     * 重新连接数据源
+     */
+    reconnectDataSource(name: string): Promise<boolean>;
+    /**
+     * 开始健康检查
+     */
+    private startHealthCheck;
+    /**
+     * 清理指定数据源
+     */
+    private cleanupDataSources;
+    /**
+     * 清理所有动态数据源
+     */
+    private cleanupAllDataSources;
+}

package/transaction/data-source-registry.js

@@ -0,0 +1,349 @@
+"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 DataSourceRegistryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceRegistryService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const transaction_context_service_1 = require("./transaction-context.service");
+const database_adapter_1 = require("./database-adapter");
+/**
+ * 数据源注册表管理器
+ * 负责管理所有动态注册的数据源
+ */
+let DataSourceRegistryService = DataSourceRegistryService_1 = class DataSourceRegistryService {
+    constructor(config) {
+        this.logger = new common_1.Logger(DataSourceRegistryService_1.name);
+        this.healthCheckInterval = null;
+        this.healthStatuses = new Map();
+        this.config = {
+            enableHealthCheck: false,
+            healthCheckInterval: 30000, // 30秒
+            connectionTimeout: 5000, // 5秒
+            maxReconnectAttempts: 3,
+            logLifecycleEvents: true,
+            autoCleanup: true,
+        };
+        if (config) {
+            this.config = Object.assign(Object.assign({}, this.config), config);
+        }
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.enableHealthCheck) {
+                this.startHealthCheck();
+            }
+            if (this.config.logLifecycleEvents) {
+                this.logger.log(`Initialized with config: ${JSON.stringify(this.config)}`);
+            }
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.healthCheckInterval) {
+                clearInterval(this.healthCheckInterval);
+                this.healthCheckInterval = null;
+            }
+            // 清理所有动态注册的数据源
+            yield this.cleanupAllDataSources();
+        });
+    }
+    /**
+     * 注册新的数据源
+     */
+    registerDataSource(name, options, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 创建数据源
+                const dataSource = new typeorm_1.DataSource(options);
+                // 初始化连接
+                if (!dataSource.isInitialized) {
+                    yield dataSource.initialize();
+                }
+                // 注册到事务上下文服务
+                yield transaction_context_service_1.TransactionContextService.addDataSource(name, dataSource, {
+                    options,
+                    metadata,
+                });
+                // 初始化健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: true,
+                        lastChecked: new Date(),
+                    });
+                }
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Registered DataSource: ${name}`);
+                }
+                return dataSource;
+            }
+            catch (error) {
+                this.logger.error(`Failed to register DataSource ${name}:`, error.stack);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 注册已存在的数据源
+     */
+    registerExistingDataSource(name, dataSource, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield transaction_context_service_1.TransactionContextService.addDataSource(name, dataSource, {
+                metadata,
+            });
+            if (this.config.enableHealthCheck) {
+                this.healthStatuses.set(name, {
+                    name,
+                    isConnected: dataSource.isInitialized,
+                    lastChecked: new Date(),
+                });
+            }
+        });
+    }
+    /**
+     * 注销数据源
+     */
+    unregisterDataSource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (config) {
+                // 关闭数据源连接
+                if (config.dataSource.isInitialized) {
+                    yield config.dataSource.destroy();
+                }
+                // 从注册表中移除
+                yield transaction_context_service_1.TransactionContextService.removeDataSource(name);
+                this.healthStatuses.delete(name);
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Unregistered DataSource: ${name}`);
+                }
+            }
+        });
+    }
+    /**
+     * 获取数据源
+     */
+    getDataSource(name) {
+        const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+        return (config === null || config === void 0 ? void 0 : config.dataSource) || null;
+    }
+    /**
+     * 获取所有已注册的数据源名称
+     */
+    getRegisteredDataSources() {
+        return transaction_context_service_1.TransactionContextService.getRegisteredDataSources();
+    }
+    /**
+     * 批量注册数据源
+     */
+    registerDataSources(configs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSources = [];
+            if (options === null || options === void 0 ? void 0 : options.parallel) {
+                // 并行注册
+                const promises = configs.map((config) => __awaiter(this, void 0, void 0, function* () {
+                    const ds = yield this.registerDataSource(config.name, config.options, config.metadata);
+                    return ds;
+                }));
+                try {
+                    const results = yield Promise.all(promises);
+                    dataSources.push(...results);
+                }
+                catch (error) {
+                    if (!(options === null || options === void 0 ? void 0 : options.continueOnError)) {
+                        // 清理已注册的数据源
+                        yield this.cleanupDataSources(dataSources.map((ds) => ds.options));
+                        throw error;
+                    }
+                }
+            }
+            else {
+                // 串行注册
+                for (const config of configs) {
+                    try {
+                        const ds = yield this.registerDataSource(config.name, config.options, config.metadata);
+                        dataSources.push(ds);
+                    }
+                    catch (error) {
+                        if (!(options === null || options === void 0 ? void 0 : options.continueOnError)) {
+                            // 清理已注册的数据源
+                            yield this.cleanupDataSources(dataSources.map((ds) => ds.options));
+                            throw error;
+                        }
+                    }
+                }
+            }
+            return dataSources;
+        });
+    }
+    /**
+     * 测试数据源连接
+     */
+    testConnection(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (!config) {
+                return false;
+            }
+            const startTime = Date.now();
+            try {
+                // 使用数据库适配器执行健康检查
+                const isHealthy = yield database_adapter_1.DatabaseAdapter.healthCheck(config.dataSource);
+                const responseTime = Date.now() - startTime;
+                if (!isHealthy) {
+                    throw new Error('Health check query failed');
+                }
+                // 更新健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: true,
+                        lastChecked: new Date(),
+                        responseTime,
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                // 更新健康状态
+                if (this.config.enableHealthCheck) {
+                    this.healthStatuses.set(name, {
+                        name,
+                        isConnected: false,
+                        lastChecked: new Date(),
+                        error: error.message,
+                        responseTime: Date.now() - startTime,
+                    });
+                }
+                return false;
+            }
+        });
+    }
+    /**
+     * 获取所有数据源的健康状态
+     */
+    getHealthStatuses() {
+        return new Map(this.healthStatuses);
+    }
+    /**
+     * 重新连接数据源
+     */
+    reconnectDataSource(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+            if (!config || !config.options) {
+                throw new Error(`Cannot reconnect: DataSource '${name}' has no connection options`);
+            }
+            try {
+                // 关闭现有连接
+                if (config.dataSource.isInitialized) {
+                    yield config.dataSource.destroy();
+                }
+                // 重新初始化
+                yield config.dataSource.initialize();
+                // 测试连接
+                const isConnected = yield this.testConnection(name);
+                if (this.config.logLifecycleEvents) {
+                    this.logger.log(`Reconnected DataSource: ${name}, Success: ${isConnected}`);
+                }
+                return isConnected;
+            }
+            catch (error) {
+                this.logger.error(`Failed to reconnect DataSource ${name}:`, error.stack);
+                return false;
+            }
+        });
+    }
+    /**
+     * 开始健康检查
+     */
+    startHealthCheck() {
+        this.healthCheckInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const dataSources = this.getRegisteredDataSources();
+            for (const name of dataSources) {
+                yield this.testConnection(name);
+                // 自动重连
+                const status = this.healthStatuses.get(name);
+                if (!(status === null || status === void 0 ? void 0 : status.isConnected) && this.config.autoCleanup) {
+                    this.logger.warn(`DataSource ${name} is unhealthy, attempting reconnect...`);
+                    let attempts = 0;
+                    const maxAttempts = this.config.maxReconnectAttempts || 3;
+                    while (attempts < maxAttempts) {
+                        const reconnected = yield this.reconnectDataSource(name);
+                        if (reconnected) {
+                            break;
+                        }
+                        attempts++;
+                    }
+                    if (!((_a = this.healthStatuses.get(name)) === null || _a === void 0 ? void 0 : _a.isConnected)) {
+                        this.logger.error(`Failed to reconnect DataSource ${name} after ${maxAttempts} attempts`);
+                    }
+                }
+            }
+        }), this.config.healthCheckInterval);
+        this.logger.log('Health check started');
+    }
+    /**
+     * 清理指定数据源
+     */
+    cleanupDataSources(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 找到对应的数据源并清理
+            for (const opt of options) {
+                // 这里需要从配置反向查找数据源名称
+                // 简化实现：遍历所有已注册的数据源
+                const names = this.getRegisteredDataSources();
+                for (const name of names) {
+                    const config = transaction_context_service_1.TransactionContextService.getDataSourceConfig(name);
+                    if ((config === null || config === void 0 ? void 0 : config.dataSource.options) === opt) {
+                        yield this.unregisterDataSource(name);
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * 清理所有动态数据源
+     */
+    cleanupAllDataSources() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const names = this.getRegisteredDataSources();
+            for (const name of names) {
+                yield this.unregisterDataSource(name);
+            }
+            if (this.config.logLifecycleEvents) {
+                this.logger.log('All dynamic DataSources cleaned up');
+            }
+        });
+    }
+};
+exports.DataSourceRegistryService = DataSourceRegistryService;
+exports.DataSourceRegistryService = DataSourceRegistryService = DataSourceRegistryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)('DATA_SOURCE_REGISTRY_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], DataSourceRegistryService);

package/transaction/database-adapter.d.ts

@@ -0,0 +1,44 @@
+import { DataSource, QueryRunner } from 'typeorm';
+/**
+ * 数据库类型
+ */
+export type DatabaseType = 'mysql' | 'mariadb' | 'postgres' | 'cockroachdb' | 'sqlite' | 'better-sqlite3' | 'mssql' | 'oracle' | 'mongodb' | 'cordova' | 'react-native' | 'nativescript' | 'sqljs' | 'expo' | 'capacitor';
+/**
+ * 数据库适配器
+ * 处理不同数据库的 SQL 语法差异
+ */
+export declare class DatabaseAdapter {
+    /**
+     * 获取数据库类型
+     */
+    static getDatabaseType(dataSource: DataSource): DatabaseType;
+    /**
+     * 检查数据库是否支持 SAVEPOINT
+     */
+    static supportsSavepoint(dataSource: DataSource): boolean;
+    /**
+     * 创建保存点
+     */
+    static createSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 回滚到保存点
+     */
+    static rollbackToSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 释放保存点
+     */
+    static releaseSavepoint(queryRunner: QueryRunner, savepointName: string): Promise<void>;
+    /**
+     * 执行健康检查查询
+     */
+    static healthCheck(dataSource: DataSource): Promise<boolean>;
+    /**
+     * 获取数据库特定的信息
+     */
+    static getDatabaseInfo(dataSource: DataSource): {
+        type: DatabaseType;
+        supportsSavepoint: boolean;
+        supportsNestedTransactions: boolean;
+        requiresReleaseSavepoint: boolean;
+    };
+}