@nest-omni/core 4.1.3-3 → 4.1.3-30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "4.1.3-3",
+  "version": "4.1.3-30",
   "description": "A comprehensive NestJS framework for building enterprise-grade applications with best practices",
   "main": "index.js",
   "types": "index.d.ts",
@@ -36,67 +36,72 @@
   "author": "Jinpy",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=18.0.0",
+    "node": ">=22.0.0",
     "npm": ">=9.0.0"
   },
   "devDependencies": {
     "@types/compression": "^1.8.1",
-    "@types/express": "^5.0.4",
+    "@types/express": "^5.0.6",
     "@types/express-session": "^1.18.2",
-    "@types/lodash": "^4.17.20",
-    "@types/node": "^24.9.1",
+    "@types/lodash": "^4.17.21",
+    "@types/node": "^25.0.3",
+    "@types/nodemailer": "^6.4.17",
+    "@types/sharp": "^0.32.0",
     "@types/sprintf-js": "^1.1.4",
     "@types/uuid": "^11.0.0",
+    "sqlite3": "^5.1.7",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@dataui/crud": "^5.3.4",
     "@dataui/crud-typeorm": "^5.3.4",
-    "@nestjs-cls/transactional": "^3.1.0",
-    "@nestjs-cls/transactional-adapter-typeorm": "^1.3.0",
+    "@nest-omni/transaction": "*",
     "@nestjs/bull": "^11.0.4",
-    "@nestjs/common": "^11.1.7",
+    "@nestjs/common": "^11.1.11",
     "@nestjs/config": "^4.0.2",
-    "@nestjs/core": "^11.1.7",
-    "@nestjs/platform-express": "^11.1.7",
-    "@nestjs/schedule": "^6.0.1",
-    "@nestjs/swagger": "^11.2.1",
+    "@nestjs/core": "^11.1.11",
+    "@nestjs/platform-express": "^11.1.11",
+    "@nestjs/schedule": "^6.1.0",
+    "@nestjs/swagger": "^11.2.4",
     "@nestjs/terminus": "^11.0.0",
     "@nestjs/typeorm": "^11.0.0",
-    "@sentry/nestjs": "^10.22.0",
-    "@sentry/profiling-node": "^10.22.0",
+    "@sentry/nestjs": "^10.32.1",
+    "@sentry/profiling-node": "^10.32.1",
     "@songkeys/nestjs-redis": "^11.0.0",
     "@songkeys/nestjs-redis-health": "^11.0.0",
-    "axios": "^1.12.2",
+    "axios": "^1.13.2",
     "axios-retry": "^4.5.0",
     "bcrypt": "^6.0.0",
-    "body-parser": "^2.2.0",
+    "body-parser": "^2.2.1",
     "bull": "^4.16.5",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.2",
+    "class-validator": "^0.14.3",
     "compression": "^1.8.1",
     "connect-redis": "^9.0.0",
     "dotenv": "^17.2.3",
-    "express": "^5.1.0",
+    "express": "^5.2.1",
     "express-session": "^1.18.2",
+    "fast-csv": "^5.0.5",
     "hygen": "^6.2.11",
-    "ioredis": "^5.8.2",
-    "libphonenumber-js": "^1.12.25",
+    "ioredis": "^5.9.0",
     "lodash": "^4.17.21",
-    "mime-types": "^3.0.1",
+    "mime-types": "^3.0.2",
     "moment": "^2.30.1",
-    "mysql2": "^3.15.3",
-    "nestjs-cls": "^6.0.1",
-    "nestjs-i18n": "^10.5.1",
-    "nestjs-pino": "^4.4.1",
+    "mysql2": "^3.16.0",
+    "nestjs-cls": "^6.2.0",
+    "nodemailer": "^6.9.16",
+    "nestjs-i18n": "^10.6.0",
+    "nestjs-pino": "^4.5.0",
+    "node-vault": "^0.10.9",
     "pino-http": "^11.0.0",
-    "pino-pretty": "^13.1.2",
+    "pino-pretty": "^13.1.3",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2",
     "source-map-support": "^0.5.21",
     "sprintf-js": "^1.1.3",
-    "typeorm": "^0.3.27",
+    "typeorm": "^0.3.28",
     "uuid": "^13.0.0",
-    "node-vault": "^0.10.9"
-  }
+    "xlsx": "git+https://git.sheetjs.com/sheetjs/sheetjs.git#v0.20.3"
+  },
+  "peerDependencies": {}
 }

package/providers/context.provider.d.ts

@@ -3,6 +3,7 @@ export declare class ContextProvider {
     private static readonly nameSpace;
     private static readonly authUserKey;
     private static readonly routerKey;
+    private static readonly sourceKey;
     private static readonly languageKey;
     private static readonly requestKey;
     static get<T>(key: string): import("nestjs-cls/dist/src/types/type-if-type.type").TypeIfUndefined<T, import("nestjs-cls").ClsStore, T>;
@@ -31,4 +32,12 @@ export declare class ContextProvider {
     static getRole(): string;
     static getAdmin(): boolean;
     static getTenantId(): string;
+    /**
+     * 设置请求来源（如业务主键ID等）
+     */
+    static setSource(source: string): void;
+    /**
+     * 获取请求来源
+     */
+    static getSource(): string | undefined;
 }

package/providers/context.provider.js

@@ -73,10 +73,23 @@ class ContextProvider {
     static getTenantId() {
         return ContextProvider.getAuthUserField('tenantId');
     }
+    /**
+     * 设置请求来源（如业务主键ID等）
+     */
+    static setSource(source) {
+        ContextProvider.set(ContextProvider.sourceKey, source);
+    }
+    /**
+     * 获取请求来源
+     */
+    static getSource() {
+        return ContextProvider.get(ContextProvider.sourceKey);
+    }
 }
 exports.ContextProvider = ContextProvider;
 ContextProvider.nameSpace = 'request';
 ContextProvider.authUserKey = 'user_key';
 ContextProvider.routerKey = 'router_key';
+ContextProvider.sourceKey = 'source_key';
 ContextProvider.languageKey = 'language_key';
 ContextProvider.requestKey = 'request_key';

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

@@ -0,0 +1,94 @@
+import { OnModuleInit, OnApplicationShutdown } from '@nestjs/common';
+import { RedisLockService } from './redis-lock.service';
+import { LockHeartbeatService } from './lock-heartbeat.service';
+/**
+ * Comprehensive lock cleanup service
+ *
+ * Provides safe and comprehensive lock cleanup mechanism for distributed environments.
+ * Combines instance-based precise cleanup with heartbeat-based dead instance detection.
+ *
+ * **Cleanup Strategy:**
+ * 1. **Immediate Precise Cleanup (0s):**
+ *    - Only cleans locks from the current instance
+ *    - Safe during rolling updates - won't affect other running instances
+ *
+ * 2. **Delayed Conservative Cleanup (60s):**
+ *    - Checks heartbeat of other instances
+ *    - Only cleans locks from dead instances (no heartbeat)
+ *    - Gives enough time for rolling updates to complete
+ *
+ * 3. **Graceful Shutdown Cleanup:**
+ *    - On SIGTERM/SIGINT, immediately cleans own locks
+ *    - Ensures locks are released before process exits
+ *    - Works with PM2 reload and Kubernetes rolling updates
+ *
+ * @example
+ * ```typescript
+ * // In your module
+ * @Module({
+ *   providers: [
+ *     RedisLockService,
+ *     LockHeartbeatService,
+ *     ComprehensiveLockCleanupService,
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class ComprehensiveLockCleanupService implements OnModuleInit, OnApplicationShutdown {
+    private readonly lockService;
+    private readonly heartbeatService;
+    private readonly logger;
+    private readonly instanceId;
+    /**
+     * Grace period before cleaning other instances' locks (milliseconds)
+     * @default 60000 (60 seconds)
+     */
+    private readonly gracePeriod;
+    constructor(lockService: RedisLockService, heartbeatService: LockHeartbeatService);
+    onModuleInit(): Promise<void>;
+    /**
+     * Clean up locks from the current instance
+     * Safe to run immediately - only affects locks created by this instance
+     */
+    private cleanupOwnLocks;
+    /**
+     * Clean up locks from dead instances
+     * Only runs after grace period to avoid cleaning locks during rolling updates
+     */
+    private cleanupDeadInstanceLocks;
+    /**
+     * Check if a lock belongs to the current instance
+     *
+     * @param lockValue - Lock value to check
+     * @returns True if lock belongs to current instance
+     */
+    private isOwnLock;
+    /**
+     * Extract instance ID from lock value
+     * Lock value format: instanceId:timestamp:random:pid
+     *
+     * @param lockValue - Lock value
+     * @returns Instance ID or null if cannot be extracted
+     */
+    private extractInstanceId;
+    /**
+     * Get instance identifier
+     */
+    private getInstanceId;
+    /**
+     * Manually trigger cleanup of all stale locks
+     * Use with caution - this will clean both own and dead instance locks
+     */
+    manualCleanup(): Promise<{
+        ownLocks: number;
+        deadLocks: number;
+    }>;
+    private cleanupOwnLocksCount;
+    private cleanupDeadInstanceLocksCount;
+    /**
+     * Cleanup own locks on application shutdown
+     * Called when receiving SIGTERM/SIGINT (graceful shutdown)
+     */
+    onApplicationShutdown(signal?: string): Promise<void>;
+}

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

@@ -0,0 +1,253 @@
+"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 ComprehensiveLockCleanupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComprehensiveLockCleanupService = void 0;
+const common_1 = require("@nestjs/common");
+const redis_lock_service_1 = require("./redis-lock.service");
+const lock_heartbeat_service_1 = require("./lock-heartbeat.service");
+/**
+ * Comprehensive lock cleanup service
+ *
+ * Provides safe and comprehensive lock cleanup mechanism for distributed environments.
+ * Combines instance-based precise cleanup with heartbeat-based dead instance detection.
+ *
+ * **Cleanup Strategy:**
+ * 1. **Immediate Precise Cleanup (0s):**
+ *    - Only cleans locks from the current instance
+ *    - Safe during rolling updates - won't affect other running instances
+ *
+ * 2. **Delayed Conservative Cleanup (60s):**
+ *    - Checks heartbeat of other instances
+ *    - Only cleans locks from dead instances (no heartbeat)
+ *    - Gives enough time for rolling updates to complete
+ *
+ * 3. **Graceful Shutdown Cleanup:**
+ *    - On SIGTERM/SIGINT, immediately cleans own locks
+ *    - Ensures locks are released before process exits
+ *    - Works with PM2 reload and Kubernetes rolling updates
+ *
+ * @example
+ * ```typescript
+ * // In your module
+ * @Module({
+ *   providers: [
+ *     RedisLockService,
+ *     LockHeartbeatService,
+ *     ComprehensiveLockCleanupService,
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+let ComprehensiveLockCleanupService = ComprehensiveLockCleanupService_1 = class ComprehensiveLockCleanupService {
+    constructor(lockService, heartbeatService) {
+        this.lockService = lockService;
+        this.heartbeatService = heartbeatService;
+        this.logger = new common_1.Logger(ComprehensiveLockCleanupService_1.name);
+        /**
+         * Grace period before cleaning other instances' locks (milliseconds)
+         * @default 60000 (60 seconds)
+         */
+        this.gracePeriod = 60000;
+        this.instanceId = this.getInstanceId();
+    }
+    onModuleInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Starting comprehensive lock cleanup...');
+            // Step 1: Immediate precise cleanup - only clean own instance's locks
+            yield this.cleanupOwnLocks();
+            // Step 2: Delayed cleanup - clean dead instances' locks after grace period
+            setTimeout(() => {
+                this.cleanupDeadInstanceLocks().catch((error) => {
+                    this.logger.error('Failed to cleanup dead instance locks:', error);
+                });
+            }, this.gracePeriod);
+        });
+    }
+    /**
+     * Clean up locks from the current instance
+     * Safe to run immediately - only affects locks created by this instance
+     */
+    cleanupOwnLocks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log(`Cleaning locks for this instance: ${this.instanceId}`);
+            try {
+                const allLocks = yield this.lockService.getActiveLocks('*', 'lock');
+                let deletedCount = 0;
+                for (const lock of allLocks) {
+                    if (this.isOwnLock(lock.value)) {
+                        this.logger.warn(`Found stale lock from this instance: ${lock.key}`);
+                        yield this.lockService.forceRelease(lock.key);
+                        deletedCount++;
+                    }
+                }
+                this.logger.log(`Cleaned up ${deletedCount} locks from this instance`);
+            }
+            catch (error) {
+                this.logger.error('Failed to cleanup own locks:', error);
+            }
+        });
+    }
+    /**
+     * Clean up locks from dead instances
+     * Only runs after grace period to avoid cleaning locks during rolling updates
+     */
+    cleanupDeadInstanceLocks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Cleaning locks from dead instances...');
+            try {
+                const allLocks = yield this.lockService.getActiveLocks('*', 'lock');
+                let deletedCount = 0;
+                for (const lock of allLocks) {
+                    // Skip own instance's locks
+                    if (this.isOwnLock(lock.value)) {
+                        continue;
+                    }
+                    // Extract instance ID from lock value
+                    const instanceId = this.extractInstanceId(lock.value);
+                    if (!instanceId) {
+                        // Cannot determine instance, skip (might be old format)
+                        continue;
+                    }
+                    // Check if instance is alive via heartbeat
+                    const isAlive = yield this.heartbeatService.isInstanceAlive(instanceId);
+                    if (!isAlive) {
+                        this.logger.warn(`Instance ${instanceId} is dead, removing lock: ${lock.key}`);
+                        yield this.lockService.forceRelease(lock.key);
+                        deletedCount++;
+                    }
+                }
+                this.logger.log(`Cleaned up ${deletedCount} locks from dead instances`);
+            }
+            catch (error) {
+                this.logger.error('Failed to cleanup dead instance locks:', error);
+            }
+        });
+    }
+    /**
+     * Check if a lock belongs to the current instance
+     *
+     * @param lockValue - Lock value to check
+     * @returns True if lock belongs to current instance
+     */
+    isOwnLock(lockValue) {
+        if (!lockValue) {
+            return false;
+        }
+        const instanceId = this.extractInstanceId(lockValue);
+        return instanceId === this.instanceId;
+    }
+    /**
+     * Extract instance ID from lock value
+     * Lock value format: instanceId:timestamp:random:pid
+     *
+     * @param lockValue - Lock value
+     * @returns Instance ID or null if cannot be extracted
+     */
+    extractInstanceId(lockValue) {
+        if (!lockValue) {
+            return null;
+        }
+        // New format: instanceId:timestamp:random:pid
+        const parts = lockValue.split(':');
+        return parts.length >= 1 ? parts[0] : null;
+    }
+    /**
+     * Get instance identifier
+     */
+    getInstanceId() {
+        return (process.env.HOSTNAME ||
+            process.env.INSTANCE_ID ||
+            `instance-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`);
+    }
+    /**
+     * Manually trigger cleanup of all stale locks
+     * Use with caution - this will clean both own and dead instance locks
+     */
+    manualCleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log('Manual cleanup triggered');
+            const ownLocksCount = yield this.cleanupOwnLocksCount();
+            const deadLocksCount = yield this.cleanupDeadInstanceLocksCount();
+            this.logger.log(`Manual cleanup completed: ${ownLocksCount} own locks, ${deadLocksCount} dead locks`);
+            return {
+                ownLocks: ownLocksCount,
+                deadLocks: deadLocksCount,
+            };
+        });
+    }
+    cleanupOwnLocksCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allLocks = yield this.lockService.getActiveLocks('*', 'lock');
+            let deletedCount = 0;
+            for (const lock of allLocks) {
+                if (this.isOwnLock(lock.value)) {
+                    yield this.lockService.forceRelease(lock.key);
+                    deletedCount++;
+                }
+            }
+            return deletedCount;
+        });
+    }
+    cleanupDeadInstanceLocksCount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allLocks = yield this.lockService.getActiveLocks('*', 'lock');
+            let deletedCount = 0;
+            for (const lock of allLocks) {
+                if (this.isOwnLock(lock.value)) {
+                    continue;
+                }
+                const instanceId = this.extractInstanceId(lock.value);
+                if (!instanceId) {
+                    continue;
+                }
+                const isAlive = yield this.heartbeatService.isInstanceAlive(instanceId);
+                if (!isAlive) {
+                    yield this.lockService.forceRelease(lock.key);
+                    deletedCount++;
+                }
+            }
+            return deletedCount;
+        });
+    }
+    /**
+     * Cleanup own locks on application shutdown
+     * Called when receiving SIGTERM/SIGINT (graceful shutdown)
+     */
+    onApplicationShutdown(signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.log(`Application shutting down (signal: ${signal}), cleaning own locks...`);
+            try {
+                const deletedCount = yield this.cleanupOwnLocksCount();
+                this.logger.log(`Graceful shutdown cleanup completed: cleaned ${deletedCount} lock(s) from this instance`);
+            }
+            catch (error) {
+                this.logger.error('Failed to cleanup own locks on shutdown:', error);
+            }
+        });
+    }
+};
+exports.ComprehensiveLockCleanupService = ComprehensiveLockCleanupService;
+exports.ComprehensiveLockCleanupService = ComprehensiveLockCleanupService = ComprehensiveLockCleanupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [redis_lock_service_1.RedisLockService,
+        lock_heartbeat_service_1.LockHeartbeatService])
+], ComprehensiveLockCleanupService);

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,6 +1,6 @@
 "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; } });
@@ -9,6 +9,10 @@ Object.defineProperty(exports, "REDIS_LOCK_SERVICE", { enumerable: true, get: fu
 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; } });

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

@@ -0,0 +1,80 @@
+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 5000 (5 seconds) - reduced for faster failure detection
+     */
+    private readonly heartbeatInterval;
+    /**
+     * Heartbeat TTL in seconds (3x interval for safety)
+     * @default 15 (15 seconds) - adjusted to match new interval
+     */
+    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)
+     *
+     * **Note**: Uses SCAN command to avoid blocking Redis in production.
+     *
+     * @returns Array of instance IDs that are currently alive
+     */
+    getActiveInstances(): Promise<string[]>;
+    /**
+     * Get current instance ID
+     */
+    getInstanceId(): string;
+}