@nest-omni/core 2.0.1-8 → 3.1.1-10

package/setup/mode.setup.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationMode = void 0;
+exports.getApplicationMode = getApplicationMode;
+exports.shouldProcessQueues = shouldProcessQueues;
+exports.shouldStartHttpServer = shouldStartHttpServer;
+exports.isHttpMode = isHttpMode;
+exports.isWorkerMode = isWorkerMode;
+exports.isHybridMode = isHybridMode;
+exports.getModeDescription = getModeDescription;
+var ApplicationMode;
+(function (ApplicationMode) {
+    ApplicationMode["HTTP"] = "http";
+    ApplicationMode["WORKER"] = "worker";
+    ApplicationMode["HYBRID"] = "hybrid";
+})(ApplicationMode || (exports.ApplicationMode = ApplicationMode = {}));
+function getApplicationMode() {
+    const mode = (process.env.APP_MODE || process.env.MODE || 'hybrid')
+        .toLowerCase()
+        .trim();
+    switch (mode) {
+        case 'http':
+            return ApplicationMode.HTTP;
+        case 'worker':
+            return ApplicationMode.WORKER;
+        case 'hybrid':
+        default:
+            return ApplicationMode.HYBRID;
+    }
+}
+function shouldProcessQueues() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.WORKER || mode === ApplicationMode.HYBRID;
+}
+function shouldStartHttpServer() {
+    const mode = getApplicationMode();
+    return mode === ApplicationMode.HTTP || mode === ApplicationMode.HYBRID;
+}
+function isHttpMode() {
+    return getApplicationMode() === ApplicationMode.HTTP;
+}
+function isWorkerMode() {
+    return getApplicationMode() === ApplicationMode.WORKER;
+}
+function isHybridMode() {
+    return getApplicationMode() === ApplicationMode.HYBRID;
+}
+function getModeDescription() {
+    const mode = getApplicationMode();
+    switch (mode) {
+        case ApplicationMode.HTTP:
+            return 'HTTP-only mode (no background workers)';
+        case ApplicationMode.WORKER:
+            return 'Worker-only mode (no HTTP server)';
+        case ApplicationMode.HYBRID:
+            return 'Hybrid mode (HTTP server + background workers)';
+        default:
+            return 'Unknown mode';
+    }
+}

package/setup/redis.lock.decorator.d.ts

@@ -0,0 +1,5 @@
+import type { LockOptions } from './redis.lock.service';
+export declare function UseRedisLock(lockKey: string, options?: LockOptions & {
+    skipReturnValue?: any;
+}): MethodDecorator;
+export declare function UseRedisLockOrSkip(lockKey: string, ttl?: number): MethodDecorator;

package/setup/redis.lock.decorator.js

@@ -0,0 +1,60 @@
+"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.UseRedisLock = UseRedisLock;
+exports.UseRedisLockOrSkip = UseRedisLockOrSkip;
+const common_1 = require("@nestjs/common");
+function UseRedisLock(lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = new common_1.Logger(`RedisLock:${String(propertyKey)}`);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const { RedisLockService } = yield Promise.resolve().then(() => require('./redis.lock.service'));
+                const lockService = RedisLockService.getGlobalInstance();
+                if (!lockService) {
+                    logger.error(`RedisLockService global instance not found. ` +
+                        `Please ensure RedisLockService is registered in your application module.`);
+                    throw new Error(`RedisLockService not initialized. Please register it in your module.`);
+                }
+                const skipReturnValue = (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
+                const lockResult = yield lockService.acquireLock(lockKey, options);
+                if (!lockResult.acquired) {
+                    logger.log(`Lock '${lockKey}' is already held, skipping execution of ${String(propertyKey)}`);
+                    return skipReturnValue;
+                }
+                logger.debug(`Lock '${lockKey}' acquired, executing ${String(propertyKey)}`);
+                try {
+                    return yield originalMethod.apply(this, args);
+                }
+                catch (error) {
+                    logger.error(`Error executing ${String(propertyKey)} with lock '${lockKey}':`, error);
+                    throw error;
+                }
+                finally {
+                    if (lockResult.autoExtendTimer) {
+                        clearInterval(lockResult.autoExtendTimer);
+                    }
+                    yield lockService.releaseLock(lockKey, lockResult.lockValue, options.keyPrefix);
+                    logger.debug(`Lock '${lockKey}' released`);
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function UseRedisLockOrSkip(lockKey, ttl = 300000) {
+    return UseRedisLock(lockKey, {
+        ttl,
+        skipReturnValue: false,
+    });
+}

package/setup/redis.lock.service.d.ts

@@ -0,0 +1,56 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+export interface LockOptions {
+    ttl?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    keyPrefix?: string;
+    throwOnFailure?: boolean;
+    autoExtend?: number;
+}
+export interface LockResult {
+    acquired: boolean;
+    lockValue?: string;
+    error?: string;
+    autoExtendTimer?: NodeJS.Timeout;
+}
+export interface RedisOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    retryDelay?: number;
+    maxRetries?: number;
+    reconnectOnError?: (err: Error) => boolean;
+}
+export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
+    private static globalInstance;
+    private readonly logger;
+    private redis;
+    private redisOptions;
+    private isConnected;
+    private isConnecting;
+    private connectionPromise;
+    private readonly defaultOptions;
+    private readonly defaultRedisOptions;
+    constructor(redisOptions?: RedisOptions);
+    static getGlobalInstance(): RedisLockService | null;
+    static setGlobalInstance(instance: RedisLockService): void;
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    acquireLock(key: string, options?: LockOptions): Promise<LockResult>;
+    releaseLock(key: string, lockValue: string, keyPrefix?: string): Promise<boolean>;
+    extendLock(key: string, lockValue: string, ttl: number, keyPrefix?: string): Promise<boolean>;
+    isLocked(key: string, keyPrefix?: string): Promise<boolean>;
+    withLock<T>(key: string, fn: () => Promise<T>, options?: LockOptions): Promise<T | null>;
+    getLockInfo(key: string, keyPrefix?: string): Promise<{
+        value: string | null;
+        ttl: number | null;
+    }>;
+    forceRelease(key: string, keyPrefix?: string): Promise<boolean>;
+    getRedisOptions(): RedisOptions;
+    private getRedis;
+    private createRedisConnection;
+    private generateLockValue;
+    private buildLockKey;
+    private sleep;
+}

package/setup/redis.lock.service.js

@@ -0,0 +1,338 @@
+"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 __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 RedisLockService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockService = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = require("ioredis");
+let RedisLockService = RedisLockService_1 = class RedisLockService {
+    constructor(redisOptions) {
+        this.logger = new common_1.Logger(RedisLockService_1.name);
+        this.redis = null;
+        this.isConnected = false;
+        this.isConnecting = false;
+        this.connectionPromise = null;
+        this.defaultOptions = {
+            ttl: 300000,
+            retryCount: 0,
+            retryDelay: 100,
+            keyPrefix: 'lock',
+            throwOnFailure: false,
+            autoExtend: 0,
+        };
+        this.defaultRedisOptions = {
+            host: process.env.REDIS_HOST || 'localhost',
+            port: parseInt(process.env.REDIS_PORT || '6379', 10),
+            password: process.env.REDIS_PASSWORD,
+            db: parseInt(process.env.REDIS_DB || '0', 10),
+            retryDelay: 2000,
+            maxRetries: 10,
+            reconnectOnError: (err) => {
+                this.logger.warn('Redis reconnection error:', err.message);
+                return true;
+            },
+        };
+        this.redisOptions = Object.assign(Object.assign({}, this.defaultRedisOptions), redisOptions);
+        if (!RedisLockService_1.globalInstance) {
+            RedisLockService_1.globalInstance = this;
+        }
+    }
+    static getGlobalInstance() {
+        return RedisLockService_1.globalInstance;
+    }
+    static setGlobalInstance(instance) {
+        RedisLockService_1.globalInstance = instance;
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('RedisLockService initialized, will connect on first use');
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redis) {
+                yield this.redis.quit();
+                this.isConnected = false;
+                this.logger.log('Redis connection closed');
+            }
+        });
+    }
+    acquireLock(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, options = {}) {
+            const redis = yield this.getRedis();
+            const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
+            const lockKey = this.buildLockKey(key, opts.keyPrefix);
+            const lockValue = this.generateLockValue();
+            let attempts = 0;
+            const maxAttempts = opts.retryCount + 1;
+            while (attempts < maxAttempts) {
+                try {
+                    const result = yield redis.set(lockKey, lockValue, 'PX', opts.ttl, 'NX');
+                    if (result === 'OK') {
+                        this.logger.debug(`Lock acquired: ${lockKey} (value: ${lockValue}, ttl: ${opts.ttl}ms)`);
+                        let autoExtendTimer;
+                        if (opts.autoExtend && opts.autoExtend > 0) {
+                            autoExtendTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                                try {
+                                    yield this.extendLock(key, lockValue, opts.ttl, opts.keyPrefix);
+                                }
+                                catch (error) {
+                                    this.logger.error(`Failed to auto-extend lock ${lockKey}:`, error);
+                                }
+                            }), opts.autoExtend);
+                        }
+                        return { acquired: true, lockValue, autoExtendTimer };
+                    }
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        this.logger.debug(`Lock acquisition failed for ${lockKey}, retrying... (${attempts}/${opts.retryCount})`);
+                        yield this.sleep(opts.retryDelay);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                    this.logger.error(errorMessage, error.stack);
+                    if (opts.throwOnFailure) {
+                        throw new Error(errorMessage);
+                    }
+                    return { acquired: false, error: errorMessage };
+                }
+            }
+            const failureMessage = `Failed to acquire lock for ${lockKey} after ${attempts} attempts`;
+            this.logger.warn(failureMessage);
+            if (opts.throwOnFailure) {
+                throw new Error(failureMessage);
+            }
+            return { acquired: false, error: failureMessage };
+        });
+    }
+    releaseLock(key_1, lockValue_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+                const result = yield redis.eval(script, 1, lockKey, lockValue);
+                if (result === 1) {
+                    this.logger.debug(`Lock released: ${lockKey}`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock release failed: ${lockKey} (lock value mismatch or already expired)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error releasing lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    extendLock(key_1, lockValue_1, ttl_1) {
+        return __awaiter(this, arguments, void 0, function* (key, lockValue, ttl, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("pexpire", KEYS[1], ARGV[2])
+        else
+          return 0
+        end
+      `;
+                const result = yield redis.eval(script, 1, lockKey, lockValue, ttl);
+                if (result === 1) {
+                    this.logger.debug(`Lock extended: ${lockKey} (new ttl: ${ttl}ms)`);
+                    return true;
+                }
+                else {
+                    this.logger.warn(`Lock extension failed: ${lockKey} (lock value mismatch or doesn't exist)`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error extending lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    isLocked(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const exists = yield redis.exists(lockKey);
+                return exists === 1;
+            }
+            catch (error) {
+                this.logger.error(`Error checking lock existence for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    withLock(key_1, fn_1) {
+        return __awaiter(this, arguments, void 0, function* (key, fn, options = {}) {
+            const lockResult = yield this.acquireLock(key, options);
+            if (!lockResult.acquired) {
+                this.logger.warn(`Could not acquire lock for ${key}, skipping execution`);
+                return null;
+            }
+            try {
+                return yield fn();
+            }
+            catch (error) {
+                this.logger.error(`Error executing function with lock ${key}:`, error);
+                throw error;
+            }
+            finally {
+                if (lockResult.autoExtendTimer) {
+                    clearInterval(lockResult.autoExtendTimer);
+                }
+                yield this.releaseLock(key, lockResult.lockValue, options.keyPrefix);
+            }
+        });
+    }
+    getLockInfo(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const [value, ttl] = yield Promise.all([
+                    redis.get(lockKey),
+                    redis.pttl(lockKey),
+                ]);
+                return {
+                    value,
+                    ttl: ttl >= 0 ? ttl : null,
+                };
+            }
+            catch (error) {
+                this.logger.error(`Error getting lock info for ${lockKey}: ${error.message}`, error.stack);
+                return { value: null, ttl: null };
+            }
+        });
+    }
+    forceRelease(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const lockKey = this.buildLockKey(key, keyPrefix);
+            try {
+                const result = yield redis.del(lockKey);
+                if (result === 1) {
+                    this.logger.debug(`Lock forcefully released: ${lockKey}`);
+                    return true;
+                }
+                else {
+                    this.logger.debug(`No lock found to forcefully release: ${lockKey}`);
+                    return false;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error force releasing lock for ${lockKey}: ${error.message}`, error.stack);
+                return false;
+            }
+        });
+    }
+    getRedisOptions() {
+        return Object.assign({}, this.redisOptions);
+    }
+    getRedis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redis && this.isConnected) {
+                return this.redis;
+            }
+            if (this.isConnecting && this.connectionPromise) {
+                return this.connectionPromise;
+            }
+            this.isConnecting = true;
+            this.connectionPromise = this.createRedisConnection()
+                .then((redis) => {
+                this.isConnecting = false;
+                this.isConnected = true;
+                return redis;
+            })
+                .catch((error) => {
+                this.isConnecting = false;
+                this.connectionPromise = null;
+                throw error;
+            });
+            return this.connectionPromise;
+        });
+    }
+    createRedisConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const redis = new ioredis_1.default({
+                    host: this.redisOptions.host,
+                    port: this.redisOptions.port,
+                    password: this.redisOptions.password,
+                    db: this.redisOptions.db,
+                    retryStrategy: (times) => {
+                        this.logger.warn(`Redis connection retry attempt ${times}`);
+                        if (times > (this.redisOptions.maxRetries || 10)) {
+                            this.logger.error('Max retries reached, giving up on Redis connection');
+                            this.isConnected = false;
+                            return undefined;
+                        }
+                        const delay = Math.min(times * (this.redisOptions.retryDelay || 2000), 30000);
+                        this.logger.log(`Retrying Redis connection in ${delay}ms`);
+                        return delay;
+                    },
+                    reconnectOnError: this.redisOptions.reconnectOnError,
+                });
+                const onConnect = () => {
+                    this.logger.log(`Connected to Redis at ${this.redisOptions.host}:${this.redisOptions.port}`);
+                    this.isConnected = true;
+                    resolve(redis);
+                };
+                const onError = (err) => {
+                    this.logger.error('Redis connection error:', err.message);
+                    if (!this.isConnected) {
+                        reject(err);
+                    }
+                };
+                redis.once('connect', onConnect);
+                redis.once('error', onError);
+                this.redis = redis;
+            });
+        });
+    }
+    generateLockValue() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}-${process.pid}`;
+    }
+    buildLockKey(key, prefix = 'lock') {
+        return `${prefix}:${key}`;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+};
+exports.RedisLockService = RedisLockService;
+RedisLockService.globalInstance = null;
+exports.RedisLockService = RedisLockService = RedisLockService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], RedisLockService);

package/setup/schedule.decorator.d.ts

@@ -0,0 +1,21 @@
+import type { CronOptions } from '@nestjs/schedule';
+export declare function WorkerCron(cronTime: string | Date, options?: CronOptions): MethodDecorator;
+export declare function WorkerInterval(timeout: number, options?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerTimeout(timeout: number, options?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerCronWithLock(cronTime: string | Date, lockKey: string, lockTtl?: number, cronOptions?: CronOptions): MethodDecorator;
+export declare function WorkerIntervalWithLock(timeout: number, lockKey: string, lockTtl?: number, intervalOptions?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerTimeoutWithLock(timeout: number, lockKey: string, lockTtl?: number, timeoutOptions?: {
+    name?: string;
+}): MethodDecorator;
+export declare function WorkerCronAdvanced(cronTime: string | Date, lockKey: string, options?: {
+    lockTtl?: number;
+    cronOptions?: CronOptions;
+    logExecution?: boolean;
+    onError?: (error: Error) => void;
+}): MethodDecorator;

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;
+    };
+}