@nest-omni/core 3.1.1-17 → 3.1.1-19

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

@@ -19,8 +19,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var RedisLockService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisLockService = void 0;
+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);
@@ -31,6 +37,8 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             retryDelay: 100,
             keyPrefix: 'lock',
             throwOnFailure: false,
+            strategy: LockStrategy.SKIP,
+            waitTimeout: undefined,
             autoExtend: 0,
         };
         if (!RedisLockService_1.globalInstance) {
@@ -84,15 +92,33 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
         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 maxAttempts = opts.retryCount + 1;
+            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)`);
+                        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* () {
@@ -107,15 +133,22 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
                         return { acquired: true, lockValue, autoExtendTimer };
                     }
                     attempts++;
-                    if (attempts < maxAttempts) {
+                    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.throwOnFailure) {
+                    if (opts.strategy === LockStrategy.THROW) {
                         throw new Error(errorMessage);
                     }
                     return { acquired: false, error: errorMessage };
@@ -123,7 +156,7 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             }
             const failureMessage = `Failed to acquire lock for ${lockKey} after ${attempts} attempts`;
             this.logger.warn(failureMessage);
-            if (opts.throwOnFailure) {
+            if (opts.strategy === LockStrategy.THROW) {
                 throw new Error(failureMessage);
             }
             return { acquired: false, error: failureMessage };
@@ -262,6 +295,98 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             }
         });
     }
+    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) {

package/setup/bootstrap.setup.d.ts

@@ -1,3 +1,2 @@
-import '../common/boilerplate.polyfill';
 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>>>;

package/setup/bootstrap.setup.js

@@ -17,7 +17,6 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const process = require("process");
 const mode_setup_1 = require("./mode.setup");
-require("../common/boilerplate.polyfill");
 function findValidRootPath() {
     const getAppRootPath = () => {
         if (require.main && require.main.filename) {

package/setup/index.d.ts

@@ -2,4 +2,3 @@ export * from './bootstrap.setup';
 export * from './mode.setup';
 export * from './worker.decorator';
 export * from './schedule.decorator';
-export * from '../redis-lock';

package/setup/index.js

@@ -18,4 +18,3 @@ __exportStar(require("./bootstrap.setup"), exports);
 __exportStar(require("./mode.setup"), exports);
 __exportStar(require("./worker.decorator"), exports);
 __exportStar(require("./schedule.decorator"), exports);
-__exportStar(require("../redis-lock"), exports);

package/shared/serviceRegistryModule.js

@@ -125,6 +125,8 @@ if (services_1.ApiConfigService.toBoolean(process.env.CACHE_ENABLED)) {
                 dataSource,
                 memoryTtl: config.getNumber('CACHE_TTL'),
                 memoryNamespace: config.getString('CACHE_NAMESPACE', 'default'),
+                enableCompression: config.getBoolean('CACHE_COMPRESSION_ENABLED', false),
+                compressionThreshold: config.getNumber('CACHE_COMPRESSION_THRESHOLD', 1024),
             };
         }),
     }));