@nest-omni/core 4.1.3-3 → 4.1.3-31

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

@@ -72,18 +72,23 @@ 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) {
             RedisLockService_1.globalInstance = this;
         }
+        // Initialize instance ID
+        this.instanceId = this.getInstanceId();
     }
     /**
      * Get the global singleton instance
@@ -167,8 +172,37 @@ 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);
+            // Validate TTL
+            if (opts.ttl !== undefined) {
+                if (typeof opts.ttl !== 'number' || opts.ttl <= 0) {
+                    this.logger.warn(`Invalid TTL value: ${opts.ttl}. TTL must be a positive number. Using default TTL: ${this.defaultOptions.ttl}ms`);
+                    opts.ttl = this.defaultOptions.ttl;
+                }
+            }
+            // Validate waitTimeout
+            if (opts.waitTimeout !== undefined) {
+                if (typeof opts.waitTimeout !== 'number' || opts.waitTimeout <= 0) {
+                    this.logger.warn(`Invalid waitTimeout value: ${opts.waitTimeout}. waitTimeout must be a positive number. Ignoring waitTimeout.`);
+                    opts.waitTimeout = undefined;
+                }
+            }
+            // Validate retryCount
+            if (opts.retryCount !== undefined) {
+                if (typeof opts.retryCount !== 'number' || opts.retryCount < 0) {
+                    this.logger.warn(`Invalid retryCount value: ${opts.retryCount}. retryCount must be a non-negative number. Using default: ${this.defaultOptions.retryCount}`);
+                    opts.retryCount = this.defaultOptions.retryCount;
+                }
+            }
+            // Validate retryDelay
+            if (opts.retryDelay !== undefined) {
+                if (typeof opts.retryDelay !== 'number' || opts.retryDelay <= 0) {
+                    this.logger.warn(`Invalid retryDelay value: ${opts.retryDelay}. retryDelay must be a positive number. Using default: ${this.defaultOptions.retryDelay}ms`);
+                    opts.retryDelay = this.defaultOptions.retryDelay;
+                }
+            }
             // Handle backward compatibility: if throwOnFailure is true, use THROW strategy
             if (opts.throwOnFailure && !options.strategy) {
                 opts.strategy = LockStrategy.THROW;
@@ -227,16 +261,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
@@ -439,6 +499,8 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
      *
      * WARNING: Use with caution in production! This will forcefully delete locks.
      *
+     * **Note**: Uses SCAN command to avoid blocking Redis in production.
+     *
      * @param pattern - Lock pattern (e.g., 'MyService:*' or '*:migration:*')
      * @param keyPrefix - Key prefix (default: 'lock')
      * @returns Number of locks deleted
@@ -457,14 +519,28 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             const redis = yield this.getRedis();
             const searchPattern = `${keyPrefix}:${pattern}`;
             try {
-                const keys = yield redis.keys(searchPattern);
-                if (keys.length === 0) {
+                let cursor = '0';
+                const allKeys = [];
+                // Use SCAN to iterate through keys without blocking Redis
+                do {
+                    const [nextCursor, keys] = yield redis.scan(cursor, 'MATCH', searchPattern, 'COUNT', 100);
+                    cursor = nextCursor;
+                    allKeys.push(...keys);
+                } while (cursor !== '0');
+                if (allKeys.length === 0) {
                     this.logger.debug(`No locks found matching pattern: ${searchPattern}`);
                     return 0;
                 }
-                const result = yield redis.del(...keys);
-                this.logger.log(`Cleaned up ${result} lock(s) matching pattern: ${searchPattern}`);
-                return result;
+                // Delete keys in batches to avoid blocking Redis
+                let deletedCount = 0;
+                const batchSize = 100;
+                for (let i = 0; i < allKeys.length; i += batchSize) {
+                    const batch = allKeys.slice(i, i + batchSize);
+                    const result = yield redis.del(...batch);
+                    deletedCount += result;
+                }
+                this.logger.log(`Cleaned up ${deletedCount} lock(s) matching pattern: ${searchPattern}`);
+                return deletedCount;
             }
             catch (error) {
                 this.logger.error(`Error cleaning up locks by pattern ${searchPattern}: ${error.message}`, error.stack);
@@ -546,6 +622,8 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
      * Get all active locks with optional pattern filtering
      * Useful for monitoring and debugging
      *
+     * **Note**: Uses SCAN command to avoid blocking Redis in production.
+     *
      * @param pattern - Optional pattern to filter locks (e.g., 'MyService:*')
      * @param keyPrefix - Key prefix (default: 'lock')
      * @returns Array of active lock information
@@ -555,11 +633,18 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             const redis = yield this.getRedis();
             const searchPattern = `${keyPrefix}:${pattern}`;
             try {
-                const keys = yield redis.keys(searchPattern);
-                if (keys.length === 0) {
+                let cursor = '0';
+                const allKeys = [];
+                // Use SCAN to iterate through keys without blocking Redis
+                do {
+                    const [nextCursor, keys] = yield redis.scan(cursor, 'MATCH', searchPattern, 'COUNT', 100);
+                    cursor = nextCursor;
+                    allKeys.push(...keys);
+                } while (cursor !== '0');
+                if (allKeys.length === 0) {
                     return [];
                 }
-                const locks = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
+                const locks = yield Promise.all(allKeys.map((key) => __awaiter(this, void 0, void 0, function* () {
                     const [value, ttl] = yield Promise.all([
                         redis.get(key),
                         redis.pttl(key),
@@ -596,11 +681,33 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
     }
     /**
      * Generate a unique lock value
+     * Format: instanceId:timestamp:random:pid
      *
      * @returns Unique lock identifier
      */
     generateLockValue() {
-        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}-${process.pid}`;
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 15);
+        const pid = process.pid;
+        return `${this.instanceId}:${timestamp}:${random}:${pid}`;
+    }
+    /**
+     * Get instance identifier
+     * Used to distinguish different process instances in distributed environments
+     *
+     * @returns Instance identifier
+     */
+    getInstanceId() {
+        // 1. Kubernetes Pod name
+        if (process.env.HOSTNAME) {
+            return process.env.HOSTNAME;
+        }
+        // 2. Custom instance ID
+        if (process.env.INSTANCE_ID) {
+            return process.env.INSTANCE_ID;
+        }
+        // 3. Generate unique ID
+        return `instance-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     }
     /**
      * Build the full Redis key for a lock

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>>>;
+export declare function bootstrapSetup(AppModule: any, SetupSwagger: any): Promise<NestExpressApplication<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node: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");
@@ -163,7 +164,7 @@ function bootstrapSetup(AppModule, SetupSwagger) {
         }).use, (0, __1.RequestIdMiddleware)(), (0, __1.PowerByMiddleware)(), (0, __1.OmniAuthMiddleware)(), compression());
         // 全局过滤器
         const reflector = app.get(core_1.Reflector);
-        app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(), new __1.QueryFailedFilter(reflector));
+        app.useGlobalFilters(new setup_1.SentryGlobalFilter(), new __1.HttpExceptionFilter(logger), new __1.QueryFailedFilter(reflector));
         // 全局拦截器
         app.useGlobalInterceptors(new __1.LanguageInterceptor(), new __1.TranslationInterceptor(), new nestjs_pino_1.LoggerErrorInterceptor());
         // 全局管道
@@ -172,7 +173,7 @@ function bootstrapSetup(AppModule, SetupSwagger) {
             errorHttpStatusCode: common_1.HttpStatus.UNPROCESSABLE_ENTITY,
             transform: true,
             stopAtFirstError: true,
-            validationError: { target: false, value: false },
+            validationError: { target: true, value: true },
         }));
         // 可选功能模块 - 仅在 HTTP 或 Hybrid 模式下启用
         if (shouldStartHttp) {

package/setup/index.d.ts

@@ -2,3 +2,4 @@ export * from './bootstrap.setup';
 export * from './mode.setup';
 export * from './worker.decorator';
 export * from './schedule.decorator';
+export * from './run-in-mode.decorator';

package/setup/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./bootstrap.setup"), exports);
 __exportStar(require("./mode.setup"), exports);
 __exportStar(require("./worker.decorator"), exports);
 __exportStar(require("./schedule.decorator"), exports);
+__exportStar(require("./run-in-mode.decorator"), exports);

package/setup/run-in-mode.decorator.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Mode-Aware Method Decorators
+ *
+ * Conditional method execution based on application mode:
+ * - HTTP: Only HTTP server (no workers/schedulers)
+ * - WORKER: Only background workers and schedulers (no HTTP server)
+ * - HYBRID: Both HTTP server and workers (default)
+ */
+/**
+ * Method only executes in HTTP mode (skipped in WORKER and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInHttp()
+ * async handleApiRequest() {
+ *   // Only runs when APP_MODE=http
+ * }
+ * ```
+ */
+export declare function RunOnlyInHttp(): MethodDecorator;
+/**
+ * Method only executes in WORKER mode (skipped in HTTP and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInWorker()
+ * async processBackgroundJob() {
+ *   // Only runs when APP_MODE=worker
+ * }
+ * ```
+ */
+export declare function RunOnlyInWorker(): MethodDecorator;
+/**
+ * Method executes in HTTP or HYBRID mode (skipped in WORKER-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInHttpOrHybrid()
+ * async handleWebRequest() {
+ *   // Runs in HTTP or HYBRID mode
+ * }
+ * ```
+ */
+export declare function RunInHttpOrHybrid(): MethodDecorator;
+/**
+ * Method executes in WORKER or HYBRID mode (skipped in HTTP-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInWorkerOrHybrid()
+ * async processScheduledTask() {
+ *   // Runs in WORKER or HYBRID mode
+ * }
+ * ```
+ */
+export declare function RunInWorkerOrHybrid(): MethodDecorator;

package/setup/run-in-mode.decorator.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Mode-Aware Method Decorators
+ *
+ * Conditional method execution based on application mode:
+ * - HTTP: Only HTTP server (no workers/schedulers)
+ * - WORKER: Only background workers and schedulers (no HTTP server)
+ * - HYBRID: Both HTTP server and workers (default)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunOnlyInHttp = RunOnlyInHttp;
+exports.RunOnlyInWorker = RunOnlyInWorker;
+exports.RunInHttpOrHybrid = RunInHttpOrHybrid;
+exports.RunInWorkerOrHybrid = RunInWorkerOrHybrid;
+const common_1 = require("@nestjs/common");
+const mode_setup_1 = require("./mode.setup");
+/**
+ * Create mode-restricted decorator
+ */
+function createModeDecorator(allowedModes) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const logger = new common_1.Logger(`${className}.${methodName}`);
+        descriptor.value = function (...args) {
+            const currentMode = (0, mode_setup_1.getApplicationMode)();
+            if (!allowedModes.includes(currentMode)) {
+                logger.log(`Skipped (current: ${currentMode}, allowed: ${allowedModes.join(', ')})`);
+                return undefined;
+            }
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+/**
+ * Method only executes in HTTP mode (skipped in WORKER and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInHttp()
+ * async handleApiRequest() {
+ *   // Only runs when APP_MODE=http
+ * }
+ * ```
+ */
+function RunOnlyInHttp() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.HTTP]);
+}
+/**
+ * Method only executes in WORKER mode (skipped in HTTP and HYBRID)
+ *
+ * @example
+ * ```typescript
+ * @RunOnlyInWorker()
+ * async processBackgroundJob() {
+ *   // Only runs when APP_MODE=worker
+ * }
+ * ```
+ */
+function RunOnlyInWorker() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.WORKER]);
+}
+/**
+ * Method executes in HTTP or HYBRID mode (skipped in WORKER-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInHttpOrHybrid()
+ * async handleWebRequest() {
+ *   // Runs in HTTP or HYBRID mode
+ * }
+ * ```
+ */
+function RunInHttpOrHybrid() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.HTTP, mode_setup_1.ApplicationMode.HYBRID]);
+}
+/**
+ * Method executes in WORKER or HYBRID mode (skipped in HTTP-only mode)
+ *
+ * @example
+ * ```typescript
+ * @RunInWorkerOrHybrid()
+ * async processScheduledTask() {
+ *   // Runs in WORKER or HYBRID mode
+ * }
+ * ```
+ */
+function RunInWorkerOrHybrid() {
+    return createModeDecorator([mode_setup_1.ApplicationMode.WORKER, mode_setup_1.ApplicationMode.HYBRID]);
+}

package/setup/schedule.decorator.d.ts

@@ -123,6 +123,7 @@ export declare function WorkerTimeout(timeout: number, name?: string): MethodDec
  * @param lockKeyOrOptions - Lock key (string) or options object
  * @param lockTtl - Lock TTL in milliseconds (only if lockKeyOrOptions is a string)
  *
+ * @param cronOptions
  * @example
  * ```typescript
  * // Using string lock key

package/setup/schedule.decorator.js

@@ -31,7 +31,7 @@ exports.WorkerCronAdvanced = WorkerCronAdvanced;
 const common_1 = require("@nestjs/common");
 const schedule_1 = require("@nestjs/schedule");
 const mode_setup_1 = require("./mode.setup");
-const redis_lock_service_1 = require("../redis-lock/redis-lock.service");
+const redis_lock_1 = require("../redis-lock");
 /**
  * Generate a lock key from class name and method name
  */
@@ -73,10 +73,14 @@ function executeWithRetry(fn, options) {
 function createWorkerDecorator(baseDecorator, decoratorName) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const logger = new common_1.Logger(`${className}.${methodName}`);
         descriptor.value = function (...args) {
             return __awaiter(this, void 0, void 0, function* () {
                 // Only execute in worker or hybrid mode
                 if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    logger.log('Skipped (scheduled tasks require WORKER or HYBRID mode)');
                     return;
                 }
                 return originalMethod.apply(this, args);
@@ -102,12 +106,23 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
             return __awaiter(this, void 0, void 0, function* () {
                 // Only execute in worker or hybrid mode
                 if (!(0, mode_setup_1.shouldProcessQueues)()) {
+                    logger.log('Skipped (scheduled tasks require WORKER or HYBRID mode)');
                     return;
                 }
                 // Get or create global instance - auto-configures from environment variables
-                const lockService = redis_lock_service_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 lockService = redis_lock_1.RedisLockService.getOrCreateGlobalInstance();
+                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 +132,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 +148,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,
@@ -164,9 +179,8 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 }
                 catch (error) {
                     const duration = Date.now() - startTime;
-                    if (logExecution) {
-                        logger.error(`Task failed after ${duration}ms: ${error.message}`, error.stack);
-                    }
+                    // Always log errors regardless of logExecution setting
+                    logger.error(`Task failed after ${duration}ms: ${error.message}`, error.stack);
                     // Call error callback with proper this context
                     if (onError) {
                         yield onError.call(this, error);
@@ -251,6 +265,7 @@ function WorkerTimeout(timeout, name) {
  * @param lockKeyOrOptions - Lock key (string) or options object
  * @param lockTtl - Lock TTL in milliseconds (only if lockKeyOrOptions is a string)
  *
+ * @param cronOptions
  * @example
  * ```typescript
  * // Using string lock key
@@ -309,11 +324,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 +421,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/setup/worker.decorator.js

@@ -20,6 +20,7 @@ exports.WorkerOnQueueCleaned = WorkerOnQueueCleaned;
 exports.WorkerOnQueueDrained = WorkerOnQueueDrained;
 exports.WorkerOnQueuePaused = WorkerOnQueuePaused;
 exports.WorkerOnQueueResumed = WorkerOnQueueResumed;
+const common_1 = require("@nestjs/common");
 const bull_1 = require("@nestjs/bull");
 const mode_setup_1 = require("./mode.setup");
 /**
@@ -67,8 +68,16 @@ function WorkerProcess(name) {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.Process)(name);
     }
-    // In HTTP-only mode, return a no-op decorator
+    // In HTTP-only mode, return a decorator that logs and skips
     return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const logger = new common_1.Logger(`${className}.${methodName}`);
+        descriptor.value = function (...args) {
+            logger.log('Skipped (queue processors require WORKER or HYBRID mode)');
+            return undefined;
+        };
         return 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);