@nest-omni/core 4.1.3-2 → 4.1.3-20

package/setup/schedule.decorator.js

@@ -1,4 +1,14 @@
 "use strict";
+/**
+ * Enhanced Schedule Decorators for Worker Mode
+ *
+ * This module provides decorators for scheduled tasks that:
+ * - Only run in Worker or Hybrid mode (not in HTTP-only mode)
+ * - Support distributed locking via Redis
+ * - Support retry logic for failed tasks
+ * - Provide automatic lock key generation
+ * - Support task execution logging and error handling
+ */
 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) {
@@ -21,10 +31,16 @@ 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
+ */
 function generateLockKey(className, methodName) {
     return `${className}.${methodName}`;
 }
+/**
+ * Execute a function with retry logic
+ */
 function executeWithRetry(fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const { retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logger, taskName, } = options;
@@ -51,43 +67,72 @@ function executeWithRetry(fn, options) {
         throw lastError;
     });
 }
+/**
+ * Base decorator creator for worker-mode tasks
+ */
 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);
             });
         };
+        // Apply the base decorator
         baseDecorator(target, propertyKey, descriptor);
         return descriptor;
     };
 }
+/**
+ * Create a worker decorator with lock support
+ */
 function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, options = {}) {
     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}`);
+        // Resolve lock key
         const resolvedLockKey = typeof lockKey === 'function' ? lockKey() : lockKey;
         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;
                 }
-                const lockService = redis_lock_service_1.RedisLockService.getOrCreateGlobalInstance();
-                const { lockTtl = 3600000, retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                // Get or create global instance - auto-configures from environment variables
+                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
                 if (logExecution) {
                     logger.log(`Task starting...`);
                 }
                 try {
+                    // Acquire lock
                     const lockResult = yield lockService.acquireLock(resolvedLockKey, {
-                        ttl: lockTtl,
+                        ttl: validatedLockTtl,
                         keyPrefix: lockKeyPrefix,
                         autoExtend: autoExtendLock,
                     });
@@ -101,9 +146,10 @@ 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,
@@ -113,15 +159,18 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                         if (logExecution) {
                             logger.log(`Task completed successfully in ${duration}ms`);
                         }
+                        // Call success callback with proper this context
                         if (onSuccess) {
                             yield onSuccess.call(this, duration);
                         }
                         return result;
                     }
                     finally {
+                        // Clear auto-extension timer if it exists
                         if (lockResult.autoExtendTimer) {
                             clearInterval(lockResult.autoExtendTimer);
                         }
+                        // Always release the lock
                         yield lockService.releaseLock(resolvedLockKey, lockResult.lockValue, lockKeyPrefix);
                         if (logExecution) {
                             logger.debug(`Lock "${fullLockKey}" released`);
@@ -130,9 +179,9 @@ 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);
                     }
@@ -140,25 +189,98 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 }
             });
         };
+        // Apply the base decorator
         baseDecorator(target, propertyKey, descriptor);
         return descriptor;
     };
 }
+// ============================================================================
+// Basic Worker Decorators (without lock)
+// ============================================================================
+/**
+ * Cron decorator that only executes in Worker or Hybrid mode
+ *
+ * @param cronTime - Cron expression
+ * @param options - Cron options
+ *
+ * @example
+ * ```typescript
+ * @WorkerCron('0 0 * * *') // Run daily at midnight
+ * async dailyTask() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerCron(cronTime, options) {
     return createWorkerDecorator((0, schedule_1.Cron)(cronTime, options), 'WorkerCron');
 }
+/**
+ * Interval decorator that only executes in Worker or Hybrid mode
+ *
+ * @param timeout - Interval in milliseconds
+ * @param name - Optional name for the interval
+ *
+ * @example
+ * ```typescript
+ * @WorkerInterval(60000) // Run every minute
+ * async minutelyTask() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerInterval(timeout, name) {
     if (name) {
         return createWorkerDecorator((0, schedule_1.Interval)(name, timeout), 'WorkerInterval');
     }
     return createWorkerDecorator((0, schedule_1.Interval)(timeout), 'WorkerInterval');
 }
+/**
+ * Timeout decorator that only executes in Worker or Hybrid mode
+ *
+ * @param timeout - Timeout in milliseconds
+ * @param name - Optional name for the timeout
+ *
+ * @example
+ * ```typescript
+ * @WorkerTimeout(5000) // Run once after 5 seconds
+ * async startupTask() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerTimeout(timeout, name) {
     if (name) {
         return createWorkerDecorator((0, schedule_1.Timeout)(name, timeout), 'WorkerTimeout');
     }
     return createWorkerDecorator((0, schedule_1.Timeout)(timeout), 'WorkerTimeout');
 }
+// ============================================================================
+// Worker Decorators with Lock Support
+// ============================================================================
+/**
+ * Cron decorator with distributed lock support
+ * Automatically generates lock key from class and method name
+ *
+ * @param cronTime - Cron expression
+ * @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
+ * @WorkerCronWithLock('0 * * * *', 'hourly-task', 3600000)
+ * async hourlyTask() {
+ *   // Task logic
+ * }
+ *
+ * // Using options object (auto-generates lock key)
+ * @WorkerCronWithLock('0 * * * *', { lockTtl: 3600000, retryCount: 3 })
+ * async hourlyTask() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerCronWithLock(cronTime, lockKeyOrOptions, lockTtl, cronOptions) {
     return function (target, propertyKey, descriptor) {
         let lockKey;
@@ -174,21 +296,65 @@ function WorkerCronWithLock(cronTime, lockKeyOrOptions, lockTtl, cronOptions) {
         return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronWithLock', lockKey, options)(target, propertyKey, descriptor);
     };
 }
+/**
+ * Interval decorator with distributed lock support
+ *
+ * @param timeout - Interval in milliseconds
+ * @param lockKeyOrOptions - Lock key (string) or options object
+ * @param lockTtl - Lock TTL in milliseconds (only if lockKeyOrOptions is a string)
+ *
+ * @example
+ * ```typescript
+ * // Using string lock key
+ * @WorkerIntervalWithLock(60000, 'status-check', 50000)
+ * async checkStatus() {
+ *   // Task logic
+ * }
+ *
+ * // Using options object (auto-generates lock key)
+ * @WorkerIntervalWithLock(60000, { retryCount: 2 })
+ * async checkStatus() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerIntervalWithLock(timeout, lockKeyOrOptions, lockTtl) {
     return function (target, propertyKey, descriptor) {
         let lockKey;
         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);
     };
 }
+/**
+ * Timeout decorator with distributed lock support
+ *
+ * @param timeout - Timeout in milliseconds
+ * @param lockKeyOrOptions - Lock key (string) or options object
+ * @param lockTtl - Lock TTL in milliseconds (only if lockKeyOrOptions is a string)
+ *
+ * @example
+ * ```typescript
+ * // Using string lock key
+ * @WorkerTimeoutWithLock(5000, 'init-task', 10000)
+ * async initializeSystem() {
+ *   // Task logic
+ * }
+ *
+ * // Using options object (auto-generates lock key)
+ * @WorkerTimeoutWithLock(5000, { lockTtl: 10000 })
+ * async initializeSystem() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerTimeoutWithLock(timeout, lockKeyOrOptions, lockTtl) {
     return function (target, propertyKey, descriptor) {
         let lockKey;
@@ -204,18 +370,80 @@ function WorkerTimeoutWithLock(timeout, lockKeyOrOptions, lockTtl) {
         return createWorkerDecoratorWithLock((0, schedule_1.Timeout)(timeout), 'WorkerTimeoutWithLock', lockKey, options)(target, propertyKey, descriptor);
     };
 }
+// ============================================================================
+// Smart Decorators (Recommended)
+// ============================================================================
+/**
+ * Smart Cron decorator with auto-generated lock key and intelligent defaults
+ * Recommended for most use cases
+ *
+ * @param cronTime - Cron expression
+ * @param options - Schedule options
+ *
+ * @example
+ * ```typescript
+ * @WorkerCronSmart('0 * * * *') // Run hourly with auto-generated lock key
+ * async hourlyTask() {
+ *   // Task logic
+ * }
+ *
+ * @WorkerCronSmart('0 0 * * *', {
+ *   lockTtl: 7200000, // 2 hours
+ *   retryCount: 3,
+ *   onError: (error) => console.error('Task failed:', error),
+ * })
+ * async dailyTask() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerCronSmart(cronTime, options = {}, cronOptions) {
     return function (target, propertyKey, descriptor) {
         const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
         return createWorkerDecoratorWithLock((0, schedule_1.Cron)(cronTime, cronOptions), 'WorkerCronSmart', lockKey, Object.assign({ lockTtl: 3600000, logExecution: true }, options))(target, propertyKey, descriptor);
     };
 }
+/**
+ * Smart Interval decorator with auto-generated lock key and intelligent defaults
+ * Lock TTL is automatically set to 80% of interval duration
+ *
+ * @param timeout - Interval in milliseconds
+ * @param options - Schedule options
+ *
+ * @example
+ * ```typescript
+ * @WorkerIntervalSmart(120000) // Run every 2 minutes, lock for ~1.6 minutes
+ * async checkStatus() {
+ *   // Task logic
+ * }
+ * ```
+ */
 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);
     };
 }
+/**
+ * Advanced Cron decorator with full control
+ * Alias for WorkerCronSmart with explicit lock key parameter
+ *
+ * @param cronTime - Cron expression
+ * @param lockKeyOrOptions - Lock key (string) or options object
+ * @param options - Schedule options (only if lockKeyOrOptions is a string)
+ *
+ * @example
+ * ```typescript
+ * @WorkerCronAdvanced('0 0 * * *', 'daily-report', {
+ *   lockTtl: 7200000,
+ *   retryCount: 5,
+ *   useExponentialBackoff: true,
+ * })
+ * async generateDailyReport() {
+ *   // Task logic
+ * }
+ * ```
+ */
 function WorkerCronAdvanced(cronTime, lockKeyOrOptions, options, cronOptions) {
     return function (target, propertyKey, descriptor) {
         let lockKey;

package/setup/worker.decorator.d.ts

@@ -1,14 +1,100 @@
+/**
+ * Worker Decorators for Bull Queue Processors
+ *
+ * These decorators conditionally apply Bull decorators based on the application mode.
+ * They only register processors when running in Worker or Hybrid mode.
+ */
+/**
+ * Conditionally applies Bull's @Processor decorator
+ * Only registers the processor class when running in Worker or Hybrid mode
+ *
+ * @param queueName - Name of the queue to process
+ * @param options - Processor options (optional)
+ *
+ * @example
+ * ```typescript
+ * @WorkerProcessor('email')
+ * export class EmailProcessor {
+ *   @WorkerProcess('send')
+ *   async sendEmail(job: Job) {
+ *     // Process email sending
+ *   }
+ * }
+ * ```
+ */
 export declare function WorkerProcessor(queueName?: string): ClassDecorator;
+/**
+ * Conditionally applies Bull's @Process decorator
+ * Only registers the processor method when running in Worker or Hybrid mode
+ *
+ * @param name - Job name to process (optional)
+ *
+ * @example
+ * ```typescript
+ * @WorkerProcess('send-email')
+ * async sendEmail(job: Job<EmailData>) {
+ *   // Process job
+ * }
+ * ```
+ */
 export declare function WorkerProcess(name?: string): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueActive decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueActive(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueCompleted decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueCompleted(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueProgress decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueProgress(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueFailed decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueFailed(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueError decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueError(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueWaiting decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueWaiting(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueStalled decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueStalled(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueRemoved decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueRemoved(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueCleaned decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueCleaned(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueDrained decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueDrained(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueuePaused decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueuePaused(): MethodDecorator;
+/**
+ * Conditionally applies Bull's @OnQueueResumed decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 export declare function WorkerOnQueueResumed(): MethodDecorator;

package/setup/worker.decorator.js

@@ -1,4 +1,10 @@
 "use strict";
+/**
+ * Worker Decorators for Bull Queue Processors
+ *
+ * These decorators conditionally apply Bull decorators based on the application mode.
+ * They only register processors when running in Worker or Hybrid mode.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerProcessor = WorkerProcessor;
 exports.WorkerProcess = WorkerProcess;
@@ -14,24 +20,71 @@ 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");
+/**
+ * Conditionally applies Bull's @Processor decorator
+ * Only registers the processor class when running in Worker or Hybrid mode
+ *
+ * @param queueName - Name of the queue to process
+ * @param options - Processor options (optional)
+ *
+ * @example
+ * ```typescript
+ * @WorkerProcessor('email')
+ * export class EmailProcessor {
+ *   @WorkerProcess('send')
+ *   async sendEmail(job: Job) {
+ *     // Process email sending
+ *   }
+ * }
+ * ```
+ */
 function WorkerProcessor(queueName) {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.Processor)(queueName);
     }
+    // In HTTP-only mode, return a no-op decorator
     return function (constructor) {
         return constructor;
     };
 }
+/**
+ * Conditionally applies Bull's @Process decorator
+ * Only registers the processor method when running in Worker or Hybrid mode
+ *
+ * @param name - Job name to process (optional)
+ *
+ * @example
+ * ```typescript
+ * @WorkerProcess('send-email')
+ * async sendEmail(job: Job<EmailData>) {
+ *   // Process job
+ * }
+ * ```
+ */
 function WorkerProcess(name) {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.Process)(name);
     }
+    // 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;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueActive decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueActive() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueActive)();
@@ -40,6 +93,10 @@ function WorkerOnQueueActive() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueCompleted decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueCompleted() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueCompleted)();
@@ -48,6 +105,10 @@ function WorkerOnQueueCompleted() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueProgress decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueProgress() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueProgress)();
@@ -56,6 +117,10 @@ function WorkerOnQueueProgress() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueFailed decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueFailed() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueFailed)();
@@ -64,6 +129,10 @@ function WorkerOnQueueFailed() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueError decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueError() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueError)();
@@ -72,6 +141,10 @@ function WorkerOnQueueError() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueWaiting decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueWaiting() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueWaiting)();
@@ -80,6 +153,10 @@ function WorkerOnQueueWaiting() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueStalled decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueStalled() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueStalled)();
@@ -88,6 +165,10 @@ function WorkerOnQueueStalled() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueRemoved decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueRemoved() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueRemoved)();
@@ -96,6 +177,10 @@ function WorkerOnQueueRemoved() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueCleaned decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueCleaned() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueCleaned)();
@@ -104,6 +189,10 @@ function WorkerOnQueueCleaned() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueDrained decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueDrained() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueDrained)();
@@ -112,6 +201,10 @@ function WorkerOnQueueDrained() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueuePaused decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueuePaused() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueuePaused)();
@@ -120,6 +213,10 @@ function WorkerOnQueuePaused() {
         return descriptor;
     };
 }
+/**
+ * Conditionally applies Bull's @OnQueueResumed decorator
+ * Only registers when running in Worker or Hybrid mode
+ */
 function WorkerOnQueueResumed() {
     if ((0, mode_setup_1.shouldProcessQueues)()) {
         return (0, bull_1.OnQueueResumed)();