@nest-omni/core 4.1.3-0 → 4.1.3-10

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

@@ -1,4 +1,9 @@
 "use strict";
+/**
+ * Lock Strategy Examples
+ *
+ * This file demonstrates the different lock acquisition strategies available in Redis Lock module.
+ */
 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);
@@ -23,18 +28,33 @@ exports.CombinedStrategiesExample = exports.WaitStrategyExample = exports.ThrowS
 const common_1 = require("@nestjs/common");
 const schedule_1 = require("@nestjs/schedule");
 const index_1 = require("../index");
+// ============================================================================
+// Strategy 1: SKIP (Default)
+// ============================================================================
+/**
+ * SKIP strategy - Skip execution if lock cannot be acquired
+ * This is the default behavior and is useful for scheduled tasks where you don't
+ * want to queue up requests if a previous execution is still running.
+ */
 let SkipStrategyExample = SkipStrategyExample_1 = class SkipStrategyExample {
     constructor(lockService) {
         this.lockService = lockService;
         this.logger = new common_1.Logger(SkipStrategyExample_1.name);
     }
+    /**
+     * Example 1: Using decorator with SKIP strategy (default)
+     */
     scheduledTask() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.log('Executing scheduled task...');
+            // This will skip if another instance is already running
             yield this.simulateLongRunning();
             this.logger.log('Scheduled task completed');
         });
     }
+    /**
+     * Example 2: Using service directly with SKIP strategy
+     */
     processWithSkip() {
         return __awaiter(this, void 0, void 0, function* () {
             const lockResult = yield this.lockService.acquireLock('process-task', {
@@ -55,13 +75,16 @@ let SkipStrategyExample = SkipStrategyExample_1 = class SkipStrategyExample {
             }
         });
     }
+    /**
+     * Example 3: SKIP with retries
+     */
     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,
+                retryCount: 3, // Try 3 times
+                retryDelay: 500, // Wait 500ms between retries
             });
             if (!lockResult.acquired) {
                 this.logger.warn('Failed to acquire lock after 3 retries');
@@ -84,10 +107,11 @@ let SkipStrategyExample = SkipStrategyExample_1 = class SkipStrategyExample {
 };
 exports.SkipStrategyExample = SkipStrategyExample;
 __decorate([
-    (0, schedule_1.Cron)('* * * * *'),
+    (0, schedule_1.Cron)('* * * * *') // Every minute
+    ,
     (0, index_1.UseRedisLock)('scheduled-task', {
         ttl: 60000,
-        strategy: index_1.LockStrategy.SKIP,
+        strategy: index_1.LockStrategy.SKIP, // Can be omitted as it's the default
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
@@ -97,18 +121,33 @@ exports.SkipStrategyExample = SkipStrategyExample = SkipStrategyExample_1 = __de
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [index_1.RedisLockService])
 ], SkipStrategyExample);
+// ============================================================================
+// Strategy 2: THROW
+// ============================================================================
+/**
+ * THROW strategy - Throw an error if lock cannot be acquired
+ * Use this for critical operations that must have exclusive access.
+ * If the lock cannot be acquired, an exception will be thrown.
+ */
 let ThrowStrategyExample = ThrowStrategyExample_1 = class ThrowStrategyExample {
     constructor(lockService) {
         this.lockService = lockService;
         this.logger = new common_1.Logger(ThrowStrategyExample_1.name);
     }
+    /**
+     * Example 1: Using decorator with THROW strategy
+     */
     criticalOperation() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.log('Executing critical operation...');
+            // If lock cannot be acquired, an error will be thrown
             yield this.processData();
             this.logger.log('Critical operation completed');
         });
     }
+    /**
+     * Example 2: Using service with error handling
+     */
     processWithThrow() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -127,20 +166,26 @@ let ThrowStrategyExample = ThrowStrategyExample_1 = class ThrowStrategyExample {
             }
             catch (error) {
                 this.logger.error(`Failed to acquire lock: ${error.message}`);
+                // Handle the error appropriately
                 throw new Error('Operation cannot proceed without exclusive access');
             }
         });
     }
+    /**
+     * Example 3: Critical payment processing
+     */
     processPayment(orderId, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const lockKey = `payment:${orderId}`;
             try {
+                // Must have exclusive access for payment processing
                 const lockResult = yield this.lockService.acquireLock(lockKey, {
                     strategy: index_1.LockStrategy.THROW,
                     ttl: 60000,
                 });
                 try {
                     this.logger.log(`Processing payment for order ${orderId}...`);
+                    // Payment logic here
                     yield this.chargePayment(orderId, amount);
                     yield this.updateOrderStatus(orderId, 'paid');
                     return { success: true };
@@ -162,11 +207,13 @@ let ThrowStrategyExample = ThrowStrategyExample_1 = class ThrowStrategyExample {
     }
     chargePayment(orderId, amount) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Simulate payment processing
             yield new Promise((resolve) => setTimeout(resolve, 1000));
         });
     }
     updateOrderStatus(orderId, status) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Update order status
             yield new Promise((resolve) => setTimeout(resolve, 500));
         });
     }
@@ -185,24 +232,39 @@ exports.ThrowStrategyExample = ThrowStrategyExample = ThrowStrategyExample_1 = _
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [index_1.RedisLockService])
 ], ThrowStrategyExample);
+// ============================================================================
+// Strategy 3: WAIT
+// ============================================================================
+/**
+ * WAIT strategy - Block/wait until lock can be acquired
+ * Use this when you want to queue execution and ensure the operation eventually runs.
+ * The function will wait indefinitely (or until waitTimeout) for the lock to become available.
+ */
 let WaitStrategyExample = WaitStrategyExample_1 = class WaitStrategyExample {
     constructor(lockService) {
         this.lockService = lockService;
         this.logger = new common_1.Logger(WaitStrategyExample_1.name);
     }
+    /**
+     * Example 1: Using decorator with WAIT strategy
+     */
     sequentialTask() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.log('Executing sequential task...');
+            // This will wait until lock is available
             yield this.processInOrder();
             this.logger.log('Sequential task completed');
         });
     }
+    /**
+     * Example 2: WAIT with timeout
+     */
     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,
+                waitTimeout: 30000, // Wait maximum 30 seconds
+                retryDelay: 200, // Check every 200ms
                 ttl: 60000,
             });
             if (!lockResult.acquired) {
@@ -219,16 +281,21 @@ let WaitStrategyExample = WaitStrategyExample_1 = class WaitStrategyExample {
             }
         });
     }
+    /**
+     * Example 3: Sequential data processing
+     * Perfect for operations that must be processed in order
+     */
     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,
+                ttl: 120000, // 2 minutes
             });
             try {
                 this.logger.log(`Processing data for user ${userId}...`);
+                // These operations will execute sequentially across all instances
                 yield this.validateData(data);
                 yield this.saveData(userId, data);
                 yield this.notifyUser(userId);
@@ -239,6 +306,10 @@ let WaitStrategyExample = WaitStrategyExample_1 = class WaitStrategyExample {
             }
         });
     }
+    /**
+     * Example 4: Queue-like behavior
+     * Multiple requests will queue and execute one by one
+     */
     processQueue(queueName, item) {
         return __awaiter(this, void 0, void 0, function* () {
             const lockKey = `queue:${queueName}`;
@@ -258,15 +329,19 @@ let WaitStrategyExample = WaitStrategyExample_1 = class WaitStrategyExample {
             }
         });
     }
+    /**
+     * Example 5: Database migration with WAIT
+     * Ensures migrations run sequentially across all instances
+     */
     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,
+                waitTimeout: 300000, // Wait up to 5 minutes
+                retryDelay: 1000, // Check every second
+                ttl: 600000, // Hold lock for 10 minutes max
             });
             if (!lockResult.acquired) {
                 throw new Error(`Migration ${migrationName} timed out waiting for lock`);
@@ -318,7 +393,7 @@ __decorate([
     (0, index_1.UseRedisLock)('sequential-task', {
         ttl: 30000,
         strategy: index_1.LockStrategy.WAIT,
-        retryDelay: 100,
+        retryDelay: 100, // Check every 100ms
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
@@ -328,16 +403,50 @@ exports.WaitStrategyExample = WaitStrategyExample = WaitStrategyExample_1 = __de
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [index_1.RedisLockService])
 ], WaitStrategyExample);
+// ============================================================================
+// Comparison: When to use each strategy
+// ============================================================================
+/**
+ * USE SKIP WHEN:
+ * - Running scheduled tasks where you don't want overlapping executions
+ * - Cron jobs that should skip if previous run is still in progress
+ * - Non-critical background tasks
+ * - Operations where it's okay to skip if busy
+ *
+ * USE THROW WHEN:
+ * - Critical operations that require exclusive access
+ * - Financial transactions
+ * - Operations where failure to acquire lock is an error
+ * - When you want to alert/fail fast if resource is busy
+ *
+ * USE WAIT WHEN:
+ * - Operations that must execute eventually
+ * - Sequential processing requirements
+ * - Queue-like behavior needed
+ * - Database migrations
+ * - Operations where order matters
+ * - When you want to ensure the operation runs (with optional timeout)
+ */
+/**
+ * Example: Combining strategies in a single service
+ */
 let CombinedStrategiesExample = CombinedStrategiesExample_1 = class CombinedStrategiesExample {
     constructor(lockService) {
         this.lockService = lockService;
         this.logger = new common_1.Logger(CombinedStrategiesExample_1.name);
     }
+    /**
+     * Background cleanup - SKIP if already running
+     */
     cleanupOldData() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logger.log('Running cleanup...');
+            // Cleanup logic
         });
     }
+    /**
+     * Payment processing - THROW if cannot get exclusive access
+     */
     processPayment(orderId) {
         return __awaiter(this, void 0, void 0, function* () {
             const lockResult = yield this.lockService.acquireLock(`payment:${orderId}`, {
@@ -345,24 +454,29 @@ let CombinedStrategiesExample = CombinedStrategiesExample_1 = class CombinedStra
                 ttl: 60000,
             });
             try {
+                // Payment logic
             }
             finally {
                 yield this.lockService.releaseLock(`payment:${orderId}`, lockResult.lockValue);
             }
         });
     }
+    /**
+     * Report generation - WAIT to ensure it runs eventually
+     */
     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,
+                waitTimeout: 180000, // Wait up to 3 minutes
                 retryDelay: 500,
-                ttl: 300000,
+                ttl: 300000, // 5 minutes
             });
             if (!lockResult.acquired) {
                 throw new Error('Report generation timed out');
             }
             try {
+                // Report generation logic
             }
             finally {
                 yield this.lockService.releaseLock(`report:${reportId}`, lockResult.lockValue);
@@ -372,10 +486,11 @@ let CombinedStrategiesExample = CombinedStrategiesExample_1 = class CombinedStra
 };
 exports.CombinedStrategiesExample = CombinedStrategiesExample;
 __decorate([
-    (0, schedule_1.Cron)('0 */6 * * *'),
+    (0, schedule_1.Cron)('0 */6 * * *') // Every 6 hours
+    ,
     (0, index_1.UseRedisLock)('cleanup-task', {
         strategy: index_1.LockStrategy.SKIP,
-        ttl: 3600000,
+        ttl: 3600000, // 1 hour
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),

package/redis-lock/index.d.ts

@@ -1,4 +1,6 @@
 export { RedisLockModule, type RedisLockModuleOptions, REDIS_LOCK_SERVICE, } from './redis-lock.module';
 export { RedisLockService, LockStrategy } from './redis-lock.service';
+export { LockHeartbeatService } from './lock-heartbeat.service';
+export { ComprehensiveLockCleanupService } from './comprehensive-lock-cleanup.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,12 +1,19 @@
 "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;
+exports.getLockService = exports.setLockService = exports.UseRedisLockOrSkipSmart = exports.UseRedisLockSmart = exports.UseRedisLockOrSkip = exports.UseRedisLock = exports.ComprehensiveLockCleanupService = exports.LockHeartbeatService = exports.LockStrategy = exports.RedisLockService = exports.REDIS_LOCK_SERVICE = exports.RedisLockModule = void 0;
+// Module
 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; } });
+// 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 lock_heartbeat_service_1 = require("./lock-heartbeat.service");
+Object.defineProperty(exports, "LockHeartbeatService", { enumerable: true, get: function () { return lock_heartbeat_service_1.LockHeartbeatService; } });
+var comprehensive_lock_cleanup_service_1 = require("./comprehensive-lock-cleanup.service");
+Object.defineProperty(exports, "ComprehensiveLockCleanupService", { enumerable: true, get: function () { return comprehensive_lock_cleanup_service_1.ComprehensiveLockCleanupService; } });
+// Decorators
 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; } });

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

@@ -0,0 +1,78 @@
+import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import type Redis from 'ioredis';
+/**
+ * Lock heartbeat service
+ *
+ * Provides heartbeat mechanism for distributed lock instances.
+ * Each instance sends periodic heartbeats to Redis to indicate it's alive.
+ * Dead instances can be detected by checking if their heartbeat has expired.
+ *
+ * @example
+ * ```typescript
+ * constructor(private heartbeatService: LockHeartbeatService) {}
+ *
+ * async isInstanceAlive(instanceId: string): Promise<boolean> {
+ *   return this.heartbeatService.isInstanceAlive(instanceId);
+ * }
+ * ```
+ */
+export declare class LockHeartbeatService implements OnModuleInit, OnModuleDestroy {
+    private readonly logger;
+    private readonly instanceId;
+    private redis;
+    private heartbeatTimer;
+    /**
+     * Heartbeat interval in milliseconds
+     * @default 10000 (10 seconds)
+     */
+    private readonly heartbeatInterval;
+    /**
+     * Heartbeat TTL in seconds (3x interval for safety)
+     * @default 30 (30 seconds)
+     */
+    private readonly heartbeatTtl;
+    constructor();
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Set Redis client (required for dependency injection)
+     */
+    setRedisClient(redis: Redis): void;
+    /**
+     * Send heartbeat to Redis
+     * Stores instance information with TTL
+     */
+    private sendHeartbeat;
+    /**
+     * Remove heartbeat record from Redis
+     */
+    private removeHeartbeat;
+    /**
+     * Check if an instance is alive by checking its heartbeat
+     *
+     * @param instanceId - Instance identifier to check
+     * @returns True if instance is alive (heartbeat exists), false otherwise
+     */
+    isInstanceAlive(instanceId: string): Promise<boolean>;
+    /**
+     * Get heartbeat information for an instance
+     *
+     * @param instanceId - Instance identifier
+     * @returns Heartbeat data or null if not found
+     */
+    getHeartbeatInfo(instanceId: string): Promise<{
+        instanceId: string;
+        timestamp: number;
+        pid: number;
+    } | null>;
+    /**
+     * Get all active instances (with heartbeat)
+     *
+     * @returns Array of instance IDs that are currently alive
+     */
+    getActiveInstances(): Promise<string[]>;
+    /**
+     * Get current instance ID
+     */
+    getInstanceId(): string;
+}

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

@@ -0,0 +1,222 @@
+"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 LockHeartbeatService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockHeartbeatService = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Lock heartbeat service
+ *
+ * Provides heartbeat mechanism for distributed lock instances.
+ * Each instance sends periodic heartbeats to Redis to indicate it's alive.
+ * Dead instances can be detected by checking if their heartbeat has expired.
+ *
+ * @example
+ * ```typescript
+ * constructor(private heartbeatService: LockHeartbeatService) {}
+ *
+ * async isInstanceAlive(instanceId: string): Promise<boolean> {
+ *   return this.heartbeatService.isInstanceAlive(instanceId);
+ * }
+ * ```
+ */
+let LockHeartbeatService = LockHeartbeatService_1 = class LockHeartbeatService {
+    constructor() {
+        this.logger = new common_1.Logger(LockHeartbeatService_1.name);
+        this.redis = null;
+        this.heartbeatTimer = null;
+        /**
+         * Heartbeat interval in milliseconds
+         * @default 10000 (10 seconds)
+         */
+        this.heartbeatInterval = 10000;
+        /**
+         * Heartbeat TTL in seconds (3x interval for safety)
+         * @default 30 (30 seconds)
+         */
+        this.heartbeatTtl = 30;
+        this.instanceId = this.getInstanceId();
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                this.logger.warn('LockHeartbeatService initialized but no Redis client provided. Heartbeat functionality will not work.');
+                return;
+            }
+            // Send initial heartbeat
+            yield this.sendHeartbeat();
+            // Start periodic heartbeat
+            this.heartbeatTimer = setInterval(() => {
+                this.sendHeartbeat().catch((error) => {
+                    this.logger.error('Failed to send heartbeat:', error);
+                });
+            }, this.heartbeatInterval);
+            this.logger.log(`Heartbeat started for instance: ${this.instanceId}`);
+        });
+    }
+    onModuleDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Stop heartbeat timer
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            // Remove heartbeat record
+            yield this.removeHeartbeat();
+            this.logger.log('Heartbeat stopped');
+        });
+    }
+    /**
+     * Set Redis client (required for dependency injection)
+     */
+    setRedisClient(redis) {
+        this.redis = redis;
+        this.logger.log('Redis client set for LockHeartbeatService');
+    }
+    /**
+     * Send heartbeat to Redis
+     * Stores instance information with TTL
+     */
+    sendHeartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return;
+            }
+            const key = `heartbeat:${this.instanceId}`;
+            const data = {
+                instanceId: this.instanceId,
+                timestamp: Date.now(),
+                pid: process.pid,
+            };
+            try {
+                // Set heartbeat with TTL (3x interval for safety)
+                yield this.redis.setex(key, this.heartbeatTtl, JSON.stringify(data));
+            }
+            catch (error) {
+                this.logger.error('Error sending heartbeat:', error);
+            }
+        });
+    }
+    /**
+     * Remove heartbeat record from Redis
+     */
+    removeHeartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return;
+            }
+            const key = `heartbeat:${this.instanceId}`;
+            try {
+                yield this.redis.del(key);
+            }
+            catch (error) {
+                this.logger.error('Error removing heartbeat:', error);
+            }
+        });
+    }
+    /**
+     * Check if an instance is alive by checking its heartbeat
+     *
+     * @param instanceId - Instance identifier to check
+     * @returns True if instance is alive (heartbeat exists), false otherwise
+     */
+    isInstanceAlive(instanceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                this.logger.warn('Redis client not available, cannot check instance status');
+                return false;
+            }
+            const key = `heartbeat:${instanceId}`;
+            try {
+                const exists = yield this.redis.exists(key);
+                return exists === 1;
+            }
+            catch (error) {
+                this.logger.error(`Error checking instance ${instanceId} status:`, error);
+                return false;
+            }
+        });
+    }
+    /**
+     * Get heartbeat information for an instance
+     *
+     * @param instanceId - Instance identifier
+     * @returns Heartbeat data or null if not found
+     */
+    getHeartbeatInfo(instanceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return null;
+            }
+            const key = `heartbeat:${instanceId}`;
+            try {
+                const data = yield this.redis.get(key);
+                if (!data) {
+                    return null;
+                }
+                return JSON.parse(data);
+            }
+            catch (error) {
+                this.logger.error(`Error getting heartbeat info for ${instanceId}:`, error);
+                return null;
+            }
+        });
+    }
+    /**
+     * Get all active instances (with heartbeat)
+     *
+     * @returns Array of instance IDs that are currently alive
+     */
+    getActiveInstances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redis) {
+                return [];
+            }
+            try {
+                const keys = yield this.redis.keys('heartbeat:*');
+                return keys.map((key) => key.replace('heartbeat:', ''));
+            }
+            catch (error) {
+                this.logger.error('Error getting active instances:', error);
+                return [];
+            }
+        });
+    }
+    /**
+     * Get current instance ID
+     */
+    getInstanceId() {
+        // 1. Kubernetes Pod name
+        if (process.env.HOSTNAME) {
+            return process.env.HOSTNAME;
+        }
+        // 2. Custom instance ID
+        if (process.env.INSTANCE_ID) {
+            return process.env.INSTANCE_ID;
+        }
+        // 3. Generate unique ID
+        return `instance-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+};
+exports.LockHeartbeatService = LockHeartbeatService;
+exports.LockHeartbeatService = LockHeartbeatService = LockHeartbeatService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], LockHeartbeatService);