@trieb.work/nextjs-turbo-redis-cache 1.2.0 → 1.3.0

package/dist/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  RedisStringsHandler: () => RedisStringsHandler,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
@@ -27,6 +28,27 @@ module.exports = __toCommonJS(index_exports);
 // src/RedisStringsHandler.ts
 var import_redis = require("redis");
 
+// src/utils/debug.ts
+function debug(color = "none", ...args) {
+  const colorCode = {
+    red: "\x1B[31m",
+    blue: "\x1B[34m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m",
+    none: ""
+  };
+  if (process.env.DEBUG_CACHE_HANDLER) {
+    console.log(colorCode[color], "DEBUG CACHE HANDLER: ", ...args);
+  }
+}
+function debugVerbose(color, ...args) {
+  if (process.env.DEBUG_CACHE_HANDLER_VERBOSE_VERBOSE) {
+    console.log("\x1B[35m", "DEBUG SYNCED MAP: ", ...args);
+  }
+}
+
 // src/SyncedMap.ts
 var SYNC_CHANNEL_SUFFIX = ":sync-channel:";
 var SyncedMap = class {
@@ -142,24 +164,56 @@ var SyncedMap = class {
         }
       }
     };
-    const keyEventHandler = async (_channel, message) => {
-      const key = message;
+    const keyEventHandler = async (key, message) => {
+      debug(
+        "yellow",
+        "SyncedMap.keyEventHandler() called with message",
+        this.redisKey,
+        message,
+        key
+      );
       if (key.startsWith(this.keyPrefix)) {
         const keyInMap = key.substring(this.keyPrefix.length);
         if (this.filterKeys(keyInMap)) {
+          debugVerbose(
+            "SyncedMap.keyEventHandler() key matches filter and will be deleted",
+            this.redisKey,
+            message,
+            key
+          );
           await this.delete(keyInMap, true);
         }
+      } else {
+        debugVerbose(
+          "SyncedMap.keyEventHandler() key does not have prefix",
+          this.redisKey,
+          message,
+          key
+        );
       }
     };
     try {
-      await this.subscriberClient.connect();
+      await this.subscriberClient.connect().catch(async () => {
+        await this.subscriberClient.connect();
+      });
+      const keyspaceEventConfig = (await this.subscriberClient.configGet("notify-keyspace-events"))?.["notify-keyspace-events"];
+      if (!keyspaceEventConfig.includes("E")) {
+        throw new Error(
+          "Keyspace event configuration 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 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`"
+        );
+      }
       await Promise.all([
         // We use a custom channel for insert/delete For the following reason:
         // With custom channel we can delete multiple entries in one message. If we would listen to unlink / del we
         // could get thousands of messages for one revalidateTag (For example revalidateTag("algolia") would send an enormous amount of network packages)
         // Also we can send the value in the message for insert
         this.subscriberClient.subscribe(this.syncChannel, syncHandler),
-        // Subscribe to Redis keyspace notifications for evicted and expired keys
+        // Subscribe to Redis keyevent notifications for evicted and expired keys
         this.subscriberClient.subscribe(
           `__keyevent@${this.database}__:evicted`,
           keyEventHandler
@@ -191,9 +245,19 @@ var SyncedMap = class {
     await this.setupLock;
   }
   get(key) {
+    debugVerbose(
+      "SyncedMap.get() called with key",
+      key,
+      JSON.stringify(this.map.get(key))?.substring(0, 100)
+    );
     return this.map.get(key);
   }
   async set(key, value) {
+    debugVerbose(
+      "SyncedMap.set() called with key",
+      key,
+      JSON.stringify(value)?.substring(0, 100)
+    );
     this.map.set(key, value);
     const operations = [];
     if (this.customizedSync?.withoutSetSync) {
@@ -220,7 +284,15 @@ var SyncedMap = class {
     );
     await Promise.all(operations);
   }
+  // /api/revalidated-fetch
+  // true
   async delete(keys, withoutSyncMessage = false) {
+    debugVerbose(
+      "SyncedMap.delete() called with keys",
+      this.redisKey,
+      keys,
+      withoutSyncMessage
+    );
     const keysArray = Array.isArray(keys) ? keys : [keys];
     const operations = [];
     for (const key of keysArray) {
@@ -242,6 +314,12 @@ var SyncedMap = class {
       );
     }
     await Promise.all(operations);
+    debugVerbose(
+      "SyncedMap.delete() finished operations",
+      this.redisKey,
+      keys,
+      operations.length
+    );
   }
   has(key) {
     return this.map.has(key);
@@ -256,19 +334,59 @@ var DeduplicatedRequestHandler = class {
   constructor(fn, cachingTimeMs, inMemoryDeduplicationCache) {
     // Method to handle deduplicated requests
     this.deduplicatedFunction = (key) => {
+      debugVerbose(
+        "DeduplicatedRequestHandler.deduplicatedFunction() called with",
+        key
+      );
       const self = this;
       const dedupedFn = async (...args) => {
+        debugVerbose(
+          "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn called with",
+          key
+        );
         if (self.inMemoryDeduplicationCache && self.inMemoryDeduplicationCache.has(key)) {
+          debugVerbose(
+            "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn ",
+            key,
+            "found key in inMemoryDeduplicationCache"
+          );
           const res = await self.inMemoryDeduplicationCache.get(key).then((v) => structuredClone(v));
+          debugVerbose(
+            "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn ",
+            key,
+            "found key in inMemoryDeduplicationCache and served result from there",
+            JSON.stringify(res).substring(0, 200)
+          );
           return res;
         }
         const promise = self.fn(...args);
         self.inMemoryDeduplicationCache.set(key, promise);
+        debugVerbose(
+          "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn ",
+          key,
+          "did not found key in inMemoryDeduplicationCache. Setting it now and waiting for promise to resolve"
+        );
         try {
+          const ts = performance.now();
           const result = await promise;
+          debugVerbose(
+            "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn ",
+            key,
+            "promise resolved (in ",
+            performance.now() - ts,
+            "ms). Returning result",
+            JSON.stringify(result).substring(0, 200)
+          );
           return structuredClone(result);
         } finally {
           setTimeout(() => {
+            debugVerbose(
+              "DeduplicatedRequestHandler.deduplicatedFunction().dedupedFn ",
+              key,
+              "deleting key from inMemoryDeduplicationCache after ",
+              self.cachingTimeMs,
+              "ms"
+            );
             self.inMemoryDeduplicationCache.delete(key);
           }, self.cachingTimeMs);
         }
@@ -283,18 +401,41 @@ var DeduplicatedRequestHandler = class {
   seedRequestReturn(key, value) {
     const resultPromise = new Promise((res) => res(value));
     this.inMemoryDeduplicationCache.set(key, resultPromise);
+    debugVerbose(
+      "DeduplicatedRequestHandler.seedRequestReturn() seeded result ",
+      key,
+      value.substring(0, 200)
+    );
     setTimeout(() => {
       this.inMemoryDeduplicationCache.delete(key);
     }, this.cachingTimeMs);
   }
 };
 
+// src/utils/json.ts
+function bufferReviver(_, value) {
+  if (value && typeof value === "object" && typeof value.$binary === "string") {
+    return Buffer.from(value.$binary, "base64");
+  }
+  return value;
+}
+function bufferReplacer(_, value) {
+  if (Buffer.isBuffer(value)) {
+    return {
+      $binary: value.toString("base64")
+    };
+  }
+  if (value && typeof value === "object" && value?.type === "Buffer" && Array.isArray(value.data)) {
+    return {
+      $binary: Buffer.from(value.data).toString("base64")
+    };
+  }
+  return value;
+}
+
 // src/RedisStringsHandler.ts
 var NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
 var REVALIDATED_TAGS_KEY = "__revalidated_tags__";
-function isImplicitTag(tag) {
-  return tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID);
-}
 function getTimeoutRedisCommandOptions(timeoutMs) {
   return (0, import_redis.commandOptions)({ signal: AbortSignal.timeout(timeoutMs) });
 }
@@ -309,7 +450,7 @@ var RedisStringsHandler = class {
     redisGetDeduplication = true,
     inMemoryCachingTime = 1e4,
     defaultStaleAge = 60 * 60 * 24 * 14,
-    estimateExpireAge = (staleAge) => process.env.VERCEL_ENV === "preview" ? staleAge * 1.2 : staleAge * 2
+    estimateExpireAge = (staleAge) => process.env.VERCEL_ENV === "production" ? staleAge * 2 : staleAge * 1.2
   }) {
     this.keyPrefix = keyPrefix;
     this.timeoutMs = timeoutMs;
@@ -327,9 +468,12 @@ var RedisStringsHandler = class {
       });
       this.client.connect().then(() => {
         console.info("Redis client connected.");
-      }).catch((error) => {
-        console.error("Failed to connect Redis client:", error);
-        this.client.disconnect();
+      }).catch(() => {
+        this.client.connect().catch((error) => {
+          console.error("Failed to connect Redis client:", error);
+          this.client.disconnect();
+          throw error;
+        });
       });
     } catch (error) {
       console.error("Failed to initialize Redis client");
@@ -378,8 +522,7 @@ var RedisStringsHandler = class {
     this.redisGet = redisGet;
     this.deduplicatedRedisGet = this.redisDeduplicationHandler.deduplicatedFunction;
   }
-  resetRequestCache(...args) {
-    console.warn("WARNING resetRequestCache() was called", args);
+  resetRequestCache() {
   }
   async assertClientIsReady() {
     await Promise.all([
@@ -391,75 +534,153 @@ var RedisStringsHandler = class {
     }
   }
   async get(key, ctx) {
+    if (ctx.kind !== "APP_ROUTE" && ctx.kind !== "APP_PAGE" && ctx.kind !== "FETCH") {
+      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 ",
+        ctx?.kind
+      );
+    }
+    debug("green", "RedisStringsHandler.get() called with", key, ctx);
     await this.assertClientIsReady();
     const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(key) : this.redisGet;
-    const result = await clientGet(
+    const serializedCacheEntry = await clientGet(
       getTimeoutRedisCommandOptions(this.timeoutMs),
       this.keyPrefix + key
     );
-    if (!result) {
+    debug(
+      "green",
+      "RedisStringsHandler.get() finished with result (serializedCacheEntry)",
+      serializedCacheEntry?.substring(0, 200)
+    );
+    if (!serializedCacheEntry) {
       return null;
     }
-    const cacheValue = JSON.parse(result);
-    if (!cacheValue) {
+    const cacheEntry = JSON.parse(
+      serializedCacheEntry,
+      bufferReviver
+    );
+    debug(
+      "green",
+      "RedisStringsHandler.get() finished with result (cacheEntry)",
+      JSON.stringify(cacheEntry).substring(0, 200)
+    );
+    if (!cacheEntry) {
       return null;
     }
-    if (cacheValue.value?.kind === "FETCH") {
-      cacheValue.value.data.body = Buffer.from(
-        cacheValue.value.data.body
-      ).toString("base64");
+    if (!cacheEntry?.tags) {
+      console.warn(
+        "RedisStringsHandler.get() called with",
+        key,
+        ctx,
+        "cacheEntry is mall formed (missing tags)"
+      );
     }
-    const combinedTags = /* @__PURE__ */ new Set([
-      ...ctx?.softTags || [],
-      ...ctx?.tags || []
-    ]);
-    if (combinedTags.size === 0) {
-      return cacheValue;
+    if (!cacheEntry?.value) {
+      console.warn(
+        "RedisStringsHandler.get() called with",
+        key,
+        ctx,
+        "cacheEntry is mall formed (missing value)"
+      );
     }
-    for (const tag of combinedTags) {
-      const revalidationTime = this.revalidatedTagsMap.get(tag);
-      if (revalidationTime && revalidationTime > cacheValue.lastModified) {
-        const redisKey = this.keyPrefix + key;
-        this.client.unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey).catch((err) => {
-          console.error(
-            "Error occurred while unlinking stale data. Retrying now. Error was:",
-            err
-          );
-          this.client.unlink(
-            getTimeoutRedisCommandOptions(this.timeoutMs),
-            redisKey
+    if (!cacheEntry?.lastModified) {
+      console.warn(
+        "RedisStringsHandler.get() called with",
+        key,
+        ctx,
+        "cacheEntry is mall formed (missing lastModified)"
+      );
+    }
+    if (ctx.kind === "FETCH") {
+      const combinedTags = /* @__PURE__ */ new Set([
+        ...ctx?.softTags || [],
+        ...ctx?.tags || []
+      ]);
+      if (combinedTags.size === 0) {
+        return cacheEntry;
+      }
+      for (const tag of combinedTags) {
+        const revalidationTime = this.revalidatedTagsMap.get(tag);
+        if (revalidationTime && revalidationTime > cacheEntry.lastModified) {
+          const redisKey = this.keyPrefix + key;
+          this.client.unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey).catch((err) => {
+            console.error(
+              "Error occurred while unlinking stale data. Retrying now. Error was:",
+              err
+            );
+            this.client.unlink(
+              getTimeoutRedisCommandOptions(this.timeoutMs),
+              redisKey
+            );
+          }).finally(async () => {
+            await this.sharedTagsMap.delete(key);
+            await this.revalidatedTagsMap.delete(tag);
+          });
+          debug(
+            "green",
+            'RedisStringsHandler.get() found revalidation time for tag. Cache entry is stale and will be deleted and "null" will be returned.',
+            tag,
+            redisKey,
+            revalidationTime,
+            cacheEntry
           );
-        }).finally(async () => {
-          await this.sharedTagsMap.delete(key);
-          await this.revalidatedTagsMap.delete(tag);
-        });
-        return null;
+          return null;
+        }
       }
     }
-    return cacheValue;
+    return cacheEntry;
   }
   async set(key, data, ctx) {
-    if (data.kind === "FETCH") {
-      console.time("encoding" + key);
-      data.data.body = Buffer.from(data.data.body, "base64").toString();
-      console.timeEnd("encoding" + key);
+    if (data.kind !== "APP_ROUTE" && data.kind !== "APP_PAGE" && data.kind !== "FETCH") {
+      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 ",
+        data?.kind
+      );
     }
     await this.assertClientIsReady();
-    data.lastModified = Date.now();
-    const value = JSON.stringify(data);
+    if (data.kind === "APP_PAGE" || data.kind === "APP_ROUTE") {
+      const tags = data.headers["x-next-cache-tags"]?.split(",");
+      ctx.tags = [...ctx.tags || [], ...tags || []];
+    }
+    const cacheEntry = {
+      lastModified: Date.now(),
+      tags: ctx?.tags || [],
+      value: data
+    };
+    const serializedCacheEntry = JSON.stringify(cacheEntry, bufferReplacer);
     if (this.redisGetDeduplication) {
-      this.redisDeduplicationHandler.seedRequestReturn(key, value);
+      this.redisDeduplicationHandler.seedRequestReturn(
+        key,
+        serializedCacheEntry
+      );
     }
     const expireAt = ctx.revalidate && Number.isSafeInteger(ctx.revalidate) && ctx.revalidate > 0 ? this.estimateExpireAge(ctx.revalidate) : this.estimateExpireAge(this.defaultStaleAge);
     const options = getTimeoutRedisCommandOptions(this.timeoutMs);
     const setOperation = this.client.set(
       options,
       this.keyPrefix + key,
-      value,
+      serializedCacheEntry,
       {
         EX: expireAt
       }
     );
+    debug(
+      "blue",
+      "RedisStringsHandler.set() will set the following serializedCacheEntry",
+      this.keyPrefix,
+      key,
+      data,
+      ctx,
+      serializedCacheEntry?.substring(0, 200),
+      expireAt
+    );
     let setTagsOperation;
     if (ctx.tags && ctx.tags.length > 0) {
       const currentTags = this.sharedTagsMap.get(key);
@@ -471,27 +692,54 @@ var RedisStringsHandler = class {
         );
       }
     }
+    debug(
+      "blue",
+      "RedisStringsHandler.set() will set the following sharedTagsMap",
+      key,
+      ctx.tags
+    );
     await Promise.all([setOperation, setTagsOperation]);
   }
-  async revalidateTag(tagOrTags) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async revalidateTag(tagOrTags, ...rest) {
+    debug(
+      "red",
+      "RedisStringsHandler.revalidateTag() called with",
+      tagOrTags,
+      rest
+    );
     const tags = new Set([tagOrTags || []].flat());
     await this.assertClientIsReady();
+    const keysToDelete = /* @__PURE__ */ new Set();
     for (const tag of tags) {
-      if (isImplicitTag(tag)) {
+      if (tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID)) {
         const now = Date.now();
+        debug(
+          "red",
+          "RedisStringsHandler.revalidateTag() set revalidation time for tag",
+          tag,
+          "to",
+          now
+        );
         await this.revalidatedTagsMap.set(tag, now);
       }
     }
-    const keysToDelete = [];
     for (const [key, sharedTags] of this.sharedTagsMap.entries()) {
       if (sharedTags.some((tag) => tags.has(tag))) {
-        keysToDelete.push(key);
+        keysToDelete.add(key);
       }
     }
-    if (keysToDelete.length === 0) {
+    debug(
+      "red",
+      "RedisStringsHandler.revalidateTag() found",
+      keysToDelete,
+      "keys to delete"
+    );
+    if (keysToDelete.size === 0) {
       return;
     }
-    const fullRedisKeys = keysToDelete.map((key) => this.keyPrefix + key);
+    const redisKeys = Array.from(keysToDelete);
+    const fullRedisKeys = redisKeys.map((key) => this.keyPrefix + key);
     const options = getTimeoutRedisCommandOptions(this.timeoutMs);
     const deleteKeysOperation = this.client.unlink(options, fullRedisKeys);
     if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
@@ -499,8 +747,12 @@ var RedisStringsHandler = class {
         this.inMemoryDeduplicationCache.delete(key);
       }
     }
-    const deleteTagsOperation = this.sharedTagsMap.delete(keysToDelete);
+    const deleteTagsOperation = this.sharedTagsMap.delete(redisKeys);
     await Promise.all([deleteKeysOperation, deleteTagsOperation]);
+    debug(
+      "red",
+      "RedisStringsHandler.revalidateTag() finished delete operations"
+    );
   }
 };
 
@@ -514,12 +766,15 @@ var CachedHandler = class {
     }
   }
   get(...args) {
+    debugVerbose("CachedHandler.get called with", args);
     return cachedHandler.get(...args);
   }
   set(...args) {
+    debugVerbose("CachedHandler.set called with", args);
     return cachedHandler.set(...args);
   }
   revalidateTag(...args) {
+    debugVerbose("CachedHandler.revalidateTag called with", args);
     return cachedHandler.revalidateTag(...args);
   }
   resetRequestCache(...args) {
@@ -529,4 +784,8 @@ var CachedHandler = class {
 
 // src/index.ts
 var index_default = CachedHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisStringsHandler
+});
 //# sourceMappingURL=index.js.map