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

package/setup/schedule.decorator.js

@@ -0,0 +1,127 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerCron = WorkerCron;
+exports.WorkerInterval = WorkerInterval;
+exports.WorkerTimeout = WorkerTimeout;
+exports.WorkerCronWithLock = WorkerCronWithLock;
+exports.WorkerIntervalWithLock = WorkerIntervalWithLock;
+exports.WorkerTimeoutWithLock = WorkerTimeoutWithLock;
+exports.WorkerCronAdvanced = WorkerCronAdvanced;
+const schedule_1 = require("@nestjs/schedule");
+const mode_setup_1 = require("./mode.setup");
+const redis_lock_decorator_1 = require("./redis.lock.decorator");
+const common_1 = require("@nestjs/common");
+function WorkerCron(cronTime, options) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, schedule_1.Cron)(cronTime, options);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerInterval(timeout, options) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, schedule_1.Interval)((options === null || options === void 0 ? void 0 : options.name) || `interval-${timeout}`, timeout);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerTimeout(timeout, options) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, schedule_1.Timeout)((options === null || options === void 0 ? void 0 : options.name) || `timeout-${timeout}`, timeout);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerCronWithLock(cronTime, lockKey, lockTtl = 300000, cronOptions) {
+    if (!(0, mode_setup_1.shouldProcessQueues)()) {
+        return function (target, propertyKey, descriptor) {
+            return descriptor;
+        };
+    }
+    return function (target, propertyKey, descriptor) {
+        (0, schedule_1.Cron)(cronTime, cronOptions)(target, propertyKey, descriptor);
+        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function WorkerIntervalWithLock(timeout, lockKey, lockTtl, intervalOptions) {
+    if (!(0, mode_setup_1.shouldProcessQueues)()) {
+        return function (target, propertyKey, descriptor) {
+            return descriptor;
+        };
+    }
+    const ttl = lockTtl !== null && lockTtl !== void 0 ? lockTtl : timeout;
+    return function (target, propertyKey, descriptor) {
+        (0, schedule_1.Interval)((intervalOptions === null || intervalOptions === void 0 ? void 0 : intervalOptions.name) || `interval-with-lock-${timeout}`, timeout)(target, propertyKey, descriptor);
+        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, ttl)(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function WorkerTimeoutWithLock(timeout, lockKey, lockTtl = 300000, timeoutOptions) {
+    if (!(0, mode_setup_1.shouldProcessQueues)()) {
+        return function (target, propertyKey, descriptor) {
+            return descriptor;
+        };
+    }
+    return function (target, propertyKey, descriptor) {
+        (0, schedule_1.Timeout)((timeoutOptions === null || timeoutOptions === void 0 ? void 0 : timeoutOptions.name) || `timeout-with-lock-${timeout}`, timeout)(target, propertyKey, descriptor);
+        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}
+function WorkerCronAdvanced(cronTime, lockKey, options = {}) {
+    if (!(0, mode_setup_1.shouldProcessQueues)()) {
+        return function (target, propertyKey, descriptor) {
+            return descriptor;
+        };
+    }
+    const { lockTtl = 300000, cronOptions, logExecution = true, onError } = options;
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = new common_1.Logger(`Scheduler:${String(propertyKey)}`);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const startTime = Date.now();
+                try {
+                    if (logExecution) {
+                        logger.log(`Starting scheduled task: ${String(propertyKey)}`);
+                    }
+                    const result = yield originalMethod.apply(this, args);
+                    if (logExecution) {
+                        const duration = Date.now() - startTime;
+                        logger.log(`Completed scheduled task: ${String(propertyKey)} (${duration}ms)`);
+                    }
+                    return result;
+                }
+                catch (error) {
+                    const duration = Date.now() - startTime;
+                    logger.error(`Error in scheduled task: ${String(propertyKey)} (${duration}ms)`, error.stack);
+                    if (onError) {
+                        try {
+                            onError(error);
+                        }
+                        catch (handlerError) {
+                            logger.error('Error handler threw an error:', handlerError);
+                        }
+                    }
+                    throw error;
+                }
+            });
+        };
+        (0, schedule_1.Cron)(cronTime, cronOptions)(target, propertyKey, descriptor);
+        (0, redis_lock_decorator_1.UseRedisLockOrSkip)(lockKey, lockTtl)(target, propertyKey, descriptor);
+        return descriptor;
+    };
+}

package/setup/worker.decorator.d.ts

@@ -0,0 +1,14 @@
+export declare function WorkerProcessor(queueName?: string): ClassDecorator;
+export declare function WorkerProcess(name?: string): MethodDecorator;
+export declare function WorkerOnQueueActive(): MethodDecorator;
+export declare function WorkerOnQueueCompleted(): MethodDecorator;
+export declare function WorkerOnQueueProgress(): MethodDecorator;
+export declare function WorkerOnQueueFailed(): MethodDecorator;
+export declare function WorkerOnQueueError(): MethodDecorator;
+export declare function WorkerOnQueueWaiting(): MethodDecorator;
+export declare function WorkerOnQueueStalled(): MethodDecorator;
+export declare function WorkerOnQueueRemoved(): MethodDecorator;
+export declare function WorkerOnQueueCleaned(): MethodDecorator;
+export declare function WorkerOnQueueDrained(): MethodDecorator;
+export declare function WorkerOnQueuePaused(): MethodDecorator;
+export declare function WorkerOnQueueResumed(): MethodDecorator;

package/setup/worker.decorator.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerProcessor = WorkerProcessor;
+exports.WorkerProcess = WorkerProcess;
+exports.WorkerOnQueueActive = WorkerOnQueueActive;
+exports.WorkerOnQueueCompleted = WorkerOnQueueCompleted;
+exports.WorkerOnQueueProgress = WorkerOnQueueProgress;
+exports.WorkerOnQueueFailed = WorkerOnQueueFailed;
+exports.WorkerOnQueueError = WorkerOnQueueError;
+exports.WorkerOnQueueWaiting = WorkerOnQueueWaiting;
+exports.WorkerOnQueueStalled = WorkerOnQueueStalled;
+exports.WorkerOnQueueRemoved = WorkerOnQueueRemoved;
+exports.WorkerOnQueueCleaned = WorkerOnQueueCleaned;
+exports.WorkerOnQueueDrained = WorkerOnQueueDrained;
+exports.WorkerOnQueuePaused = WorkerOnQueuePaused;
+exports.WorkerOnQueueResumed = WorkerOnQueueResumed;
+const bull_1 = require("@nestjs/bull");
+const mode_setup_1 = require("./mode.setup");
+function WorkerProcessor(queueName) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Processor)(queueName);
+    }
+    return function (constructor) {
+        return constructor;
+    };
+}
+function WorkerProcess(name) {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.Process)(name);
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueActive() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueActive)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCompleted() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCompleted)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueProgress() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueProgress)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueFailed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueFailed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueError() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueError)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueWaiting() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueWaiting)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueStalled() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueStalled)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueRemoved() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueRemoved)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueCleaned() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueCleaned)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueDrained() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueDrained)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueuePaused() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueuePaused)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}
+function WorkerOnQueueResumed() {
+    if ((0, mode_setup_1.shouldProcessQueues)()) {
+        return (0, bull_1.OnQueueResumed)();
+    }
+    return function (target, propertyKey, descriptor) {
+        return descriptor;
+    };
+}