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

package/redis-lock/redis-lock.module.js

@@ -0,0 +1,117 @@
+"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 RedisLockModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockModule = exports.REDIS_LOCK_SERVICE = void 0;
+const common_1 = require("@nestjs/common");
+const redis_lock_service_1 = require("./redis-lock.service");
+const redis_lock_decorator_1 = require("./redis-lock.decorator");
+exports.REDIS_LOCK_SERVICE = Symbol('REDIS_LOCK_SERVICE');
+let RedisLockModule = RedisLockModule_1 = class RedisLockModule {
+    constructor() { }
+    static forRoot(options) {
+        const { isGlobal = true, redisClient, defaultTtl, defaultKeyPrefix, defaultRetryCount, defaultRetryDelay, } = options;
+        return {
+            module: RedisLockModule_1,
+            global: isGlobal,
+            providers: [
+                {
+                    provide: 'REDIS_LOCK_CLIENT',
+                    useValue: redisClient,
+                },
+                {
+                    provide: exports.REDIS_LOCK_SERVICE,
+                    useFactory: () => {
+                        const service = new redis_lock_service_1.RedisLockService();
+                        service.setRedisClient(redisClient);
+                        if (defaultTtl) {
+                            service.setDefaultTtl(defaultTtl);
+                        }
+                        if (defaultKeyPrefix) {
+                            service.setDefaultKeyPrefix(defaultKeyPrefix);
+                        }
+                        if (defaultRetryCount !== undefined) {
+                            service.setDefaultRetryCount(defaultRetryCount);
+                        }
+                        if (defaultRetryDelay !== undefined) {
+                            service.setDefaultRetryDelay(defaultRetryDelay);
+                        }
+                        return service;
+                    },
+                },
+                {
+                    provide: redis_lock_service_1.RedisLockService,
+                    useExisting: exports.REDIS_LOCK_SERVICE,
+                },
+            ],
+            exports: [exports.REDIS_LOCK_SERVICE, redis_lock_service_1.RedisLockService],
+        };
+    }
+    static forRootAsync(options) {
+        var _a;
+        return {
+            module: RedisLockModule_1,
+            global: (_a = options.isGlobal) !== null && _a !== void 0 ? _a : true,
+            imports: options.imports || [],
+            providers: [
+                {
+                    provide: 'REDIS_LOCK_MODULE_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: 'REDIS_LOCK_CLIENT',
+                    useFactory: (moduleOptions) => moduleOptions.redisClient,
+                    inject: ['REDIS_LOCK_MODULE_OPTIONS'],
+                },
+                {
+                    provide: exports.REDIS_LOCK_SERVICE,
+                    useFactory: (moduleOptions) => {
+                        const service = new redis_lock_service_1.RedisLockService();
+                        service.setRedisClient(moduleOptions.redisClient);
+                        if (moduleOptions.defaultTtl) {
+                            service.setDefaultTtl(moduleOptions.defaultTtl);
+                        }
+                        if (moduleOptions.defaultKeyPrefix) {
+                            service.setDefaultKeyPrefix(moduleOptions.defaultKeyPrefix);
+                        }
+                        if (moduleOptions.defaultRetryCount !== undefined) {
+                            service.setDefaultRetryCount(moduleOptions.defaultRetryCount);
+                        }
+                        if (moduleOptions.defaultRetryDelay !== undefined) {
+                            service.setDefaultRetryDelay(moduleOptions.defaultRetryDelay);
+                        }
+                        return service;
+                    },
+                    inject: ['REDIS_LOCK_MODULE_OPTIONS'],
+                },
+                {
+                    provide: redis_lock_service_1.RedisLockService,
+                    useExisting: exports.REDIS_LOCK_SERVICE,
+                },
+            ],
+            exports: [exports.REDIS_LOCK_SERVICE, redis_lock_service_1.RedisLockService],
+        };
+    }
+    onModuleInit() {
+        const globalInstance = redis_lock_service_1.RedisLockService.getGlobalInstance();
+        if (globalInstance) {
+            this.redisLockService = globalInstance;
+            (0, redis_lock_decorator_1.setLockService)(this.redisLockService);
+        }
+    }
+};
+exports.RedisLockModule = RedisLockModule;
+exports.RedisLockModule = RedisLockModule = RedisLockModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [])
+], RedisLockModule);

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

@@ -0,0 +1,66 @@
+import { OnModuleInit } from '@nestjs/common';
+import type Redis from 'ioredis';
+export declare enum LockStrategy {
+    SKIP = "SKIP",
+    THROW = "THROW",
+    WAIT = "WAIT"
+}
+export interface LockOptions {
+    ttl?: number;
+    retryCount?: number;
+    retryDelay?: number;
+    keyPrefix?: string;
+    throwOnFailure?: boolean;
+    strategy?: LockStrategy;
+    waitTimeout?: number;
+    autoExtend?: number;
+}
+export interface LockResult {
+    acquired: boolean;
+    lockValue?: string;
+    error?: string;
+    autoExtendTimer?: NodeJS.Timeout;
+}
+export declare class RedisLockService implements OnModuleInit {
+    private static globalInstance;
+    private readonly logger;
+    private redis;
+    private readonly defaultOptions;
+    constructor();
+    static getGlobalInstance(): RedisLockService | null;
+    static getOrCreateGlobalInstance(): RedisLockService;
+    static setGlobalInstance(instance: RedisLockService): void;
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    setRedisClient(redis: Redis): void;
+    setDefaultTtl(ttl: number): void;
+    setDefaultKeyPrefix(prefix: string): void;
+    setDefaultRetryCount(count: number): void;
+    setDefaultRetryDelay(delay: number): 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>;
+    cleanupLocksByPattern(pattern: string, keyPrefix?: string): Promise<number>;
+    cleanupOnStartup(patterns: string[], keyPrefix?: string): Promise<number>;
+    healthCheck(): Promise<{
+        healthy: boolean;
+        redis: boolean;
+        message: string;
+    }>;
+    getActiveLocks(pattern?: string, keyPrefix?: string): Promise<Array<{
+        key: string;
+        value: string | null;
+        ttl: number | null;
+    }>>;
+    private getRedis;
+    private generateLockValue;
+    private buildLockKey;
+    private sleep;
+}

package/redis-lock/redis-lock.service.js

@@ -0,0 +1,413 @@
+"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 = exports.LockStrategy = void 0;
+const common_1 = require("@nestjs/common");
+var LockStrategy;
+(function (LockStrategy) {
+    LockStrategy["SKIP"] = "SKIP";
+    LockStrategy["THROW"] = "THROW";
+    LockStrategy["WAIT"] = "WAIT";
+})(LockStrategy || (exports.LockStrategy = LockStrategy = {}));
+let RedisLockService = RedisLockService_1 = class RedisLockService {
+    constructor() {
+        this.logger = new common_1.Logger(RedisLockService_1.name);
+        this.redis = null;
+        this.defaultOptions = {
+            ttl: 300000,
+            retryCount: 0,
+            retryDelay: 100,
+            keyPrefix: 'lock',
+            throwOnFailure: false,
+            strategy: LockStrategy.SKIP,
+            waitTimeout: undefined,
+            autoExtend: 0,
+        };
+        if (!RedisLockService_1.globalInstance) {
+            RedisLockService_1.globalInstance = this;
+        }
+    }
+    static getGlobalInstance() {
+        return RedisLockService_1.globalInstance;
+    }
+    static getOrCreateGlobalInstance() {
+        if (!RedisLockService_1.globalInstance) {
+            RedisLockService_1.globalInstance = new RedisLockService_1();
+        }
+        return RedisLockService_1.globalInstance;
+    }
+    static setGlobalInstance(instance) {
+        RedisLockService_1.globalInstance = instance;
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                this.logger.warn('RedisLockService initialized but no Redis client provided. Redis Lock functionality will not work.');
+            }
+            else {
+                this.logger.log('RedisLockService initialized with Redis client');
+            }
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('RedisLockService destroyed');
+        });
+    }
+    setRedisClient(redis) {
+        this.redis = redis;
+        this.logger.log('Redis client set for RedisLockService');
+    }
+    setDefaultTtl(ttl) {
+        this.defaultOptions.ttl = ttl;
+    }
+    setDefaultKeyPrefix(prefix) {
+        this.defaultOptions.keyPrefix = prefix;
+    }
+    setDefaultRetryCount(count) {
+        this.defaultOptions.retryCount = count;
+    }
+    setDefaultRetryDelay(delay) {
+        this.defaultOptions.retryDelay = delay;
+    }
+    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);
+            if (opts.throwOnFailure && !options.strategy) {
+                opts.strategy = LockStrategy.THROW;
+            }
+            const lockKey = this.buildLockKey(key, opts.keyPrefix);
+            const lockValue = this.generateLockValue();
+            let maxAttempts;
+            if (opts.strategy === LockStrategy.WAIT) {
+                maxAttempts = Number.MAX_SAFE_INTEGER;
+            }
+            else {
+                maxAttempts = opts.retryCount + 1;
+            }
+            let attempts = 0;
+            const startTime = Date.now();
+            while (attempts < maxAttempts) {
+                if (opts.strategy === LockStrategy.WAIT && opts.waitTimeout) {
+                    const elapsed = Date.now() - startTime;
+                    if (elapsed >= opts.waitTimeout) {
+                        const timeoutMessage = `Lock acquisition timed out for ${lockKey} after ${elapsed}ms (waitTimeout: ${opts.waitTimeout}ms)`;
+                        this.logger.warn(timeoutMessage);
+                        return { acquired: false, error: timeoutMessage };
+                    }
+                }
+                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, attempts: ${attempts + 1})`);
+                        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 (opts.strategy === LockStrategy.WAIT) {
+                        if (attempts === 1 || attempts % 10 === 0) {
+                            this.logger.debug(`Waiting for lock ${lockKey}... (attempt ${attempts})`);
+                        }
+                    }
+                    else if (attempts < maxAttempts) {
+                        this.logger.debug(`Lock acquisition failed for ${lockKey}, retrying... (${attempts}/${opts.retryCount})`);
+                    }
+                    if (attempts < maxAttempts) {
+                        yield this.sleep(opts.retryDelay);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                    this.logger.error(errorMessage, error.stack);
+                    if (opts.strategy === LockStrategy.THROW) {
+                        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.strategy === LockStrategy.THROW) {
+                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;
+            }
+        });
+    }
+    cleanupLocksByPattern(pattern_1) {
+        return __awaiter(this, arguments, void 0, function* (pattern, keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const searchPattern = `${keyPrefix}:${pattern}`;
+            try {
+                const keys = yield redis.keys(searchPattern);
+                if (keys.length === 0) {
+                    this.logger.debug(`No locks found matching pattern: ${searchPattern}`);
+                    return 0;
+                }
+                const result = yield redis.del(...keys);
+                this.logger.log(`Cleaned up ${result} lock(s) matching pattern: ${searchPattern}`);
+                return result;
+            }
+            catch (error) {
+                this.logger.error(`Error cleaning up locks by pattern ${searchPattern}: ${error.message}`, error.stack);
+                return 0;
+            }
+        });
+    }
+    cleanupOnStartup(patterns_1) {
+        return __awaiter(this, arguments, void 0, function* (patterns, keyPrefix = 'lock') {
+            this.logger.log(`Starting lock cleanup for ${patterns.length} pattern(s) on startup...`);
+            let totalDeleted = 0;
+            for (const pattern of patterns) {
+                const deleted = yield this.cleanupLocksByPattern(pattern, keyPrefix);
+                totalDeleted += deleted;
+            }
+            this.logger.log(`Startup lock cleanup completed. Deleted ${totalDeleted} lock(s)`);
+            return totalDeleted;
+        });
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const redis = yield this.getRedis();
+                const pong = yield redis.ping();
+                if (pong === 'PONG') {
+                    return {
+                        healthy: true,
+                        redis: true,
+                        message: 'Redis Lock Service is healthy',
+                    };
+                }
+                else {
+                    return {
+                        healthy: false,
+                        redis: false,
+                        message: 'Redis ping returned unexpected response',
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    redis: false,
+                    message: `Redis Lock Service unhealthy: ${error.message}`,
+                };
+            }
+        });
+    }
+    getActiveLocks() {
+        return __awaiter(this, arguments, void 0, function* (pattern = '*', keyPrefix = 'lock') {
+            const redis = yield this.getRedis();
+            const searchPattern = `${keyPrefix}:${pattern}`;
+            try {
+                const keys = yield redis.keys(searchPattern);
+                if (keys.length === 0) {
+                    return [];
+                }
+                const locks = yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
+                    const [value, ttl] = yield Promise.all([
+                        redis.get(key),
+                        redis.pttl(key),
+                    ]);
+                    const cleanKey = key.startsWith(`${keyPrefix}:`)
+                        ? key.substring(`${keyPrefix}:`.length)
+                        : key;
+                    return {
+                        key: cleanKey,
+                        value,
+                        ttl: ttl >= 0 ? ttl : null,
+                    };
+                })));
+                return locks.filter((lock) => lock.value !== null);
+            }
+            catch (error) {
+                this.logger.error(`Error getting active locks: ${error.message}`, error.stack);
+                return [];
+            }
+        });
+    }
+    getRedis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                throw new Error('RedisLockService requires a Redis client to be set. Please provide a Redis client through the module configuration.');
+            }
+            return this.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", [])
+], RedisLockService);

package/setup/bootstrap.setup.d.ts

@@ -0,0 +1,2 @@
+import type { NestExpressApplication } from '@nestjs/platform-express';
+export declare function bootstrapSetup(AppModule: any, SetupSwagger: any): Promise<NestExpressApplication<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>>;