@nest-omni/core 3.1.1-18 → 3.1.1-20

package/decorators/validator.decorators.js

@@ -1,5 +1,21 @@
 "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 __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.AtLeastOneFieldConstraint = void 0;
 exports.IsPassword = IsPassword;
 exports.IsPhoneNumber = IsPhoneNumber;
 exports.IsTmpKey = IsTmpKey;
@@ -7,8 +23,12 @@ exports.IsUndefinable = IsUndefinable;
 exports.IsEmptyable = IsEmptyable;
 exports.IsNullable = IsNullable;
 exports.IsHttpUrl = IsHttpUrl;
+exports.AtLeastOneField = AtLeastOneField;
+exports.CustomValidation = CustomValidation;
+exports.CustomValidationMethod = CustomValidationMethod;
 const class_validator_1 = require("class-validator");
 const lodash_1 = require("lodash");
+const nestjs_i18n_1 = require("nestjs-i18n");
 function IsPassword(validationOptions) {
     return (object, propertyName) => {
         (0, class_validator_1.registerDecorator)({
@@ -76,3 +96,98 @@ function IsHttpUrl(validationOptions) {
         });
     };
 }
+let AtLeastOneFieldConstraint = class AtLeastOneFieldConstraint {
+    validate(value, args) {
+        const object = args.object;
+        const [requiredProperties] = args.constraints;
+        return requiredProperties.some((property) => {
+            const propValue = object[property];
+            return (propValue !== null &&
+                propValue !== undefined &&
+                propValue !== '' &&
+                !(Array.isArray(propValue) && propValue.length === 0));
+        });
+    }
+    defaultMessage(args) {
+        const [requiredProperties] = args.constraints;
+        return `At least one of the following fields must be provided: ${requiredProperties.join(', ')}`;
+    }
+};
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint;
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'atLeastOneField', async: false })
+], AtLeastOneFieldConstraint);
+function AtLeastOneField(properties, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName: propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.AT_LEAST_ONE_FIELD', {
+                    properties: properties.join(', '),
+                }) }, validationOptions),
+            constraints: [properties],
+            validator: AtLeastOneFieldConstraint,
+        });
+    };
+}
+function CustomValidation(validationCallback, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidation',
+            target: object.constructor,
+            propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            return yield validationCallback(value, args);
+                        }
+                        catch (error) {
+                            console.error('CustomValidation error:', error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    return `Validation failed for ${args.property}`;
+                },
+            },
+        });
+    };
+}
+function CustomValidationMethod(methodName, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidationMethod',
+            target: object.constructor,
+            propertyName,
+            constraints: [methodName],
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION_METHOD') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const [method] = args.constraints;
+                        const object = args.object;
+                        if (typeof object[method] !== 'function') {
+                            console.error(`CustomValidationMethod: Method '${method}' not found on object`);
+                            return false;
+                        }
+                        try {
+                            const result = yield object[method](value, args);
+                            return Boolean(result);
+                        }
+                        catch (error) {
+                            console.error(`CustomValidationMethod error in '${method}':`, error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    const [method] = args.constraints;
+                    return `Validation failed for ${args.property} using method ${method}`;
+                },
+            },
+        });
+    };
+}

package/i18n/en_US/validation.json

@@ -37,5 +37,8 @@
     "IS_IP": "{property} value `{value}` not a valid IP",
     "IS_OBJECT": "{property} value `{value}` not a valid Object",
     "IS_TIME_ZONE": "{property} value `{value}` must be a valid IANA time-zone",
-    "IS_LOCALE": "{property} value `{value}` must be a valid locale"
+    "IS_LOCALE": "{property} value `{value}` must be a valid locale",
+    "AT_LEAST_ONE_FIELD": "At least one of the following fields must be provided: {properties}",
+    "CUSTOM_VALIDATION": "Custom validation failed for {property}",
+    "CUSTOM_VALIDATION_METHOD": "Validation failed for {property}"
 }

package/i18n/zh_CN/validation.json

@@ -37,5 +37,8 @@
     "IS_IP": "{property} 值 `{value}` 必须是有效IP",
     "IS_OBJECT": "{property} 值 `{value}` 必须是有效对象",
     "IS_TIME_ZONE": "{property} 值 `{value}` 必须是有效时区",
-    "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言"
+    "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言",
+    "AT_LEAST_ONE_FIELD": "以下字段中至少必须提供一个：{properties}",
+    "CUSTOM_VALIDATION": "{property}自定义验证失败",
+    "CUSTOM_VALIDATION_METHOD": "{property}验证失败"
 }

package/index.d.ts

@@ -11,6 +11,7 @@ export * from './common';
 export * from './validator-json';
 export * from './helpers';
 export * from './providers';
+export * from './redis-lock';
 export * from './cache';
 export * from './vault';
 export * from './setup';

package/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./validator-json"), exports);
 __exportStar(require("./helpers"), exports);
 __exportStar(require("./providers"), exports);
+__exportStar(require("./redis-lock"), exports);
 __exportStar(require("./cache"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./setup"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "3.1.1-18",
+  "version": "3.1.1-20",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",

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

@@ -1,4 +1,4 @@
 export { RedisLockModule, type RedisLockModuleOptions, REDIS_LOCK_SERVICE, } from './redis-lock.module';
-export { RedisLockService } from './redis-lock.service';
-export { UseRedisLock, UseRedisLockOrSkip, setLockService, getLockService, } from './redis-lock.decorator';
+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

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLockService = exports.setLockService = exports.UseRedisLockOrSkip = exports.UseRedisLock = exports.RedisLockService = exports.REDIS_LOCK_SERVICE = exports.RedisLockModule = void 0;
+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

@@ -6,3 +6,7 @@ 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;