claude-flow-novice 2.15.3 → 2.15.5

package/dist/lib/distributed-lock.js

@@ -0,0 +1,451 @@
+/**
+ * Distributed Lock Manager - Enhanced v2
+ *
+ * Provides distributed locking mechanism for cross-database transactions using Redis.
+ * Prevents concurrent modifications and ensures data consistency.
+ *
+ * Enhanced Features (Phase 2, Task P2-2.2):
+ * - Mandatory TTL enforcement with automatic expiration
+ * - Lock renewal mechanism for long-running operations
+ * - Auto-renewal with configurable interval
+ * - Lock health monitoring and statistics
+ * - Deadlock detection support
+ * - Stale lock cleanup
+ * - Backward compatible with existing usage
+ *
+ * Part of Task 3.1 (enhanced in Task P2-2.2)
+ */ import { randomUUID } from 'crypto';
+import { createLogger } from './logging.js';
+import { generateCorrelationId } from './correlation.js';
+const logger = createLogger('distributed-lock');
+/**
+ * Enhanced Redis-backed distributed lock manager
+ */ export class DistributedLockManager {
+    redisClient;
+    activeLocks = new Map();
+    renewalTimers = new Map();
+    statistics = {
+        totalAcquisitions: 0,
+        totalReleases: 0,
+        currentlyHeld: 0,
+        totalRenewals: 0,
+        averageDuration: 0,
+        failedAcquisitions: 0
+    };
+    lockDurations = [];
+    constructor(redisClient){
+        this.redisClient = redisClient;
+        logger.info('Enhanced distributed lock manager initialized (v2)');
+    }
+    /**
+   * Acquire lock on a resource with TTL enforcement and optional auto-renewal
+   */ async acquireLock(options) {
+        // Validate TTL (REQUIRED in v2)
+        if (options.ttl === undefined || options.ttl === null) {
+            // Backward compatibility: use default 60s TTL
+            options.ttl = 60000;
+        }
+        if (options.ttl <= 0) {
+            throw new Error('TTL must be positive');
+        }
+        const opts = {
+            timeout: options.timeout ?? 10000,
+            transactionId: options.transactionId,
+            retryInterval: options.retryInterval ?? 100,
+            correlationId: options.correlationId ?? generateCorrelationId()
+        };
+        const lockKey = this.buildLockKey(options.key);
+        const lockId = randomUUID();
+        const startTime = Date.now();
+        logger.debug('Attempting lock acquisition', {
+            lockKey,
+            lockId,
+            ttl: options.ttl,
+            renewInterval: options.renewInterval,
+            transactionId: opts.transactionId,
+            timeout: opts.timeout,
+            correlationId: opts.correlationId
+        });
+        // Try to acquire lock with timeout
+        while(Date.now() - startTime < opts.timeout){
+            const acquired = await this.tryAcquire(lockKey, lockId, options, opts);
+            if (acquired) {
+                const lock = {
+                    id: lockId,
+                    key: options.key,
+                    acquiredAt: new Date(),
+                    transactionId: opts.transactionId,
+                    ttl: options.ttl,
+                    renewInterval: options.renewInterval,
+                    correlationId: opts.correlationId
+                };
+                this.activeLocks.set(lockId, lock);
+                this.statistics.totalAcquisitions++;
+                this.statistics.currentlyHeld++;
+                // Start auto-renewal if configured
+                if (options.renewInterval) {
+                    this.startAutoRenewal(lock);
+                }
+                logger.info('Lock acquired successfully', {
+                    lockId,
+                    lockKey,
+                    ttl: options.ttl,
+                    renewInterval: options.renewInterval,
+                    transactionId: opts.transactionId,
+                    duration: Date.now() - startTime
+                });
+                return lock;
+            }
+            // Wait before retry
+            await this.sleep(opts.retryInterval);
+        }
+        // Timeout reached
+        const currentHolder = await this.getLockInfo(options.key);
+        this.statistics.failedAcquisitions++;
+        logger.warn('Lock acquisition timeout', {
+            lockKey,
+            lockId,
+            timeout: opts.timeout,
+            currentHolder,
+            correlationId: opts.correlationId
+        });
+        throw new LockAcquisitionError(`Failed to acquire lock on ${lockKey} within ${opts.timeout}ms`, lockKey, currentHolder);
+    }
+    /**
+   * Try to acquire lock atomically (single attempt)
+   */ async tryAcquire(lockKey, lockId, options, opts) {
+        try {
+            const now = new Date();
+            const metadata = {
+                lockId,
+                transactionId: opts.transactionId,
+                processId: process.pid,
+                acquiredAt: now.toISOString(),
+                expiresAt: new Date(now.getTime() + options.ttl).toISOString(),
+                correlationId: opts.correlationId
+            };
+            // Use Redis SET NX (set if not exists) with TTL (PX = milliseconds)
+            // This is atomic and prevents race conditions
+            const result = await this.redisClient.set(lockKey, JSON.stringify(metadata), 'PX', options.ttl, 'NX' // only set if not exists
+            );
+            return result === 'OK';
+        } catch (err) {
+            logger.error('Error during lock acquisition attempt', err, {
+                lockKey,
+                lockId
+            });
+            return false;
+        }
+    }
+    /**
+   * Renew lock TTL (extends expiration time)
+   */ async renewLock(lockId, ttl) {
+        const lock = this.activeLocks.get(lockId);
+        if (!lock) {
+            throw new LockOwnershipError(`Cannot renew lock ${lockId}: lock not found in active locks`, lockId, 'unknown');
+        }
+        const lockKey = this.buildLockKey(lock.key);
+        try {
+            // Get current lock metadata
+            const metadata = await this.getLockInfo(lock.key);
+            if (!metadata) {
+                throw new Error('Lock has expired or been released');
+            }
+            if (metadata.lockId !== lockId) {
+                throw new LockOwnershipError(`Cannot renew lock ${lockKey}: ownership mismatch`, lockId, metadata.lockId);
+            }
+            // Update expiration time
+            const now = new Date();
+            metadata.expiresAt = new Date(now.getTime() + ttl).toISOString();
+            metadata.lastRenewedAt = now.toISOString();
+            // Update Redis with new TTL
+            await this.redisClient.set(lockKey, JSON.stringify(metadata), 'PX', ttl);
+            // Update local lock object
+            lock.ttl = ttl;
+            this.statistics.totalRenewals++;
+            logger.debug('Lock renewed successfully', {
+                lockId,
+                lockKey,
+                newTtl: ttl
+            });
+        } catch (err) {
+            logger.error('Error renewing lock', err, {
+                lockId,
+                lockKey
+            });
+            throw err;
+        }
+    }
+    /**
+   * Start auto-renewal for a lock
+   */ startAutoRenewal(lock) {
+        if (!lock.renewInterval) {
+            return;
+        }
+        const timer = setInterval(async ()=>{
+            try {
+                await this.renewLock(lock.id, lock.ttl);
+                logger.debug('Auto-renewal completed', {
+                    lockId: lock.id,
+                    key: lock.key
+                });
+            } catch (err) {
+                logger.error('Auto-renewal failed', err, {
+                    lockId: lock.id,
+                    key: lock.key
+                });
+                // Stop renewal on failure
+                this.stopAutoRenewal(lock.id);
+            }
+        }, lock.renewInterval);
+        this.renewalTimers.set(lock.id, timer);
+        logger.debug('Auto-renewal started', {
+            lockId: lock.id,
+            key: lock.key,
+            interval: lock.renewInterval
+        });
+    }
+    /**
+   * Stop auto-renewal for a lock
+   */ stopAutoRenewal(lockId) {
+        const timer = this.renewalTimers.get(lockId);
+        if (timer) {
+            clearInterval(timer);
+            this.renewalTimers.delete(lockId);
+            logger.debug('Auto-renewal stopped', {
+                lockId
+            });
+        }
+    }
+    /**
+   * Release a lock manually
+   */ async releaseLock(lockId) {
+        const lock = this.activeLocks.get(lockId);
+        if (!lock) {
+            logger.warn('Lock not found in active locks', {
+                lockId
+            });
+            return;
+        }
+        const lockKey = this.buildLockKey(lock.key);
+        logger.debug('Releasing lock', {
+            lockId,
+            lockKey,
+            transactionId: lock.transactionId
+        });
+        try {
+            // Stop auto-renewal if active
+            this.stopAutoRenewal(lockId);
+            // Verify we own the lock before releasing
+            const metadata = await this.getLockInfo(lock.key);
+            if (!metadata) {
+                logger.warn('Lock already released or expired', {
+                    lockId,
+                    lockKey
+                });
+                this.activeLocks.delete(lockId);
+                this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);
+                return;
+            }
+            if (metadata.lockId !== lockId) {
+                logger.error('Lock ownership mismatch', new Error('Lock ownership mismatch'), {
+                    expectedLockId: lockId,
+                    actualLockId: metadata.lockId,
+                    lockKey
+                });
+                throw new LockOwnershipError(`Cannot release lock ${lockKey}: ownership mismatch`, lockId, metadata.lockId);
+            }
+            // Delete lock from Redis
+            await this.redisClient.del(lockKey);
+            // Track duration for statistics
+            const duration = Date.now() - lock.acquiredAt.getTime();
+            this.lockDurations.push(duration);
+            // Keep only last 100 durations for average calculation
+            if (this.lockDurations.length > 100) {
+                this.lockDurations.shift();
+            }
+            // Update statistics
+            this.statistics.totalReleases++;
+            this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);
+            this.statistics.averageDuration = this.calculateAverageDuration();
+            this.activeLocks.delete(lockId);
+            logger.info('Lock released successfully', {
+                lockId,
+                lockKey,
+                duration,
+                transactionId: lock.transactionId
+            });
+        } catch (err) {
+            logger.error('Error releasing lock', err, {
+                lockId,
+                lockKey
+            });
+            throw err;
+        }
+    }
+    /**
+   * Check if a resource is currently locked
+   */ async isLocked(key) {
+        const lockKey = this.buildLockKey(key);
+        try {
+            const exists = await this.redisClient.exists(lockKey);
+            return exists === 1;
+        } catch (err) {
+            logger.error('Error checking lock status', err, {
+                lockKey
+            });
+            return false; // Assume unlocked on error (fail-safe)
+        }
+    }
+    /**
+   * Get lock metadata for a resource
+   */ async getLockInfo(key) {
+        const lockKey = this.buildLockKey(key);
+        try {
+            const data = await this.redisClient.get(lockKey);
+            if (!data) {
+                return null;
+            }
+            const metadata = JSON.parse(data);
+            return metadata;
+        } catch (err) {
+            logger.error('Error retrieving lock info', err, {
+                lockKey
+            });
+            return null;
+        }
+    }
+    /**
+   * Force release of a lock (admin operation - use with caution)
+   */ async forceRelease(key) {
+        const lockKey = this.buildLockKey(key);
+        logger.warn('Force releasing lock', {
+            lockKey
+        });
+        try {
+            await this.redisClient.del(lockKey);
+            // Clean up from active locks if present
+            for (const [id, lock] of Array.from(this.activeLocks.entries())){
+                if (lock.key === key) {
+                    this.stopAutoRenewal(id);
+                    this.activeLocks.delete(id);
+                    this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);
+                }
+            }
+            logger.info('Lock force released', {
+                lockKey
+            });
+        } catch (err) {
+            logger.error('Error force releasing lock', err, {
+                lockKey
+            });
+            throw err;
+        }
+    }
+    /**
+   * Get all active locks managed by this instance
+   */ getActiveLocks() {
+        return Array.from(this.activeLocks.values());
+    }
+    /**
+   * Get lock statistics
+   */ getStatistics() {
+        return {
+            ...this.statistics
+        };
+    }
+    /**
+   * Clean up expired locks from tracking
+   */ cleanupExpiredLocks() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [id, lock] of Array.from(this.activeLocks.entries())){
+            const expiresAt = lock.acquiredAt.getTime() + lock.ttl;
+            if (now > expiresAt) {
+                this.stopAutoRenewal(id);
+                this.activeLocks.delete(id);
+                this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logger.debug('Cleaned up expired locks from tracking', {
+                count: cleaned
+            });
+        }
+        return cleaned;
+    }
+    /**
+   * Release all active locks (cleanup on shutdown)
+   */ async releaseAll() {
+        logger.info('Releasing all active locks', {
+            count: this.activeLocks.size
+        });
+        const releases = Array.from(this.activeLocks.values()).map((lock)=>this.releaseLock(lock.id).catch((err)=>{
+                logger.error('Error releasing lock during cleanup', err, {
+                    lockId: lock.id
+                });
+            }));
+        await Promise.all(releases);
+        logger.info('All locks released');
+    }
+    /**
+   * Build Redis key for lock resource
+   */ buildLockKey(key) {
+        return `lock:${key}`;
+    }
+    /**
+   * Calculate average lock duration
+   */ calculateAverageDuration() {
+        if (this.lockDurations.length === 0) {
+            return 0;
+        }
+        const sum = this.lockDurations.reduce((acc, dur)=>acc + dur, 0);
+        return Math.round(sum / this.lockDurations.length);
+    }
+    /**
+   * Sleep utility for retry intervals
+   */ sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+}
+/**
+ * Lock acquisition error
+ */ export class LockAcquisitionError extends Error {
+    lockKey;
+    currentHolder;
+    constructor(message, lockKey, currentHolder){
+        super(message), this.lockKey = lockKey, this.currentHolder = currentHolder;
+        this.name = 'LockAcquisitionError';
+    }
+}
+/**
+ * Lock ownership error
+ */ export class LockOwnershipError extends Error {
+    expectedLockId;
+    actualLockId;
+    constructor(message, expectedLockId, actualLockId){
+        super(message), this.expectedLockId = expectedLockId, this.actualLockId = actualLockId;
+        this.name = 'LockOwnershipError';
+    }
+}
+/**
+ * Utility: Execute function with distributed lock
+ */ export async function withLock(lockManager, key, fn, options) {
+    const lock = await lockManager.acquireLock({
+        key,
+        ttl: options?.ttl ?? 60000,
+        ...options
+    });
+    try {
+        const result = await fn();
+        await lockManager.releaseLock(lock.id);
+        return result;
+    } catch (err) {
+        await lockManager.releaseLock(lock.id);
+        throw err;
+    }
+}
+export { DistributedLockManager as DistributedLock };
+
+//# sourceMappingURL=distributed-lock.js.map

package/dist/lib/distributed-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/distributed-lock.ts"],"sourcesContent":["/**\r\n * Distributed Lock Manager - Enhanced v2\r\n *\r\n * Provides distributed locking mechanism for cross-database transactions using Redis.\r\n * Prevents concurrent modifications and ensures data consistency.\r\n *\r\n * Enhanced Features (Phase 2, Task P2-2.2):\r\n * - Mandatory TTL enforcement with automatic expiration\r\n * - Lock renewal mechanism for long-running operations\r\n * - Auto-renewal with configurable interval\r\n * - Lock health monitoring and statistics\r\n * - Deadlock detection support\r\n * - Stale lock cleanup\r\n * - Backward compatible with existing usage\r\n *\r\n * Part of Task 3.1 (enhanced in Task P2-2.2)\r\n */\r\n\r\nimport { randomUUID } from 'crypto';\r\nimport { createLogger } from './logging.js';\r\nimport { generateCorrelationId } from './correlation.js';\r\n\r\nconst logger = createLogger('distributed-lock');\r\n\r\n/**\r\n * Lock acquisition options (enhanced)\r\n */\r\nexport interface LockOptions {\r\n  /** Lock resource key (required) */\r\n  key: string;\r\n  /** Auto-release TTL in milliseconds (REQUIRED in v2) */\r\n  ttl: number;\r\n  /** Lock acquisition timeout in milliseconds (default: 10000) */\r\n  timeout?: number;\r\n  /** Auto-renewal interval in milliseconds (optional, enables auto-renewal) */\r\n  renewInterval?: number;\r\n  /** Transaction ID to associate with lock */\r\n  transactionId?: string;\r\n  /** Retry interval for lock acquisition in milliseconds (default: 100) */\r\n  retryInterval?: number;\r\n  /** Correlation ID for tracking */\r\n  correlationId?: string;\r\n}\r\n\r\n/**\r\n * Lock instance (enhanced)\r\n */\r\nexport interface Lock {\r\n  /** Unique lock ID */\r\n  id: string;\r\n  /** Lock resource key */\r\n  key: string;\r\n  /** Lock acquisition timestamp */\r\n  acquiredAt: Date;\r\n  /** Associated transaction ID */\r\n  transactionId?: string;\r\n  /** Lock TTL in milliseconds */\r\n  ttl: number;\r\n  /** Auto-renewal interval (if enabled) */\r\n  renewInterval?: number;\r\n  /** Correlation ID */\r\n  correlationId: string;\r\n}\r\n\r\n/**\r\n * Lock metadata (stored in Redis)\r\n */\r\nexport interface LockMetadata {\r\n  /** Lock ID */\r\n  lockId: string;\r\n  /** Transaction ID */\r\n  transactionId?: string;\r\n  /** Process ID (for deadlock detection) */\r\n  processId: number;\r\n  /** Acquired timestamp (ISO string) */\r\n  acquiredAt: string;\r\n  /** Expiration timestamp (ISO string) */\r\n  expiresAt: string;\r\n  /** Last renewal timestamp (ISO string) */\r\n  lastRenewedAt?: string;\r\n  /** Correlation ID */\r\n  correlationId: string;\r\n}\r\n\r\n/**\r\n * Lock statistics\r\n */\r\nexport interface LockStatistics {\r\n  /** Total lock acquisitions */\r\n  totalAcquisitions: number;\r\n  /** Total lock releases */\r\n  totalReleases: number;\r\n  /** Currently held locks */\r\n  currentlyHeld: number;\r\n  /** Total renewals performed */\r\n  totalRenewals: number;\r\n  /** Average lock duration (ms) */\r\n  averageDuration: number;\r\n  /** Failed acquisition attempts */\r\n  failedAcquisitions: number;\r\n}\r\n\r\n/**\r\n * Enhanced Redis-backed distributed lock manager\r\n */\r\nexport class DistributedLockManager {\r\n  private redisClient: any;\r\n  private activeLocks: Map<string, Lock> = new Map();\r\n  private renewalTimers: Map<string, NodeJS.Timeout> = new Map();\r\n  private statistics: LockStatistics = {\r\n    totalAcquisitions: 0,\r\n    totalReleases: 0,\r\n    currentlyHeld: 0,\r\n    totalRenewals: 0,\r\n    averageDuration: 0,\r\n    failedAcquisitions: 0,\r\n  };\r\n  private lockDurations: number[] = [];\r\n\r\n  constructor(redisClient: any) {\r\n    this.redisClient = redisClient;\r\n    logger.info('Enhanced distributed lock manager initialized (v2)');\r\n  }\r\n\r\n  /**\r\n   * Acquire lock on a resource with TTL enforcement and optional auto-renewal\r\n   */\r\n  async acquireLock(options: LockOptions): Promise<Lock> {\r\n    // Validate TTL (REQUIRED in v2)\r\n    if (options.ttl === undefined || options.ttl === null) {\r\n      // Backward compatibility: use default 60s TTL\r\n      options.ttl = 60000;\r\n    }\r\n\r\n    if (options.ttl <= 0) {\r\n      throw new Error('TTL must be positive');\r\n    }\r\n\r\n    const opts = {\r\n      timeout: options.timeout ?? 10000,\r\n      transactionId: options.transactionId,\r\n      retryInterval: options.retryInterval ?? 100,\r\n      correlationId: options.correlationId ?? generateCorrelationId(),\r\n    };\r\n\r\n    const lockKey = this.buildLockKey(options.key);\r\n    const lockId = randomUUID();\r\n    const startTime = Date.now();\r\n\r\n    logger.debug('Attempting lock acquisition', {\r\n      lockKey,\r\n      lockId,\r\n      ttl: options.ttl,\r\n      renewInterval: options.renewInterval,\r\n      transactionId: opts.transactionId,\r\n      timeout: opts.timeout,\r\n      correlationId: opts.correlationId,\r\n    });\r\n\r\n    // Try to acquire lock with timeout\r\n    while (Date.now() - startTime < opts.timeout) {\r\n      const acquired = await this.tryAcquire(lockKey, lockId, options, opts);\r\n\r\n      if (acquired) {\r\n        const lock: Lock = {\r\n          id: lockId,\r\n          key: options.key,\r\n          acquiredAt: new Date(),\r\n          transactionId: opts.transactionId,\r\n          ttl: options.ttl,\r\n          renewInterval: options.renewInterval,\r\n          correlationId: opts.correlationId,\r\n        };\r\n\r\n        this.activeLocks.set(lockId, lock);\r\n        this.statistics.totalAcquisitions++;\r\n        this.statistics.currentlyHeld++;\r\n\r\n        // Start auto-renewal if configured\r\n        if (options.renewInterval) {\r\n          this.startAutoRenewal(lock);\r\n        }\r\n\r\n        logger.info('Lock acquired successfully', {\r\n          lockId,\r\n          lockKey,\r\n          ttl: options.ttl,\r\n          renewInterval: options.renewInterval,\r\n          transactionId: opts.transactionId,\r\n          duration: Date.now() - startTime,\r\n        });\r\n\r\n        return lock;\r\n      }\r\n\r\n      // Wait before retry\r\n      await this.sleep(opts.retryInterval);\r\n    }\r\n\r\n    // Timeout reached\r\n    const currentHolder = await this.getLockInfo(options.key);\r\n\r\n    this.statistics.failedAcquisitions++;\r\n\r\n    logger.warn('Lock acquisition timeout', {\r\n      lockKey,\r\n      lockId,\r\n      timeout: opts.timeout,\r\n      currentHolder,\r\n      correlationId: opts.correlationId,\r\n    });\r\n\r\n    throw new LockAcquisitionError(\r\n      `Failed to acquire lock on ${lockKey} within ${opts.timeout}ms`,\r\n      lockKey,\r\n      currentHolder\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Try to acquire lock atomically (single attempt)\r\n   */\r\n  private async tryAcquire(\r\n    lockKey: string,\r\n    lockId: string,\r\n    options: LockOptions,\r\n    opts: { transactionId?: string; correlationId: string }\r\n  ): Promise<boolean> {\r\n    try {\r\n      const now = new Date();\r\n      const metadata: LockMetadata = {\r\n        lockId,\r\n        transactionId: opts.transactionId,\r\n        processId: process.pid,\r\n        acquiredAt: now.toISOString(),\r\n        expiresAt: new Date(now.getTime() + options.ttl).toISOString(),\r\n        correlationId: opts.correlationId,\r\n      };\r\n\r\n      // Use Redis SET NX (set if not exists) with TTL (PX = milliseconds)\r\n      // This is atomic and prevents race conditions\r\n      const result = await this.redisClient.set(\r\n        lockKey,\r\n        JSON.stringify(metadata),\r\n        'PX', // milliseconds\r\n        options.ttl,\r\n        'NX' // only set if not exists\r\n      );\r\n\r\n      return result === 'OK';\r\n    } catch (err) {\r\n      logger.error('Error during lock acquisition attempt', err as Error, {\r\n        lockKey,\r\n        lockId,\r\n      });\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Renew lock TTL (extends expiration time)\r\n   */\r\n  async renewLock(lockId: string, ttl: number): Promise<void> {\r\n    const lock = this.activeLocks.get(lockId);\r\n\r\n    if (!lock) {\r\n      throw new LockOwnershipError(\r\n        `Cannot renew lock ${lockId}: lock not found in active locks`,\r\n        lockId,\r\n        'unknown'\r\n      );\r\n    }\r\n\r\n    const lockKey = this.buildLockKey(lock.key);\r\n\r\n    try {\r\n      // Get current lock metadata\r\n      const metadata = await this.getLockInfo(lock.key);\r\n\r\n      if (!metadata) {\r\n        throw new Error('Lock has expired or been released');\r\n      }\r\n\r\n      if (metadata.lockId !== lockId) {\r\n        throw new LockOwnershipError(\r\n          `Cannot renew lock ${lockKey}: ownership mismatch`,\r\n          lockId,\r\n          metadata.lockId\r\n        );\r\n      }\r\n\r\n      // Update expiration time\r\n      const now = new Date();\r\n      metadata.expiresAt = new Date(now.getTime() + ttl).toISOString();\r\n      metadata.lastRenewedAt = now.toISOString();\r\n\r\n      // Update Redis with new TTL\r\n      await this.redisClient.set(\r\n        lockKey,\r\n        JSON.stringify(metadata),\r\n        'PX',\r\n        ttl\r\n      );\r\n\r\n      // Update local lock object\r\n      lock.ttl = ttl;\r\n\r\n      this.statistics.totalRenewals++;\r\n\r\n      logger.debug('Lock renewed successfully', {\r\n        lockId,\r\n        lockKey,\r\n        newTtl: ttl,\r\n      });\r\n    } catch (err) {\r\n      logger.error('Error renewing lock', err as Error, {\r\n        lockId,\r\n        lockKey,\r\n      });\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start auto-renewal for a lock\r\n   */\r\n  private startAutoRenewal(lock: Lock): void {\r\n    if (!lock.renewInterval) {\r\n      return;\r\n    }\r\n\r\n    const timer = setInterval(async () => {\r\n      try {\r\n        await this.renewLock(lock.id, lock.ttl);\r\n        logger.debug('Auto-renewal completed', {\r\n          lockId: lock.id,\r\n          key: lock.key,\r\n        });\r\n      } catch (err) {\r\n        logger.error('Auto-renewal failed', err as Error, {\r\n          lockId: lock.id,\r\n          key: lock.key,\r\n        });\r\n        // Stop renewal on failure\r\n        this.stopAutoRenewal(lock.id);\r\n      }\r\n    }, lock.renewInterval);\r\n\r\n    this.renewalTimers.set(lock.id, timer);\r\n\r\n    logger.debug('Auto-renewal started', {\r\n      lockId: lock.id,\r\n      key: lock.key,\r\n      interval: lock.renewInterval,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Stop auto-renewal for a lock\r\n   */\r\n  private stopAutoRenewal(lockId: string): void {\r\n    const timer = this.renewalTimers.get(lockId);\r\n\r\n    if (timer) {\r\n      clearInterval(timer);\r\n      this.renewalTimers.delete(lockId);\r\n\r\n      logger.debug('Auto-renewal stopped', { lockId });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Release a lock manually\r\n   */\r\n  async releaseLock(lockId: string): Promise<void> {\r\n    const lock = this.activeLocks.get(lockId);\r\n\r\n    if (!lock) {\r\n      logger.warn('Lock not found in active locks', { lockId });\r\n      return;\r\n    }\r\n\r\n    const lockKey = this.buildLockKey(lock.key);\r\n\r\n    logger.debug('Releasing lock', {\r\n      lockId,\r\n      lockKey,\r\n      transactionId: lock.transactionId,\r\n    });\r\n\r\n    try {\r\n      // Stop auto-renewal if active\r\n      this.stopAutoRenewal(lockId);\r\n\r\n      // Verify we own the lock before releasing\r\n      const metadata = await this.getLockInfo(lock.key);\r\n\r\n      if (!metadata) {\r\n        logger.warn('Lock already released or expired', {\r\n          lockId,\r\n          lockKey,\r\n        });\r\n        this.activeLocks.delete(lockId);\r\n        this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);\r\n        return;\r\n      }\r\n\r\n      if (metadata.lockId !== lockId) {\r\n        logger.error('Lock ownership mismatch', new Error('Lock ownership mismatch'), {\r\n          expectedLockId: lockId,\r\n          actualLockId: metadata.lockId,\r\n          lockKey,\r\n        });\r\n        throw new LockOwnershipError(\r\n          `Cannot release lock ${lockKey}: ownership mismatch`,\r\n          lockId,\r\n          metadata.lockId\r\n        );\r\n      }\r\n\r\n      // Delete lock from Redis\r\n      await this.redisClient.del(lockKey);\r\n\r\n      // Track duration for statistics\r\n      const duration = Date.now() - lock.acquiredAt.getTime();\r\n      this.lockDurations.push(duration);\r\n\r\n      // Keep only last 100 durations for average calculation\r\n      if (this.lockDurations.length > 100) {\r\n        this.lockDurations.shift();\r\n      }\r\n\r\n      // Update statistics\r\n      this.statistics.totalReleases++;\r\n      this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);\r\n      this.statistics.averageDuration = this.calculateAverageDuration();\r\n\r\n      this.activeLocks.delete(lockId);\r\n\r\n      logger.info('Lock released successfully', {\r\n        lockId,\r\n        lockKey,\r\n        duration,\r\n        transactionId: lock.transactionId,\r\n      });\r\n    } catch (err) {\r\n      logger.error('Error releasing lock', err as Error, {\r\n        lockId,\r\n        lockKey,\r\n      });\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if a resource is currently locked\r\n   */\r\n  async isLocked(key: string): Promise<boolean> {\r\n    const lockKey = this.buildLockKey(key);\r\n\r\n    try {\r\n      const exists = await this.redisClient.exists(lockKey);\r\n      return exists === 1;\r\n    } catch (err) {\r\n      logger.error('Error checking lock status', err as Error, {\r\n        lockKey,\r\n      });\r\n      return false; // Assume unlocked on error (fail-safe)\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get lock metadata for a resource\r\n   */\r\n  async getLockInfo(key: string): Promise<LockMetadata | null> {\r\n    const lockKey = this.buildLockKey(key);\r\n\r\n    try {\r\n      const data = await this.redisClient.get(lockKey);\r\n\r\n      if (!data) {\r\n        return null;\r\n      }\r\n\r\n      const metadata: LockMetadata = JSON.parse(data);\r\n      return metadata;\r\n    } catch (err) {\r\n      logger.error('Error retrieving lock info', err as Error, {\r\n        lockKey,\r\n      });\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Force release of a lock (admin operation - use with caution)\r\n   */\r\n  async forceRelease(key: string): Promise<void> {\r\n    const lockKey = this.buildLockKey(key);\r\n\r\n    logger.warn('Force releasing lock', {\r\n      lockKey,\r\n    });\r\n\r\n    try {\r\n      await this.redisClient.del(lockKey);\r\n\r\n      // Clean up from active locks if present\r\n      for (const [id, lock] of Array.from(this.activeLocks.entries())) {\r\n        if (lock.key === key) {\r\n          this.stopAutoRenewal(id);\r\n          this.activeLocks.delete(id);\r\n          this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);\r\n        }\r\n      }\r\n\r\n      logger.info('Lock force released', {\r\n        lockKey,\r\n      });\r\n    } catch (err) {\r\n      logger.error('Error force releasing lock', err as Error, {\r\n        lockKey,\r\n      });\r\n      throw err;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all active locks managed by this instance\r\n   */\r\n  getActiveLocks(): Lock[] {\r\n    return Array.from(this.activeLocks.values());\r\n  }\r\n\r\n  /**\r\n   * Get lock statistics\r\n   */\r\n  getStatistics(): LockStatistics {\r\n    return { ...this.statistics };\r\n  }\r\n\r\n  /**\r\n   * Clean up expired locks from tracking\r\n   */\r\n  cleanupExpiredLocks(): number {\r\n    const now = Date.now();\r\n    let cleaned = 0;\r\n\r\n    for (const [id, lock] of Array.from(this.activeLocks.entries())) {\r\n      const expiresAt = lock.acquiredAt.getTime() + lock.ttl;\r\n\r\n      if (now > expiresAt) {\r\n        this.stopAutoRenewal(id);\r\n        this.activeLocks.delete(id);\r\n        this.statistics.currentlyHeld = Math.max(0, this.statistics.currentlyHeld - 1);\r\n        cleaned++;\r\n      }\r\n    }\r\n\r\n    if (cleaned > 0) {\r\n      logger.debug('Cleaned up expired locks from tracking', { count: cleaned });\r\n    }\r\n\r\n    return cleaned;\r\n  }\r\n\r\n  /**\r\n   * Release all active locks (cleanup on shutdown)\r\n   */\r\n  async releaseAll(): Promise<void> {\r\n    logger.info('Releasing all active locks', { count: this.activeLocks.size });\r\n\r\n    const releases = Array.from(this.activeLocks.values()).map(lock =>\r\n      this.releaseLock(lock.id).catch(err => {\r\n        logger.error('Error releasing lock during cleanup', err, {\r\n          lockId: lock.id,\r\n        });\r\n      })\r\n    );\r\n\r\n    await Promise.all(releases);\r\n\r\n    logger.info('All locks released');\r\n  }\r\n\r\n  /**\r\n   * Build Redis key for lock resource\r\n   */\r\n  private buildLockKey(key: string): string {\r\n    return `lock:${key}`;\r\n  }\r\n\r\n  /**\r\n   * Calculate average lock duration\r\n   */\r\n  private calculateAverageDuration(): number {\r\n    if (this.lockDurations.length === 0) {\r\n      return 0;\r\n    }\r\n\r\n    const sum = this.lockDurations.reduce((acc, dur) => acc + dur, 0);\r\n    return Math.round(sum / this.lockDurations.length);\r\n  }\r\n\r\n  /**\r\n   * Sleep utility for retry intervals\r\n   */\r\n  private sleep(ms: number): Promise<void> {\r\n    return new Promise(resolve => setTimeout(resolve, ms));\r\n  }\r\n}\r\n\r\n/**\r\n * Lock acquisition error\r\n */\r\nexport class LockAcquisitionError extends Error {\r\n  constructor(\r\n    message: string,\r\n    public lockKey: string,\r\n    public currentHolder?: LockMetadata | null\r\n  ) {\r\n    super(message);\r\n    this.name = 'LockAcquisitionError';\r\n  }\r\n}\r\n\r\n/**\r\n * Lock ownership error\r\n */\r\nexport class LockOwnershipError extends Error {\r\n  constructor(\r\n    message: string,\r\n    public expectedLockId: string,\r\n    public actualLockId: string\r\n  ) {\r\n    super(message);\r\n    this.name = 'LockOwnershipError';\r\n  }\r\n}\r\n\r\n/**\r\n * Utility: Execute function with distributed lock\r\n */\r\nexport async function withLock<T>(\r\n  lockManager: DistributedLockManager,\r\n  key: string,\r\n  fn: () => Promise<T>,\r\n  options?: Omit<LockOptions, 'key'>\r\n): Promise<T> {\r\n  const lock = await lockManager.acquireLock({\r\n    key,\r\n    ttl: options?.ttl ?? 60000,\r\n    ...options,\r\n  });\r\n\r\n  try {\r\n    const result = await fn();\r\n    await lockManager.releaseLock(lock.id);\r\n    return result;\r\n  } catch (err) {\r\n    await lockManager.releaseLock(lock.id);\r\n    throw err;\r\n  }\r\n}\r\n\r\n// Backward compatibility exports\r\nexport type { LockOptions, Lock, LockMetadata };\r\nexport { DistributedLockManager as DistributedLock };\r\n"],"names":["randomUUID","createLogger","generateCorrelationId","logger","DistributedLockManager","redisClient","activeLocks","Map","renewalTimers","statistics","totalAcquisitions","totalReleases","currentlyHeld","totalRenewals","averageDuration","failedAcquisitions","lockDurations","info","acquireLock","options","ttl","undefined","Error","opts","timeout","transactionId","retryInterval","correlationId","lockKey","buildLockKey","key","lockId","startTime","Date","now","debug","renewInterval","acquired","tryAcquire","lock","id","acquiredAt","set","startAutoRenewal","duration","sleep","currentHolder","getLockInfo","warn","LockAcquisitionError","metadata","processId","process","pid","toISOString","expiresAt","getTime","result","JSON","stringify","err","error","renewLock","get","LockOwnershipError","lastRenewedAt","newTtl","timer","setInterval","stopAutoRenewal","interval","clearInterval","delete","releaseLock","Math","max","expectedLockId","actualLockId","del","push","length","shift","calculateAverageDuration","isLocked","exists","data","parse","forceRelease","Array","from","entries","getActiveLocks","values","getStatistics","cleanupExpiredLocks","cleaned","count","releaseAll","size","releases","map","catch","Promise","all","sum","reduce","acc","dur","round","ms","resolve","setTimeout","message","name","withLock","lockManager","fn","DistributedLock"],"mappings":"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"}