@burdenoff/be-sdk 2026.716.1 → 2026.716.2

package/dist/{chunk-CAI5GJJ6.js → chunk-CJCO3OWF.js}

@@ -439,8 +439,31 @@ var MemoryCacheProvider = class {
 };
 
 // src/cache/implementations/valkey/ValkeyGlideProvider.ts
-var CONNECT_RETRY_COOLDOWN_MS = 8e3;
-var CONNECT_ATTEMPT_TIMEOUT_MS = 2500;
+function readPositiveIntEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+__name(readPositiveIntEnv, "readPositiveIntEnv");
+var CONNECT_RETRY_COOLDOWN_MS = readPositiveIntEnv("VALKEY_CONNECT_RETRY_COOLDOWN_MS", 8e3);
+var CONNECT_ATTEMPT_TIMEOUT_MS = readPositiveIntEnv("VALKEY_CONNECT_ATTEMPT_TIMEOUT_MS", 4500);
+var CONNECTION_TIMEOUT_MS = readPositiveIntEnv("VALKEY_CONNECTION_TIMEOUT_MS", 4e3);
+var REQUEST_TIMEOUT_MS = readPositiveIntEnv("VALKEY_REQUEST_TIMEOUT_MS", 2e3);
+var MAX_CONSECUTIVE_OP_FAILURES = readPositiveIntEnv("VALKEY_MAX_CONSECUTIVE_OP_FAILURES", 3);
+function isConnectionLevelError(error) {
+  if (!(error instanceof Error)) return false;
+  const name = error.name;
+  if (name === "ClosingError" || name === "ConnectionError" || name === "TimeoutError") {
+    return true;
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("cooldown") || message.includes("budget")) {
+    return false;
+  }
+  return /connection|closing|closed|timed out|timeout|disconnect|socket|econnreset|broken pipe|not connected/.test(message);
+}
+__name(isConnectionLevelError, "isConnectionLevelError");
 var ValkeyGlideProvider = class {
   static {
     __name(this, "ValkeyGlideProvider");
@@ -457,12 +480,23 @@ var ValkeyGlideProvider = class {
   // Timestamp (ms) of the last failed connect attempt; 0 when the last attempt
   // succeeded. Drives the connect circuit-breaker in ensureConnected().
   lastConnectFailureAt = 0;
+  // Count of consecutive connection-level operation failures on an already-
+  // "connected" client, tracked across every command (any success resets it,
+  // any op's connection error increments it). When it reaches
+  // MAX_CONSECUTIVE_OP_FAILURES the wedged client is torn down so the next op
+  // rebuilds a fresh one instead of reusing a socket GLIDE's internal reconnect
+  // cannot recover. See noteOpError().
+  consecutiveOpFailures = 0;
   config;
   // Mutable: when a URL like `…/4` lands on Azure Managed Redis we fold the
   // DB index into the namespace at connect time to preserve per-service
-  // isolation on the forced-DB-0 connection. Not const, but only ever
-  // appended to once during connect().
+  // isolation on the forced-DB-0 connection. Appended exactly once across the
+  // instance's lifetime, guarded by `dbNamespaceSuffixApplied` (connect() can
+  // run repeatedly now that the self-heal path rebuilds the client).
   namespace;
+  // Set once the Azure DB-index `:db{N}` suffix has been folded into
+  // `namespace`, so reconnects do not re-append it.
+  dbNamespaceSuffixApplied = false;
   defaultTTL;
   enableLogging;
   // Statistics
@@ -616,8 +650,11 @@ var ValkeyGlideProvider = class {
           databaseFromUrl = parseInt(dbMatch[1], 10);
           const isAzureManagedRedis = /\.redis\.azure\.net$/i.test(host);
           if (isAzureManagedRedis && databaseFromUrl > 0) {
-            logger.warn(`[ValkeyGlideProvider] Azure Managed Redis only supports DB 0; ignoring /${String(databaseFromUrl)} in URL and folding it into namespace.`);
-            this.namespace = `${this.namespace}:db${String(databaseFromUrl)}`;
+            if (!this.dbNamespaceSuffixApplied) {
+              logger.warn(`[ValkeyGlideProvider] Azure Managed Redis only supports DB 0; ignoring /${String(databaseFromUrl)} in URL and folding it into namespace.`);
+              this.namespace = `${this.namespace}:db${String(databaseFromUrl)}`;
+              this.dbNamespaceSuffixApplied = true;
+            }
             databaseFromUrl = 0;
           }
         }
@@ -637,7 +674,10 @@ var ValkeyGlideProvider = class {
         } : void 0,
         clientName: this.config.name || `valkey-glide-${this.namespace}`,
         databaseId: this.config.db ?? databaseFromUrl,
-        connectionTimeout: this.config.connectionTimeout,
+        // Bound every command (incl. reconnection during the request) so a
+        // dropped/reconnecting socket fails fast to a cache miss instead of
+        // hanging the calling resolver. THE fix for the "glide hangs" failure.
+        requestTimeout: REQUEST_TIMEOUT_MS,
         // Honour the configured reconnect tuning. Previously
         // maxReconnectAttempts/reconnectTimeWait were read into config but never
         // handed to GLIDE, so the client used its built-in default backoff. A
@@ -648,7 +688,13 @@ var ValkeyGlideProvider = class {
           factor: this.config.reconnectTimeWait ?? 1e3,
           exponentBase: 2
         },
-        readFrom: "primary"
+        readFrom: "primary",
+        // GLIDE 2.x reads connectionTimeout from advancedConfiguration; a
+        // top-level value is ignored. Bounds the initial connect and every
+        // internal reconnect.
+        advancedConfiguration: {
+          connectionTimeout: this.config.connectionTimeout ?? CONNECTION_TIMEOUT_MS
+        }
       };
       if (this.config.cluster === true) {
         if (!GlideClusterClient) {
@@ -660,6 +706,7 @@ var ValkeyGlideProvider = class {
             duration_in_sec: 30
           },
           advancedConfiguration: {
+            ...baseClientConfig.advancedConfiguration,
             refreshTopologyFromInitialNodes: true
           }
         }));
@@ -677,6 +724,7 @@ var ValkeyGlideProvider = class {
               duration_in_sec: 30
             },
             advancedConfiguration: {
+              ...baseClientConfig.advancedConfiguration,
               refreshTopologyFromInitialNodes: true
             }
           }));
@@ -688,6 +736,7 @@ var ValkeyGlideProvider = class {
       }
       this.connected = true;
       this.lastConnectFailureAt = 0;
+      this.consecutiveOpFailures = 0;
       if (this.enableLogging) {
         logger.info(`[ValkeyGlideProvider:${this.namespace}] Connected to Valkey`, {
           host,
@@ -718,6 +767,47 @@ var ValkeyGlideProvider = class {
     }
   }
   /**
+  * A command completed — the connection is proven alive, so clear the
+  * teardown counter. Called from every command's success path.
+  */
+  recordOpSuccess() {
+    if (this.consecutiveOpFailures !== 0) {
+      this.consecutiveOpFailures = 0;
+    }
+  }
+  /**
+  * Record an operation error and, if the client looks wedged (enough
+  * consecutive connection-level failures), tear it down so the next op builds a
+  * fresh one. Non-connection errors (bad command, serialization) are ignored so
+  * they never trip the teardown.
+  */
+  noteOpError(error) {
+    if (!isConnectionLevelError(error)) {
+      return;
+    }
+    this.consecutiveOpFailures += 1;
+    if (this.consecutiveOpFailures >= MAX_CONSECUTIVE_OP_FAILURES) {
+      this.resetClientForReconnect();
+    }
+  }
+  /**
+  * Drop the current client so the next ensureConnected() creates a new one.
+  * Arms the connect circuit-breaker so ops fast-fail (cache miss) during the
+  * cooldown rather than racing a fresh connect on every call, and closes the
+  * dead client in the background so its socket is not leaked.
+  */
+  resetClientForReconnect() {
+    const dead = this.client;
+    this.client = null;
+    this.connected = false;
+    this.consecutiveOpFailures = 0;
+    this.lastConnectFailureAt = Date.now();
+    logger.warn(`[ValkeyGlideProvider:${this.namespace}] Tearing down wedged client after ${String(MAX_CONSECUTIVE_OP_FAILURES)} consecutive connection failures; rebuilding on next op`);
+    if (dead) {
+      void dead.close().catch(() => void 0);
+    }
+  }
+  /**
   * Check if connected
   */
   isConnected() {
@@ -776,6 +866,7 @@ var ValkeyGlideProvider = class {
       const memoryMatch = memoryRegex.exec(info);
       const memoryUsed = memoryMatch && memoryMatch[1] ? parseInt(memoryMatch[1], 10) : void 0;
       const keyCount = await client.dbsize();
+      this.recordOpSuccess();
       return {
         hits: this.stats.hits,
         misses: this.stats.misses,
@@ -790,6 +881,7 @@ var ValkeyGlideProvider = class {
         }
       };
     } catch (error) {
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Failed to get statistics:`, error);
       return {
         hits: this.stats.hits,
@@ -818,6 +910,7 @@ var ValkeyGlideProvider = class {
       const client = await this.ensureConnected();
       const cacheKey = this.buildKey(key);
       const value = await client.get(cacheKey);
+      this.recordOpSuccess();
       if (value === null) {
         this.stats.misses++;
         if (this.enableLogging) {
@@ -837,6 +930,7 @@ var ValkeyGlideProvider = class {
       return entry.data;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting cache key:`, error);
       return null;
     }
@@ -861,6 +955,7 @@ var ValkeyGlideProvider = class {
           count: ttlSeconds
         }
       });
+      this.recordOpSuccess();
       this.stats.sets++;
       if (this.enableLogging) {
         logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache set`, {
@@ -871,6 +966,7 @@ var ValkeyGlideProvider = class {
       return true;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error setting cache key:`, error);
       return false;
     }
@@ -885,6 +981,7 @@ var ValkeyGlideProvider = class {
       const result = await client.del([
         cacheKey
       ]);
+      this.recordOpSuccess();
       this.stats.deletes++;
       if (this.enableLogging) {
         logger.debug(`[ValkeyGlideProvider:${this.namespace}] Cache delete`, {
@@ -895,6 +992,7 @@ var ValkeyGlideProvider = class {
       return result > 0;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error deleting cache key:`, error);
       return false;
     }
@@ -909,9 +1007,11 @@ var ValkeyGlideProvider = class {
       const exists = await client.exists([
         cacheKey
       ]);
+      this.recordOpSuccess();
       return exists === 1;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error checking cache key:`, error);
       return false;
     }
@@ -923,9 +1023,12 @@ var ValkeyGlideProvider = class {
     try {
       const client = await this.ensureConnected();
       const cacheKey = this.buildKey(key);
-      return await client.ttl(cacheKey);
+      const result = await client.ttl(cacheKey);
+      this.recordOpSuccess();
+      return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting TTL:`, error);
       return -2;
     }
@@ -937,9 +1040,12 @@ var ValkeyGlideProvider = class {
     try {
       const client = await this.ensureConnected();
       const cacheKey = this.buildKey(key);
-      return await client.expire(cacheKey, ttl);
+      const result = await client.expire(cacheKey, ttl);
+      this.recordOpSuccess();
+      return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error setting expiration:`, error);
       return false;
     }
@@ -956,6 +1062,7 @@ var ValkeyGlideProvider = class {
       const client = await this.ensureConnected();
       const cacheKeys = keys.map((key) => this.buildKey(key));
       const values = await client.mget(cacheKeys);
+      this.recordOpSuccess();
       for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         if (!key) continue;
@@ -976,6 +1083,7 @@ var ValkeyGlideProvider = class {
       return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch get:`, error);
       return result;
     }
@@ -1002,6 +1110,7 @@ var ValkeyGlideProvider = class {
         keyValuePairs[cacheKey] = JSON.stringify(entry);
       }
       await client.mset(keyValuePairs);
+      this.recordOpSuccess();
       for (const cacheKey of Object.keys(keyValuePairs)) {
         await client.expire(cacheKey, ttlSeconds);
       }
@@ -1015,6 +1124,7 @@ var ValkeyGlideProvider = class {
       return true;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch set:`, error);
       return false;
     }
@@ -1030,6 +1140,7 @@ var ValkeyGlideProvider = class {
       const client = await this.ensureConnected();
       const cacheKeys = keys.map((key) => this.buildKey(key));
       const result = await client.del(cacheKeys);
+      this.recordOpSuccess();
       this.stats.deletes += result;
       if (this.enableLogging) {
         logger.debug(`[ValkeyGlideProvider:${this.namespace}] Batch delete`, {
@@ -1040,6 +1151,7 @@ var ValkeyGlideProvider = class {
       return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error in batch delete:`, error);
       return 0;
     }
@@ -1052,6 +1164,7 @@ var ValkeyGlideProvider = class {
       const client = await this.ensureConnected();
       const searchPattern = this.buildKey(pattern);
       const keys = await this.getKeys(searchPattern);
+      this.recordOpSuccess();
       if (keys.length === 0) {
         return 0;
       }
@@ -1065,6 +1178,7 @@ var ValkeyGlideProvider = class {
       return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error clearing pattern:`, error);
       return 0;
     }
@@ -1077,6 +1191,7 @@ var ValkeyGlideProvider = class {
       await this.ensureConnected();
       const searchPattern = this.buildKey(options.pattern);
       const keys = await this.getKeys(searchPattern);
+      this.recordOpSuccess();
       const prefix = `${this.namespace}:`;
       const cleanKeys = keys.map((key) => key.replace(prefix, ""));
       const limitedKeys = options.limit ? cleanKeys.slice(0, options.limit) : cleanKeys;
@@ -1087,6 +1202,7 @@ var ValkeyGlideProvider = class {
       };
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error getting keys:`, error);
       return {
         keys: [],
@@ -1103,6 +1219,7 @@ var ValkeyGlideProvider = class {
       const client = await this.ensureConnected();
       const pattern = this.buildKey("*");
       const keys = await this.getKeys(pattern);
+      this.recordOpSuccess();
       if (keys.length > 0) {
         await client.del(keys);
         if (this.enableLogging) {
@@ -1112,6 +1229,7 @@ var ValkeyGlideProvider = class {
       return true;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error clearing cache:`, error);
       return false;
     }
@@ -1123,9 +1241,12 @@ var ValkeyGlideProvider = class {
     try {
       const client = await this.ensureConnected();
       const cacheKey = this.buildKey(key);
-      return await client.incrBy(cacheKey, amount);
+      const result = await client.incrBy(cacheKey, amount);
+      this.recordOpSuccess();
+      return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error incrementing:`, error);
       throw error;
     }
@@ -1137,9 +1258,12 @@ var ValkeyGlideProvider = class {
     try {
       const client = await this.ensureConnected();
       const cacheKey = this.buildKey(key);
-      return await client.decrBy(cacheKey, amount);
+      const result = await client.decrBy(cacheKey, amount);
+      this.recordOpSuccess();
+      return result;
     } catch (error) {
       this.stats.errors++;
+      this.noteOpError(error);
       logger.error(`[ValkeyGlideProvider:${this.namespace}] Error decrementing:`, error);
       throw error;
     }
@@ -1475,5 +1599,5 @@ async function closeAllCaches() {
 __name(closeAllCaches, "closeAllCaches");
 
 export { CacheFactory, CacheProviderType, MemoryCacheProvider, ValkeyGlideProvider, cache_exports, closeAllCaches, createCache, getCache, getValkeyClient };
-//# sourceMappingURL=chunk-CAI5GJJ6.js.map
-//# sourceMappingURL=chunk-CAI5GJJ6.js.map
+//# sourceMappingURL=chunk-CJCO3OWF.js.map
+//# sourceMappingURL=chunk-CJCO3OWF.js.map