@trieb.work/nextjs-turbo-redis-cache 1.15.0 → 1.16.0

package/dist/index.mjs

@@ -26,6 +26,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;
@@ -166,6 +167,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();
@@ -185,12 +190,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`"
           );
         }
       }
@@ -210,22 +215,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() {
@@ -493,6 +524,19 @@ if (process.env.DEBUG_CACHE_HANDLER) {
 }
 var NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
 var REVALIDATED_TAGS_KEY = "__revalidated_tags__";
+var SUPPORTED_GET_KINDS = [
+  "APP_ROUTE",
+  "APP_PAGE",
+  "PAGES",
+  "FETCH"
+];
+var SUPPORTED_SET_KINDS = [
+  "APP_ROUTE",
+  "APP_PAGE",
+  "PAGES",
+  "REDIRECT",
+  "FETCH"
+];
 var killContainerOnErrorCount = 0;
 var RedisStringsHandler = class {
   constructor({
@@ -658,12 +702,12 @@ var RedisStringsHandler = class {
   }
   async get(key, ctx) {
     try {
-      if (ctx.kind !== "APP_ROUTE" && ctx.kind !== "APP_PAGE" && ctx.kind !== "FETCH") {
+      if (!SUPPORTED_GET_KINDS.includes(ctx.kind)) {
         console.warn(
           "RedisStringsHandler.get() called with",
           key,
           ctx,
-          " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
+          `this cache handler is only designed and tested for kinds ${SUPPORTED_GET_KINDS.join(", ")} and not for kind`,
           ctx?.kind
         );
       }
@@ -718,7 +762,7 @@ var RedisStringsHandler = class {
           "cacheEntry is mall formed (missing tags)"
         );
       }
-      if (!cacheEntry?.value) {
+      if (cacheEntry?.value === void 0) {
         console.warn(
           "RedisStringsHandler.get() called with",
           key,
@@ -791,21 +835,27 @@ var RedisStringsHandler = class {
   }
   async set(key, data, ctx) {
     try {
-      if (data.kind !== "APP_ROUTE" && data.kind !== "APP_PAGE" && data.kind !== "FETCH") {
+      if (data !== null && !SUPPORTED_SET_KINDS.includes(data.kind)) {
         console.warn(
           "RedisStringsHandler.set() called with",
           key,
           ctx,
           data,
-          " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
+          `this cache handler is only designed and tested for kinds ${SUPPORTED_SET_KINDS.join(", ")} and not for kind`,
           data?.kind
         );
       }
       await this.assertClientIsReady();
-      if (data.kind === "APP_PAGE" || data.kind === "APP_ROUTE") {
+      if (data?.kind === "APP_PAGE" || data?.kind === "APP_ROUTE") {
         const tags = data.headers["x-next-cache-tags"]?.split(",");
         ctx.tags = [...ctx.tags || [], ...tags || []];
       }
+      if (data === null || data.kind === "PAGES" || data.kind === "REDIRECT") {
+        const implicitTag = NEXT_CACHE_IMPLICIT_TAG_ID + key;
+        if (!ctx.tags?.includes(implicitTag)) {
+          ctx.tags = [...ctx.tags || [], implicitTag];
+        }
+      }
       const cacheEntry = {
         lastModified: Date.now(),
         tags: ctx?.tags || [],
@@ -820,7 +870,10 @@ var RedisStringsHandler = class {
       }
       const revalidate = (
         // For fetch requests in newest versions, the revalidate context property is never used, and instead the revalidate property of the passed-in data is used
-        data.kind === "FETCH" && data.revalidate || ctx.revalidate || ctx.cacheControl?.revalidate || data?.revalidate
+        data?.kind === "FETCH" && data.revalidate || ctx.revalidate || ctx.cacheControl?.revalidate || // Legacy fallback: older Next.js versions attached `revalidate` directly
+        // to the data payload. FETCH is already handled above, so this only
+        // matters for those older, non-discriminated shapes.
+        data?.revalidate
       );
       const expireAt = revalidate && Number.isSafeInteger(revalidate) && revalidate > 0 ? this.estimateExpireAge(revalidate) : this.estimateExpireAge(this.defaultStaleAge);
       const setOperation = redisErrorHandler(
@@ -1068,6 +1121,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,
@@ -1080,6 +1135,8 @@ var RedisCacheComponentsHandler = class {
         env: process.env
       });
       this.getTimeoutMs = getTimeoutMs;
+      this.redisGetDeduplication = redisGetDeduplication;
+      this.inMemoryCachingTime = inMemoryCachingTime;
       this.client = createClient2({
         url: redisUrl,
         pingInterval: 1e4,
@@ -1146,6 +1203,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;
@@ -1180,9 +1257,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(
           commandOptions2({ signal: AbortSignal.timeout(this.getTimeoutMs) }),
           redisKey
         )
@@ -1255,6 +1333,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(
@@ -1321,6 +1402,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) {