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

package/redis-lock/redis-lock.service.js

@@ -72,13 +72,16 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
         this.redis = null;
         this.defaultOptions = {
             ttl: 300000, // 5 minutes
-            retryCount: 0,
-            retryDelay: 100,
+            retryCount: 3, // Increased from 0 to provide reasonable retry attempts
+            retryDelay: 500, // Increased from 100 to reduce retry frequency
             keyPrefix: 'lock',
             throwOnFailure: false,
             strategy: LockStrategy.SKIP,
             waitTimeout: undefined,
             autoExtend: 0, // No auto-extension by default
+            useExponentialBackoff: true, // Enable exponential backoff by default
+            maxRetryDelay: 30000, // Maximum retry delay of 30 seconds
+            retryJitter: 100, // Add random jitter to avoid synchronized retries
         };
         // Set global instance when created
         if (!RedisLockService_1.globalInstance) {
@@ -169,6 +172,7 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
      */
     acquireLock(key_1) {
         return __awaiter(this, arguments, void 0, function* (key, options = {}) {
+            var _a, _b, _c, _d, _e;
             const redis = yield this.getRedis();
             const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
             // Handle backward compatibility: if throwOnFailure is true, use THROW strategy
@@ -229,16 +233,42 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
                     }
                     // Wait before next attempt (except for last attempt)
                     if (attempts < maxAttempts) {
-                        yield this.sleep(opts.retryDelay);
+                        // Add random jitter to avoid synchronized retries
+                        const jitter = opts.retryJitter ? Math.random() * opts.retryJitter : 0;
+                        const totalDelay = opts.retryDelay + jitter;
+                        yield this.sleep(totalDelay);
                     }
                 }
                 catch (error) {
-                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
-                    this.logger.error(errorMessage, error.stack);
-                    if (opts.strategy === LockStrategy.THROW) {
-                        throw new Error(errorMessage);
+                    // Enhanced error classification and handling
+                    if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('ECONNREFUSED')) ||
+                        ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('ECONNRESET')) ||
+                        error.code === 'ECONNREFUSED') {
+                        // Connection error, will retry - log at debug level
+                        this.logger.debug(`Redis connection error, will retry: ${error.message}`);
+                    }
+                    else if (((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('READONLY')) ||
+                        ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('LOADING')) ||
+                        ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('MASTERDOWN'))) {
+                        // Redis server error, log at warn level
+                        this.logger.warn(`Redis server error: ${error.message}`);
+                    }
+                    else {
+                        // Other errors, log at error level
+                        const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                        this.logger.error(errorMessage, error.stack);
+                        if (opts.strategy === LockStrategy.THROW) {
+                            throw new Error(errorMessage);
+                        }
+                        return { acquired: false, error: errorMessage };
+                    }
+                    // For retryable errors, continue with retry logic
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        const jitter = opts.retryJitter ? Math.random() * opts.retryJitter : 0;
+                        const totalDelay = opts.retryDelay + jitter;
+                        yield this.sleep(totalDelay);
                     }
-                    return { acquired: false, error: errorMessage };
                 }
             }
             // Max attempts reached

package/setup/bootstrap.setup.d.ts

@@ -1,2 +1,3 @@
+import "../common/boilerplate.polyfill";
 import type { NestExpressApplication } from '@nestjs/platform-express';
 export declare function bootstrapSetup(AppModule: any, SetupSwagger: any): Promise<NestExpressApplication<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>>;

package/setup/bootstrap.setup.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bootstrapSetup = bootstrapSetup;
+require("../common/boilerplate.polyfill");
 const Sentry = require("@sentry/nestjs");
 const profiling_node_1 = require("@sentry/profiling-node");
 const dotenv = require("dotenv");

package/setup/schedule.decorator.js

@@ -106,8 +106,18 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 }
                 // Get or create global instance - auto-configures from environment variables
                 const lockService = redis_lock_1.RedisLockService.getOrCreateGlobalInstance();
-                const { lockTtl = 3600000, // 1 hour default
-                retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                const { lockTtl = 600000, // 10 minutes default (reduced from 1 hour)
+                retryCount = 3, retryDelay = 500, useExponentialBackoff = true, maxRetryDelay = 30000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                // Configuration validation and adjustment
+                const validatedLockTtl = lockTtl >= 3600000
+                    ? (logger.warn(`lockTtl (${lockTtl}ms) is quite long for a scheduled task, consider if this is appropriate for ${className}.${methodName}`), lockTtl)
+                    : lockTtl;
+                const validatedRetryCount = retryCount > 10
+                    ? (logger.warn(`retryCount (${retryCount}) is too high, limiting to 10 for task ${className}.${methodName}`), 10)
+                    : retryCount;
+                const validatedRetryDelay = retryDelay < 100
+                    ? (logger.warn(`retryDelay (${retryDelay}ms) is too low, setting to 100ms for task ${className}.${methodName}`), 100)
+                    : retryDelay;
                 const fullLockKey = `${lockKeyPrefix}:${resolvedLockKey}`;
                 const startTime = Date.now();
                 // Log task start
@@ -117,7 +127,7 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 try {
                     // Acquire lock
                     const lockResult = yield lockService.acquireLock(resolvedLockKey, {
-                        ttl: lockTtl,
+                        ttl: validatedLockTtl,
                         keyPrefix: lockKeyPrefix,
                         autoExtend: autoExtendLock,
                     });
@@ -133,8 +143,8 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                     try {
                         // Execute with retry logic
                         const result = yield executeWithRetry(() => originalMethod.apply(this, args), {
-                            retryCount,
-                            retryDelay,
+                            retryCount: validatedRetryCount,
+                            retryDelay: validatedRetryDelay,
                             useExponentialBackoff,
                             maxRetryDelay,
                             logger,
@@ -309,11 +319,11 @@ function WorkerIntervalWithLock(timeout, lockKeyOrOptions, lockTtl) {
         let options;
         if (typeof lockKeyOrOptions === 'string') {
             lockKey = lockKeyOrOptions;
-            options = { lockTtl: lockTtl || Math.floor(timeout * 0.8) };
+            options = { lockTtl: lockTtl || Math.max(Math.floor(timeout * 0.8), 10000) };
         }
         else {
             lockKey = generateLockKey(target.constructor.name, String(propertyKey));
-            options = Object.assign({ lockTtl: Math.floor(timeout * 0.8) }, lockKeyOrOptions);
+            options = Object.assign({ lockTtl: Math.max(Math.floor(timeout * 0.8), 10000) }, lockKeyOrOptions);
         }
         return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalWithLock', lockKey, options)(target, propertyKey, descriptor);
     };
@@ -406,7 +416,7 @@ function WorkerCronSmart(cronTime, options = {}, cronOptions) {
 function WorkerIntervalSmart(timeout, options = {}) {
     return function (target, propertyKey, descriptor) {
         const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
-        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.floor(timeout * 0.8), logExecution: true }, options))(target, propertyKey, descriptor);
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.max(Math.floor(timeout * 0.8), 10000), logExecution: true }, options))(target, propertyKey, descriptor);
     };
 }
 /**

package/shared/index.d.ts

@@ -1,2 +1,2 @@
-export * from './serviceRegistryModule';
+export * from './service-registry.module';
 export * from './services';

package/shared/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./serviceRegistryModule"), exports);
+__exportStar(require("./service-registry.module"), exports);
 __exportStar(require("./services"), exports);

package/shared/{serviceRegistryModule.js → service-registry.module.js}

@@ -27,8 +27,6 @@ const typeorm_1 = require("@nestjs/typeorm");
 const schedule_1 = require("@nestjs/schedule");
 const setup_1 = require("@sentry/nestjs/setup");
 const cache_1 = require("../cache");
-const transactional_1 = require("@nestjs-cls/transactional");
-const transactional_adapter_typeorm_1 = require("@nestjs-cls/transactional-adapter-typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const health_checker_1 = require("../health-checker");
 const nestjs_redis_1 = require("@songkeys/nestjs-redis");
@@ -40,7 +38,6 @@ const vault_1 = require("../vault");
 const validators_1 = require("../validators");
 const providers = [
     services_1.ApiConfigService,
-    services_1.ValidatorService,
     services_1.GeneratorService,
     services_1.TranslationService,
     validators_1.IsExistsValidator,
@@ -61,19 +58,6 @@ const modules = [
         expandVariables: false,
         envFilePath: [process.env.ENV_FILE_PATH, process.env.BASE_ENV_FILE_PATH],
     }),
-    nestjs_cls_1.ClsModule.forRoot({
-        global: true,
-        middleware: { mount: true, saveReq: true },
-        plugins: [
-            new transactional_1.ClsPluginTransactional({
-                imports: [typeorm_1.TypeOrmModule],
-                adapter: new transactional_adapter_typeorm_1.TransactionalAdapterTypeOrm({
-                    dataSourceToken: typeorm_2.DataSource,
-                }),
-                enableTransactionProxy: true,
-            }),
-        ],
-    }),
     nestjs_pino_1.LoggerModule.forRootAsync({
         inject: [services_1.ApiConfigService],
         useFactory: (config) => config.pinoConfig,
@@ -105,6 +89,15 @@ if (services_1.ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
         inject: [services_1.ApiConfigService],
         useFactory: (config) => config.typeormConfig,
     }));
+    modules.push(nestjs_cls_1.ClsModule.forRootAsync({
+        imports: [typeorm_1.TypeOrmModule],
+        useFactory(args) {
+            return {
+                middleware: { mount: true, saveReq: true },
+            };
+        },
+        global: true,
+    }));
 }
 if (services_1.ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {
     modules.push(bull_1.BullModule.forRootAsync({

package/shared/services/index.d.ts

@@ -1,4 +1,3 @@
 export * from './api-config.service';
 export * from './generator.service';
 export * from './translation.service';
-export * from './validator.service';

package/shared/services/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-config.service"), exports);
 __exportStar(require("./generator.service"), exports);
 __exportStar(require("./translation.service"), exports);
-__exportStar(require("./validator.service"), exports);

package/transaction/__tests__/mocks.d.ts

@@ -0,0 +1,9 @@
+import { TransactionStatus } from '../transaction-manager';
+/**
+ * 创建 Mock TransactionStatus
+ */
+export declare function createMockTransactionStatus(overrides?: Partial<TransactionStatus>): TransactionStatus;
+/**
+ * 创建 Mock EntityManager
+ */
+export declare function createMockEntityManager(): any;

package/transaction/__tests__/mocks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockTransactionStatus = createMockTransactionStatus;
+exports.createMockEntityManager = createMockEntityManager;
+/**
+ * 创建 Mock TransactionStatus
+ */
+function createMockTransactionStatus(overrides) {
+    return Object.assign({ isCompleted: false, isRollbackOnly: false, isNewTransaction: false, dataSourceName: 'default', startTime: new Date(), definition: {
+            propagation: 0, // Propagation.REQUIRED
+        }, nestingLevel: 1 }, overrides);
+}
+/**
+ * 创建 Mock EntityManager
+ */
+function createMockEntityManager() {
+    const mockEntityManager = {
+        save: jest.fn().mockResolvedValue({}),
+        find: jest.fn().mockResolvedValue([]),
+        findOne: jest.fn().mockResolvedValue(null),
+        update: jest.fn().mockResolvedValue(undefined),
+        delete: jest.fn().mockResolvedValue(undefined),
+        remove: jest.fn().mockResolvedValue({}),
+        count: jest.fn().mockResolvedValue(0),
+        query: jest.fn().mockResolvedValue([]),
+        createQueryBuilder: jest.fn().mockReturnValue({}),
+        getRepository: jest.fn().mockReturnValue({}),
+        queryRunner: {
+            isTransactionActive: false,
+        },
+    };
+    return mockEntityManager;
+}

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

@@ -0,0 +1,99 @@
+import { Logger } from '@nestjs/common';
+import { Repository, EntityManager } from 'typeorm';
+import { TransactionManager, Propagation, IsolationLevel, TransactionStatus } from './transaction-manager';
+/**
+ * 事务感知的基础服务类
+ * 提供统一的数据操作接口，自动处理事务
+ */
+export declare abstract class BaseService {
+    protected readonly transactionManager: TransactionManager;
+    protected readonly defaultDataSourceName: string;
+    protected readonly logger: Logger;
+    constructor(transactionManager: TransactionManager, defaultDataSourceName?: string);
+    /**
+     * 获取指定数据源的 EntityManager
+     */
+    protected getEntityManager(dataSourceName?: string): EntityManager;
+    /**
+     * 手动在事务中执行
+     */
+    protected executeInTransaction<T>(callback: (em: EntityManager) => Promise<T>, options?: {
+        propagation?: Propagation;
+        readOnly?: boolean;
+        isolation?: IsolationLevel;
+        dataSource?: string;
+    }): Promise<T>;
+    /**
+     * 保存实体
+     */
+    protected save<T>(entity: T, dataSourceName?: string): Promise<T>;
+    /**
+     * 批量保存实体
+     */
+    protected saveMany<T>(entities: T[], dataSourceName?: string): Promise<T[]>;
+    /**
+     * 更新实体
+     */
+    protected update<T>(entityClass: any, criteria: any, partialEntity: Partial<T>, dataSourceName?: string): Promise<void>;
+    /**
+     * 删除实体
+     */
+    protected remove<T>(entity: T, dataSourceName?: string): Promise<T>;
+    /**
+     * 根据 ID 删除实体
+     */
+    protected delete<T>(entityClass: any, id: string | number | (string | number)[], dataSourceName?: string): Promise<void>;
+    /**
+     * 查找实体
+     */
+    protected find<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<T[]>;
+    /**
+     * 查找一个实体
+     */
+    protected findOne<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<T | null>;
+    /**
+     * 根据 ID 查找实体
+     */
+    protected findById<T>(entityClass: any, id: string | number, dataSourceName?: string): Promise<T | null>;
+    /**
+     * 计数
+     */
+    protected count<T>(entityClass: any, options?: any, dataSourceName?: string): Promise<number>;
+    /**
+     * 执行原生 SQL
+     */
+    protected query<T = any>(query: string, parameters?: any[], dataSourceName?: string): Promise<T[]>;
+    /**
+     * 创建 Query Builder
+     */
+    protected createQueryBuilder<T>(entityClass: any, alias?: string, dataSourceName?: string): Promise<import("typeorm").SelectQueryBuilder<import("typeorm").ObjectLiteral>>;
+    /**
+     * 获取 Repository
+     */
+    protected getRepository<T>(entity: any, dataSourceName?: string): Promise<Repository<T>>;
+    /**
+     * 执行跨数据源操作
+     */
+    protected executeAcrossDataSources<T>(operations: Array<{
+        dataSourceName: string;
+        operation: (em: EntityManager) => Promise<any>;
+    }>, options?: {
+        rollbackOnError?: boolean;
+    }): Promise<T[]>;
+    /**
+     * 批量操作优化
+     */
+    protected batchOperation<T, R>(items: T[], batchSize: number, operation: (batch: T[], em: EntityManager) => Promise<R[]>, options?: {
+        continueOnError?: boolean;
+        isolation?: IsolationLevel;
+        dataSourceName?: string;
+    }): Promise<R[]>;
+    /**
+     * 检查是否在事务中
+     */
+    protected isInTransaction(dataSourceName?: string): boolean;
+    /**
+     * 获取当前事务状态
+     */
+    protected getCurrentTransactionStatus(dataSourceName?: string): TransactionStatus;
+}

package/transaction/base-service-transaction.js

@@ -0,0 +1,286 @@
+"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 BaseService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const common_1 = require("@nestjs/common");
+const transaction_manager_1 = require("./transaction-manager");
+/**
+ * 事务感知的基础服务类
+ * 提供统一的数据操作接口，自动处理事务
+ */
+let BaseService = BaseService_1 = class BaseService {
+    constructor(transactionManager, defaultDataSourceName = 'default') {
+        this.transactionManager = transactionManager;
+        this.defaultDataSourceName = defaultDataSourceName;
+        this.logger = new common_1.Logger(BaseService_1.name);
+    }
+    /**
+     * 获取指定数据源的 EntityManager
+     */
+    getEntityManager(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        const em = this.transactionManager.getCurrentEntityManager(dsName);
+        if (!em) {
+            throw new Error(`No active transaction for dataSource: ${dsName}. ` +
+                `Use @Transactional decorator to start a transaction.`);
+        }
+        return em;
+    }
+    /**
+     * 手动在事务中执行
+     */
+    executeInTransaction(callback, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield this.transactionManager.getTransaction({
+                propagation: (options === null || options === void 0 ? void 0 : options.propagation) || transaction_manager_1.Propagation.REQUIRED,
+                readOnly: (options === null || options === void 0 ? void 0 : options.readOnly) || false,
+                isolationLevel: options === null || options === void 0 ? void 0 : options.isolation,
+                dataSourceName: (options === null || options === void 0 ? void 0 : options.dataSource) || this.defaultDataSourceName,
+                name: `executeInTransaction-${this.constructor.name}`,
+            });
+            try {
+                const em = this.getEntityManager(options === null || options === void 0 ? void 0 : options.dataSource);
+                const result = yield callback(em);
+                yield this.transactionManager.commit(status);
+                return result;
+            }
+            catch (error) {
+                yield this.transactionManager.rollback(status);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 保存实体
+     */
+    save(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.save(entity);
+        });
+    }
+    /**
+     * 批量保存实体
+     */
+    saveMany(entities, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.save(entities);
+        });
+    }
+    /**
+     * 更新实体
+     */
+    update(entityClass, criteria, partialEntity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            yield em.update(entityClass, criteria, partialEntity);
+        });
+    }
+    /**
+     * 删除实体
+     */
+    remove(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.remove(entity);
+        });
+    }
+    /**
+     * 根据 ID 删除实体
+     */
+    delete(entityClass, id, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            yield em.delete(entityClass, id);
+        });
+    }
+    /**
+     * 查找实体
+     */
+    find(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.find(entityClass, options);
+        });
+    }
+    /**
+     * 查找一个实体
+     */
+    findOne(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.findOne(entityClass, options);
+        });
+    }
+    /**
+     * 根据 ID 查找实体
+     */
+    findById(entityClass, id, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.findOne(entityClass, {
+                where: { id },
+            });
+        });
+    }
+    /**
+     * 计数
+     */
+    count(entityClass, options, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.count(entityClass, options);
+        });
+    }
+    /**
+     * 执行原生 SQL
+     */
+    query(query, parameters, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.query(query, parameters);
+        });
+    }
+    /**
+     * 创建 Query Builder
+     */
+    createQueryBuilder(entityClass, alias, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.createQueryBuilder(entityClass, alias || entityClass.name.toLowerCase());
+        });
+    }
+    /**
+     * 获取 Repository
+     */
+    getRepository(entity, dataSourceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const em = this.getEntityManager(dataSourceName);
+            return em.getRepository(entity);
+        });
+    }
+    /**
+     * 执行跨数据源操作
+     */
+    executeAcrossDataSources(operations, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            const startedTransactions = [];
+            try {
+                // 在每个数据源上开始事务
+                for (const op of operations) {
+                    const status = yield this.transactionManager.getTransaction({
+                        propagation: transaction_manager_1.Propagation.REQUIRED,
+                        dataSourceName: op.dataSourceName,
+                    });
+                    startedTransactions.push(status);
+                }
+                // 执行所有操作
+                for (const op of operations) {
+                    const em = this.getEntityManager(op.dataSourceName);
+                    const result = yield op.operation(em);
+                    results.push(result);
+                }
+                // 提交所有事务
+                for (const status of startedTransactions) {
+                    yield this.transactionManager.commit(status);
+                }
+                return results;
+            }
+            catch (error) {
+                // 回滚所有事务
+                if ((options === null || options === void 0 ? void 0 : options.rollbackOnError) !== false) {
+                    for (const status of startedTransactions.reverse()) {
+                        try {
+                            yield this.transactionManager.rollback(status);
+                        }
+                        catch (rollbackError) {
+                            this.logger.error(`Failed to rollback transaction on ${status.dataSourceName}:`, rollbackError);
+                        }
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * 批量操作优化
+     */
+    batchOperation(items, batchSize, operation, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allResults = [];
+            let processedCount = 0;
+            return yield this.executeInTransaction((em) => __awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < items.length; i += batchSize) {
+                    const batch = items.slice(i, i + batchSize);
+                    const batchNumber = Math.floor(i / batchSize) + 1;
+                    try {
+                        this.logger.log(`Processing batch ${batchNumber}/${Math.ceil(items.length / batchSize)}`);
+                        const results = yield operation(batch, em);
+                        allResults.push(...results);
+                        processedCount += batch.length;
+                    }
+                    catch (error) {
+                        this.logger.error(`Batch ${batchNumber} failed:`, error);
+                        if (options === null || options === void 0 ? void 0 : options.continueOnError) {
+                            // 记录失败但继续
+                            processedCount += batch.length;
+                            continue;
+                        }
+                        else {
+                            throw new Error(`Batch operation failed at batch ${batchNumber}. Processed ${processedCount}/${items.length} items.`);
+                        }
+                    }
+                }
+                return allResults;
+            }), {
+                isolation: options === null || options === void 0 ? void 0 : options.isolation,
+                dataSource: options === null || options === void 0 ? void 0 : options.dataSourceName,
+            });
+        });
+    }
+    /**
+     * 检查是否在事务中
+     */
+    isInTransaction(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        const status = this.transactionManager.getCurrentTransaction(dsName);
+        return status !== null && !status.isCompleted;
+    }
+    /**
+     * 获取当前事务状态
+     */
+    getCurrentTransactionStatus(dataSourceName) {
+        const dsName = dataSourceName || this.defaultDataSourceName;
+        return this.transactionManager.getCurrentTransaction(dsName);
+    }
+};
+exports.BaseService = BaseService;
+exports.BaseService = BaseService = BaseService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)('DEFAULT_DATA_SOURCE_NAME')),
+    __metadata("design:paramtypes", [transaction_manager_1.TransactionManager, String])
+], BaseService);