@trieb.work/nextjs-turbo-redis-cache 1.14.1 → 1.15.1

package/dist/index.js

@@ -31,8 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   RedisStringsHandler: () => RedisStringsHandler,
+  bufferAndMapReplacer: () => bufferAndMapReplacer,
+  bufferAndMapReviver: () => bufferAndMapReviver,
   default: () => index_default,
   getRedisCacheComponentsHandler: () => getRedisCacheComponentsHandler,
+  jsonCacheValueSerializer: () => jsonCacheValueSerializer,
   redisCacheHandler: () => redisCacheHandler
 });
 module.exports = __toCommonJS(index_exports);
@@ -65,6 +68,7 @@ function debugVerbose(color, ...args) {
 var SYNC_CHANNEL_SUFFIX = ":sync-channel:";
 var SyncedMap = class {
   constructor(options) {
+    this.isReconnecting = false;
     this.client = options.client;
     this.keyPrefix = options.keyPrefix;
     this.redisKey = options.redisKey;
@@ -205,6 +209,10 @@ var SyncedMap = class {
       }
     };
     try {
+      this.subscriberClient.on("error", async (err) => {
+        console.error("Subscriber client error:", err);
+        await this.reconnectSubscriber();
+      });
       const connectIfNeeded = async () => {
         if (!this.subscriberClient.isOpen && !this.subscriberClient.isReady) {
           await this.subscriberClient.connect();
@@ -224,12 +232,12 @@ var SyncedMap = class {
         const keyspaceEventConfig = (await this.subscriberClient.configGet("notify-keyspace-events"))?.["notify-keyspace-events"];
         if (!keyspaceEventConfig.includes("E")) {
           throw new Error(
-            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + " but has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
         if (!keyspaceEventConfig.includes("A") && !(keyspaceEventConfig.includes("x") && keyspaceEventConfig.includes("e"))) {
           throw new Error(
-            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + " but has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
       }
@@ -249,22 +257,48 @@ var SyncedMap = class {
           keyEventHandler
         )
       ]);
-      this.subscriberClient.on("error", async (err) => {
-        console.error("Subscriber client error:", err);
+    } catch (error) {
+      console.error("Error setting up pub/sub client:", error);
+      throw error;
+    }
+  }
+  /**
+   * Reconnect the subscriber client with exponential backoff.
+   * Guarded by `isReconnecting` to prevent concurrent reconnection
+   * attempts when multiple error events fire during an outage.
+   * Retries indefinitely (with capped delay) so the subscriber
+   * eventually recovers once Redis is available again.
+   */
+  async reconnectSubscriber() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    try {
+      let attempt = 0;
+      while (true) {
         try {
-          await this.subscriberClient.quit();
+          try {
+            this.subscriberClient.removeAllListeners("error");
+            await this.subscriberClient.disconnect();
+          } catch {
+          }
           this.subscriberClient = this.client.duplicate();
           await this.setupPubSub();
-        } catch (reconnectError) {
+          return;
+        } catch (error) {
+          const delay = Math.min(
+            500 * Math.pow(2, Math.min(attempt, 5)),
+            1e4
+          );
+          attempt++;
           console.error(
-            "Failed to reconnect subscriber client:",
-            reconnectError
+            `Subscriber reconnect attempt ${attempt} failed, retrying in ${delay}ms`,
+            error
           );
+          await new Promise((r) => setTimeout(r, delay));
         }
-      });
-    } catch (error) {
-      console.error("Error setting up pub/sub client:", error);
-      throw error;
+      }
+    } finally {
+      this.isReconnecting = false;
     }
   }
   async waitUntilReady() {
@@ -487,6 +521,16 @@ function bufferAndMapReplacer(_, value) {
   return value;
 }
 
+// src/serializer.ts
+var jsonCacheValueSerializer = {
+  serialize(value) {
+    return JSON.stringify(value, bufferAndMapReplacer);
+  },
+  deserialize(stored) {
+    return JSON.parse(stored, bufferAndMapReviver);
+  }
+};
+
 // src/RedisStringsHandler.ts
 function redisErrorHandler(debugInfo, redisCommandResult) {
   const beforeTimestamp = performance.now();
@@ -538,7 +582,8 @@ var RedisStringsHandler = class {
     estimateExpireAge = (staleAge) => process.env.VERCEL_ENV === "production" ? staleAge * 2 : staleAge * 1.2,
     killContainerOnErrorThreshold = process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD ? Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0,
     socketOptions,
-    clientOptions
+    clientOptions,
+    valueSerializer = jsonCacheValueSerializer
   }) {
     this.clientReadyCalls = 0;
     try {
@@ -549,6 +594,7 @@ var RedisStringsHandler = class {
       this.estimateExpireAge = estimateExpireAge;
       this.killContainerOnErrorThreshold = killContainerOnErrorThreshold;
       this.getTimeoutMs = getTimeoutMs;
+      this.valueSerializer = valueSerializer;
       try {
         this.client = (0, import_redis.createClient)({
           url: redisUrl,
@@ -718,10 +764,17 @@ var RedisStringsHandler = class {
       if (!serializedCacheEntry) {
         return null;
       }
-      const cacheEntry = JSON.parse(
-        serializedCacheEntry,
-        bufferAndMapReviver
-      );
+      let cacheEntry;
+      try {
+        cacheEntry = await this.valueSerializer.deserialize(serializedCacheEntry);
+      } catch (err) {
+        console.warn(
+          "RedisStringsHandler.get() valueSerializer.deserialize failed, treating as cache miss",
+          this.keyPrefix + key,
+          err
+        );
+        return null;
+      }
       debug(
         "green",
         "RedisStringsHandler.get() finished with result (cacheEntry)",
@@ -831,10 +884,7 @@ var RedisStringsHandler = class {
         tags: ctx?.tags || [],
         value: data
       };
-      const serializedCacheEntry = JSON.stringify(
-        cacheEntry,
-        bufferAndMapReplacer
-      );
+      const serializedCacheEntry = await this.valueSerializer.serialize(cacheEntry);
       if (this.redisGetDeduplication) {
         this.redisDeduplicationHandler.seedRequestReturn(
           key,
@@ -1091,6 +1141,8 @@ var RedisCacheComponentsHandler = class {
     getTimeoutMs = process.env.REDIS_COMMAND_TIMEOUT_MS ? Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 500 : 500,
     revalidateTagQuerySize = 250,
     avgResyncIntervalMs = 60 * 60 * 1e3,
+    redisGetDeduplication = true,
+    inMemoryCachingTime = 1e4,
     socketOptions,
     clientOptions,
     killContainerOnErrorThreshold = process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD ? Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0,
@@ -1103,6 +1155,8 @@ var RedisCacheComponentsHandler = class {
         env: process.env
       });
       this.getTimeoutMs = getTimeoutMs;
+      this.redisGetDeduplication = redisGetDeduplication;
+      this.inMemoryCachingTime = inMemoryCachingTime;
       this.client = (0, import_redis2.createClient)({
         url: redisUrl,
         pingInterval: 1e4,
@@ -1169,6 +1223,26 @@ var RedisCacheComponentsHandler = class {
         filterKeys,
         resyncIntervalMs: avgResyncIntervalMs - avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
+      this.inMemoryDeduplicationCache = new SyncedMap({
+        client: this.client,
+        keyPrefix: this.keyPrefix,
+        redisKey: "__cacheComponents_inMemoryDeduplicationCache__",
+        database,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        customizedSync: {
+          withoutRedisHashmap: true,
+          withoutSetSync: true
+        }
+      });
+      const redisGet = this.client.get.bind(this.client);
+      this.redisDeduplicationHandler = new DeduplicatedRequestHandler(
+        redisGet,
+        inMemoryCachingTime,
+        this.inMemoryDeduplicationCache
+      );
+      this.redisGet = redisGet;
+      this.deduplicatedRedisGet = this.redisDeduplicationHandler.deduplicatedFunction;
     } catch (error) {
       console.error("RedisCacheComponentsHandler constructor error", error);
       throw error;
@@ -1203,9 +1277,10 @@ var RedisCacheComponentsHandler = class {
     const redisKey = `${this.keyPrefix}${cacheKey}`;
     try {
       await this.assertClientIsReady();
+      const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(cacheKey) : this.redisGet;
       const serialized = await redisErrorHandler(
-        "RedisCacheComponentsHandler.get(), operation: get " + this.getTimeoutMs + "ms " + redisKey,
-        this.client.get(
+        "RedisCacheComponentsHandler.get(), operation: get" + (this.redisGetDeduplication ? " deduplicated" : "") + " " + this.getTimeoutMs + "ms " + redisKey,
+        clientGet(
           (0, import_redis2.commandOptions)({ signal: AbortSignal.timeout(this.getTimeoutMs) }),
           redisKey
         )
@@ -1278,6 +1353,9 @@ var RedisCacheComponentsHandler = class {
         console.error("Stored object:", stored);
         throw jsonError;
       }
+      if (this.redisGetDeduplication) {
+        this.redisDeduplicationHandler.seedRequestReturn(cacheKey, serialized);
+      }
       const ttlSeconds = Number.isFinite(stored.expire) && stored.expire > 0 ? Math.floor(stored.expire) : void 0;
       const redisKey = `${this.keyPrefix}${cacheKey}`;
       const setOperation = redisErrorHandler(
@@ -1344,6 +1422,11 @@ var RedisCacheComponentsHandler = class {
         "RedisCacheComponentsHandler.updateTags(), operation: unlink",
         this.client.unlink(fullRedisKeys)
       );
+      if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
+        for (const key of keysToDelete) {
+          this.inMemoryDeduplicationCache.delete(key);
+        }
+      }
       const deleteTagsOperation = this.sharedTagsMap.delete(cacheKeys);
       await deleteTagsOperation;
     } catch (error) {
@@ -1370,7 +1453,10 @@ var index_default = CachedHandler;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RedisStringsHandler,
+  bufferAndMapReplacer,
+  bufferAndMapReviver,
   getRedisCacheComponentsHandler,
+  jsonCacheValueSerializer,
   redisCacheHandler
 });
 //# sourceMappingURL=index.js.map