@nest-omni/core 3.1.1-9 → 3.1.2-0

package/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './context.provider';
+export * from './generator.provider';

package/providers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./context.provider"), exports);
+__exportStar(require("./generator.provider"), exports);

package/redis-lock/examples/lock-strategy.examples.d.ts

@@ -0,0 +1,73 @@
+import { RedisLockService } from '../index';
+export declare class SkipStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    scheduledTask(): Promise<void>;
+    processWithSkip(): Promise<{
+        skipped: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        skipped?: undefined;
+    }>;
+    processWithRetries(): Promise<{
+        skipped: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        skipped?: undefined;
+    }>;
+    private simulateLongRunning;
+}
+export declare class ThrowStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    criticalOperation(): Promise<void>;
+    processWithThrow(): Promise<{
+        success: boolean;
+    }>;
+    processPayment(orderId: string, amount: number): Promise<{
+        success: boolean;
+    }>;
+    private processData;
+    private chargePayment;
+    private updateOrderStatus;
+}
+export declare class WaitStrategyExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    sequentialTask(): Promise<void>;
+    processWithWaitTimeout(): Promise<{
+        timeout: boolean;
+        success?: undefined;
+    } | {
+        success: boolean;
+        timeout?: undefined;
+    }>;
+    processDataSequentially(userId: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    processQueue(queueName: string, item: any): Promise<{
+        success: boolean;
+    }>;
+    runMigration(migrationName: string): Promise<{
+        success: boolean;
+    }>;
+    private processInOrder;
+    private validateData;
+    private saveData;
+    private notifyUser;
+    private processQueueItem;
+    private executeMigration;
+}
+export declare class CombinedStrategiesExample {
+    private readonly lockService;
+    private readonly logger;
+    constructor(lockService: RedisLockService);
+    cleanupOldData(): Promise<void>;
+    processPayment(orderId: string): Promise<void>;
+    generateReport(reportId: string): Promise<void>;
+}

package/redis-lock/examples/lock-strategy.examples.js

@@ -0,0 +1,387 @@
+"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 SkipStrategyExample_1, ThrowStrategyExample_1, WaitStrategyExample_1, CombinedStrategiesExample_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CombinedStrategiesExample = exports.WaitStrategyExample = exports.ThrowStrategyExample = exports.SkipStrategyExample = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const index_1 = require("../index");
+let SkipStrategyExample = SkipStrategyExample_1 = class SkipStrategyExample {
+    constructor(lockService) {
+        this.lockService = lockService;
+        this.logger = new common_1.Logger(SkipStrategyExample_1.name);
+    }
+    scheduledTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Executing scheduled task...');
+            yield this.simulateLongRunning();
+            this.logger.log('Scheduled task completed');
+        });
+    }
+    processWithSkip() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockResult = yield this.lockService.acquireLock('process-task', {
+                strategy: index_1.LockStrategy.SKIP,
+                ttl: 30000,
+            });
+            if (!lockResult.acquired) {
+                this.logger.log('Task is already running, skipping...');
+                return { skipped: true };
+            }
+            try {
+                this.logger.log('Processing task...');
+                yield this.simulateLongRunning();
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock('process-task', lockResult.lockValue);
+            }
+        });
+    }
+    processWithRetries() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockResult = yield this.lockService.acquireLock('retry-task', {
+                strategy: index_1.LockStrategy.SKIP,
+                ttl: 30000,
+                retryCount: 3,
+                retryDelay: 500,
+            });
+            if (!lockResult.acquired) {
+                this.logger.warn('Failed to acquire lock after 3 retries');
+                return { skipped: true };
+            }
+            try {
+                yield this.simulateLongRunning();
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock('retry-task', lockResult.lockValue);
+            }
+        });
+    }
+    simulateLongRunning() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 5000));
+        });
+    }
+};
+exports.SkipStrategyExample = SkipStrategyExample;
+__decorate([
+    (0, schedule_1.Cron)('* * * * *'),
+    (0, index_1.UseRedisLock)('scheduled-task', {
+        ttl: 60000,
+        strategy: index_1.LockStrategy.SKIP,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], SkipStrategyExample.prototype, "scheduledTask", null);
+exports.SkipStrategyExample = SkipStrategyExample = SkipStrategyExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.RedisLockService])
+], SkipStrategyExample);
+let ThrowStrategyExample = ThrowStrategyExample_1 = class ThrowStrategyExample {
+    constructor(lockService) {
+        this.lockService = lockService;
+        this.logger = new common_1.Logger(ThrowStrategyExample_1.name);
+    }
+    criticalOperation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Executing critical operation...');
+            yield this.processData();
+            this.logger.log('Critical operation completed');
+        });
+    }
+    processWithThrow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const lockResult = yield this.lockService.acquireLock('exclusive-task', {
+                    strategy: index_1.LockStrategy.THROW,
+                    ttl: 30000,
+                });
+                try {
+                    this.logger.log('Processing exclusive task...');
+                    yield this.processData();
+                    return { success: true };
+                }
+                finally {
+                    yield this.lockService.releaseLock('exclusive-task', lockResult.lockValue);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to acquire lock: ${error.message}`);
+                throw new Error('Operation cannot proceed without exclusive access');
+            }
+        });
+    }
+    processPayment(orderId, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockKey = `payment:${orderId}`;
+            try {
+                const lockResult = yield this.lockService.acquireLock(lockKey, {
+                    strategy: index_1.LockStrategy.THROW,
+                    ttl: 60000,
+                });
+                try {
+                    this.logger.log(`Processing payment for order ${orderId}...`);
+                    yield this.chargePayment(orderId, amount);
+                    yield this.updateOrderStatus(orderId, 'paid');
+                    return { success: true };
+                }
+                finally {
+                    yield this.lockService.releaseLock(lockKey, lockResult.lockValue);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Payment processing failed for ${orderId}: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+    processData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 2000));
+        });
+    }
+    chargePayment(orderId, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 1000));
+        });
+    }
+    updateOrderStatus(orderId, status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 500));
+        });
+    }
+};
+exports.ThrowStrategyExample = ThrowStrategyExample;
+__decorate([
+    (0, index_1.UseRedisLock)('critical-operation', {
+        ttl: 60000,
+        strategy: index_1.LockStrategy.THROW,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ThrowStrategyExample.prototype, "criticalOperation", null);
+exports.ThrowStrategyExample = ThrowStrategyExample = ThrowStrategyExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.RedisLockService])
+], ThrowStrategyExample);
+let WaitStrategyExample = WaitStrategyExample_1 = class WaitStrategyExample {
+    constructor(lockService) {
+        this.lockService = lockService;
+        this.logger = new common_1.Logger(WaitStrategyExample_1.name);
+    }
+    sequentialTask() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Executing sequential task...');
+            yield this.processInOrder();
+            this.logger.log('Sequential task completed');
+        });
+    }
+    processWithWaitTimeout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockResult = yield this.lockService.acquireLock('wait-task', {
+                strategy: index_1.LockStrategy.WAIT,
+                waitTimeout: 30000,
+                retryDelay: 200,
+                ttl: 60000,
+            });
+            if (!lockResult.acquired) {
+                this.logger.warn('Timed out waiting for lock after 30 seconds');
+                return { timeout: true };
+            }
+            try {
+                this.logger.log('Lock acquired after waiting, processing...');
+                yield this.processInOrder();
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock('wait-task', lockResult.lockValue);
+            }
+        });
+    }
+    processDataSequentially(userId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockKey = `user-data:${userId}`;
+            const lockResult = yield this.lockService.acquireLock(lockKey, {
+                strategy: index_1.LockStrategy.WAIT,
+                retryDelay: 50,
+                ttl: 120000,
+            });
+            try {
+                this.logger.log(`Processing data for user ${userId}...`);
+                yield this.validateData(data);
+                yield this.saveData(userId, data);
+                yield this.notifyUser(userId);
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock(lockKey, lockResult.lockValue);
+            }
+        });
+    }
+    processQueue(queueName, item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockKey = `queue:${queueName}`;
+            this.logger.log(`Waiting for lock to process item in queue ${queueName}...`);
+            const lockResult = yield this.lockService.acquireLock(lockKey, {
+                strategy: index_1.LockStrategy.WAIT,
+                retryDelay: 100,
+                ttl: 60000,
+            });
+            try {
+                this.logger.log(`Lock acquired, processing item in queue ${queueName}...`);
+                yield this.processQueueItem(item);
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock(lockKey, lockResult.lockValue);
+            }
+        });
+    }
+    runMigration(migrationName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockKey = `migration:${migrationName}`;
+            this.logger.log(`Waiting to run migration ${migrationName}...`);
+            const lockResult = yield this.lockService.acquireLock(lockKey, {
+                strategy: index_1.LockStrategy.WAIT,
+                waitTimeout: 300000,
+                retryDelay: 1000,
+                ttl: 600000,
+            });
+            if (!lockResult.acquired) {
+                throw new Error(`Migration ${migrationName} timed out waiting for lock`);
+            }
+            try {
+                this.logger.log(`Running migration ${migrationName}...`);
+                yield this.executeMigration(migrationName);
+                this.logger.log(`Migration ${migrationName} completed successfully`);
+                return { success: true };
+            }
+            finally {
+                yield this.lockService.releaseLock(lockKey, lockResult.lockValue);
+            }
+        });
+    }
+    processInOrder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 2000));
+        });
+    }
+    validateData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 500));
+        });
+    }
+    saveData(userId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 1000));
+        });
+    }
+    notifyUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 500));
+        });
+    }
+    processQueueItem(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 1500));
+        });
+    }
+    executeMigration(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 5000));
+        });
+    }
+};
+exports.WaitStrategyExample = WaitStrategyExample;
+__decorate([
+    (0, index_1.UseRedisLock)('sequential-task', {
+        ttl: 30000,
+        strategy: index_1.LockStrategy.WAIT,
+        retryDelay: 100,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], WaitStrategyExample.prototype, "sequentialTask", null);
+exports.WaitStrategyExample = WaitStrategyExample = WaitStrategyExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.RedisLockService])
+], WaitStrategyExample);
+let CombinedStrategiesExample = CombinedStrategiesExample_1 = class CombinedStrategiesExample {
+    constructor(lockService) {
+        this.lockService = lockService;
+        this.logger = new common_1.Logger(CombinedStrategiesExample_1.name);
+    }
+    cleanupOldData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Running cleanup...');
+        });
+    }
+    processPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockResult = yield this.lockService.acquireLock(`payment:${orderId}`, {
+                strategy: index_1.LockStrategy.THROW,
+                ttl: 60000,
+            });
+            try {
+            }
+            finally {
+                yield this.lockService.releaseLock(`payment:${orderId}`, lockResult.lockValue);
+            }
+        });
+    }
+    generateReport(reportId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lockResult = yield this.lockService.acquireLock(`report:${reportId}`, {
+                strategy: index_1.LockStrategy.WAIT,
+                waitTimeout: 180000,
+                retryDelay: 500,
+                ttl: 300000,
+            });
+            if (!lockResult.acquired) {
+                throw new Error('Report generation timed out');
+            }
+            try {
+            }
+            finally {
+                yield this.lockService.releaseLock(`report:${reportId}`, lockResult.lockValue);
+            }
+        });
+    }
+};
+exports.CombinedStrategiesExample = CombinedStrategiesExample;
+__decorate([
+    (0, schedule_1.Cron)('0 */6 * * *'),
+    (0, index_1.UseRedisLock)('cleanup-task', {
+        strategy: index_1.LockStrategy.SKIP,
+        ttl: 3600000,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CombinedStrategiesExample.prototype, "cleanupOldData", null);
+exports.CombinedStrategiesExample = CombinedStrategiesExample = CombinedStrategiesExample_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.RedisLockService])
+], CombinedStrategiesExample);

package/redis-lock/index.d.ts

@@ -0,0 +1,4 @@
+export { RedisLockModule, type RedisLockModuleOptions, REDIS_LOCK_SERVICE, } from './redis-lock.module';
+export { RedisLockService, LockStrategy } from './redis-lock.service';
+export { UseRedisLock, UseRedisLockOrSkip, UseRedisLockSmart, UseRedisLockOrSkipSmart, setLockService, getLockService, } from './redis-lock.decorator';
+export type { LockOptions, LockResult } from './redis-lock.service';

package/redis-lock/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLockService = exports.setLockService = exports.UseRedisLockOrSkipSmart = exports.UseRedisLockSmart = exports.UseRedisLockOrSkip = exports.UseRedisLock = exports.LockStrategy = exports.RedisLockService = exports.REDIS_LOCK_SERVICE = exports.RedisLockModule = void 0;
+var redis_lock_module_1 = require("./redis-lock.module");
+Object.defineProperty(exports, "RedisLockModule", { enumerable: true, get: function () { return redis_lock_module_1.RedisLockModule; } });
+Object.defineProperty(exports, "REDIS_LOCK_SERVICE", { enumerable: true, get: function () { return redis_lock_module_1.REDIS_LOCK_SERVICE; } });
+var redis_lock_service_1 = require("./redis-lock.service");
+Object.defineProperty(exports, "RedisLockService", { enumerable: true, get: function () { return redis_lock_service_1.RedisLockService; } });
+Object.defineProperty(exports, "LockStrategy", { enumerable: true, get: function () { return redis_lock_service_1.LockStrategy; } });
+var redis_lock_decorator_1 = require("./redis-lock.decorator");
+Object.defineProperty(exports, "UseRedisLock", { enumerable: true, get: function () { return redis_lock_decorator_1.UseRedisLock; } });
+Object.defineProperty(exports, "UseRedisLockOrSkip", { enumerable: true, get: function () { return redis_lock_decorator_1.UseRedisLockOrSkip; } });
+Object.defineProperty(exports, "UseRedisLockSmart", { enumerable: true, get: function () { return redis_lock_decorator_1.UseRedisLockSmart; } });
+Object.defineProperty(exports, "UseRedisLockOrSkipSmart", { enumerable: true, get: function () { return redis_lock_decorator_1.UseRedisLockOrSkipSmart; } });
+Object.defineProperty(exports, "setLockService", { enumerable: true, get: function () { return redis_lock_decorator_1.setLockService; } });
+Object.defineProperty(exports, "getLockService", { enumerable: true, get: function () { return redis_lock_decorator_1.getLockService; } });

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

@@ -0,0 +1,12 @@
+import type { LockOptions } from './redis-lock.service';
+import { RedisLockService } from './redis-lock.service';
+export declare function setLockService(lockService: RedisLockService): void;
+export declare function getLockService(): RedisLockService | null;
+export declare function UseRedisLock(lockKey: string, options?: LockOptions & {
+    skipReturnValue?: any;
+}): MethodDecorator;
+export declare function UseRedisLockOrSkip(lockKey: string, ttl?: number): MethodDecorator;
+export declare function UseRedisLockSmart(options?: LockOptions & {
+    skipReturnValue?: any;
+}): MethodDecorator;
+export declare function UseRedisLockOrSkipSmart(ttl?: number): MethodDecorator;

package/redis-lock/redis-lock.decorator.js

@@ -0,0 +1,125 @@
+"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.setLockService = setLockService;
+exports.getLockService = getLockService;
+exports.UseRedisLock = UseRedisLock;
+exports.UseRedisLockOrSkip = UseRedisLockOrSkip;
+exports.UseRedisLockSmart = UseRedisLockSmart;
+exports.UseRedisLockOrSkipSmart = UseRedisLockOrSkipSmart;
+const common_1 = require("@nestjs/common");
+const redis_lock_service_1 = require("./redis-lock.service");
+let globalLockService = null;
+function setLockService(lockService) {
+    globalLockService = lockService;
+    redis_lock_service_1.RedisLockService.setGlobalInstance(lockService);
+}
+function getLockService() {
+    return globalLockService;
+}
+function UseRedisLock(lockKey, options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const logger = new common_1.Logger(`RedisLock:${lockKey}`);
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                let lockService = getLockService();
+                if (!lockService) {
+                    const { RedisLockService } = yield Promise.resolve().then(() => require('./redis-lock.service'));
+                    lockService = RedisLockService.getGlobalInstance();
+                    if (!lockService) {
+                        logger.error(`RedisLockService not found. Please ensure RedisLockModule is properly configured with a Redis client.`);
+                        return (_a = options.skipReturnValue) !== null && _a !== void 0 ? _a : null;
+                    }
+                }
+                const skipReturnValue = (_b = options.skipReturnValue) !== null && _b !== void 0 ? _b : null;
+                try {
+                    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`);
+                    }
+                }
+                catch (error) {
+                    if ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('requires a Redis client to be set')) {
+                        logger.error(`Redis client not configured for RedisLock in ${lockKey}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    if (((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('ECONNREFUSED')) ||
+                        ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('ECONNRESET')) ||
+                        ((_f = error.message) === null || _f === void 0 ? void 0 : _f.includes('ETIMEDOUT')) ||
+                        ((_g = error.message) === null || _g === void 0 ? void 0 : _g.includes('Redis connection')) ||
+                        ((_h = error.message) === null || _h === void 0 ? void 0 : _h.includes('Connection is closed')) ||
+                        error.code === 'ECONNREFUSED' ||
+                        error.code === 'ECONNRESET' ||
+                        error.code === 'ETIMEDOUT') {
+                        logger.error(`Redis connection error in ${lockKey}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    if (((_j = error.message) === null || _j === void 0 ? void 0 : _j.includes('READONLY')) ||
+                        ((_k = error.message) === null || _k === void 0 ? void 0 : _k.includes('LOADING')) ||
+                        ((_l = error.message) === null || _l === void 0 ? void 0 : _l.includes('MASTERDOWN')) ||
+                        ((_m = error.message) === null || _m === void 0 ? void 0 : _m.includes('NOREPLICAS'))) {
+                        logger.error(`Redis server error in ${lockKey}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    if (((_o = error.message) === null || _o === void 0 ? void 0 : _o.includes('getaddrinfo')) || error.code === 'EAI_AGAIN') {
+                        logger.error(`Network error connecting to Redis in ${lockKey}: ${error.message}. ` +
+                            `Skipping execution to prevent issues.`);
+                        return skipReturnValue;
+                    }
+                    logger.error(`Unexpected error in RedisLock for ${lockKey}: ${error.message}`, error.stack);
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+function UseRedisLockOrSkip(lockKey, ttl = 300000) {
+    return UseRedisLock(lockKey, {
+        ttl,
+        skipReturnValue: false,
+    });
+}
+function UseRedisLockSmart(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        const lockKey = `${className}:${methodName}`;
+        return UseRedisLock(lockKey, options)(target, propertyKey, descriptor);
+    };
+}
+function UseRedisLockOrSkipSmart(ttl = 300000) {
+    return UseRedisLockSmart({
+        ttl,
+        skipReturnValue: false,
+    });
+}

package/redis-lock/redis-lock.module.d.ts

@@ -0,0 +1,23 @@
+import { DynamicModule, OnModuleInit } from '@nestjs/common';
+import type { Redis } from 'ioredis';
+export declare const REDIS_LOCK_SERVICE: unique symbol;
+export interface RedisLockModuleOptions {
+    isGlobal?: boolean;
+    redisClient: Redis;
+    defaultTtl?: number;
+    defaultKeyPrefix?: string;
+    defaultRetryCount?: number;
+    defaultRetryDelay?: number;
+}
+export declare class RedisLockModule implements OnModuleInit {
+    private redisLockService;
+    constructor();
+    static forRoot(options: RedisLockModuleOptions): DynamicModule;
+    static forRootAsync(options: {
+        imports?: any[];
+        inject?: any[];
+        useFactory: (...args: any[]) => Promise<RedisLockModuleOptions> | RedisLockModuleOptions;
+        isGlobal?: boolean;
+    }): DynamicModule;
+    onModuleInit(): void;
+}