@trieb.work/nextjs-turbo-redis-cache 1.10.0-beta.14 → 1.11.0-beta.1

package/dist/index.js

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   RedisStringsHandler: () => RedisStringsHandler,
-  default: () => index_default
+  default: () => index_default,
+  getRedisCacheComponentsHandler: () => getRedisCacheComponentsHandler,
+  redisCacheHandler: () => redisCacheHandler
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -539,16 +541,15 @@ var RedisStringsHandler = class {
             error,
             killContainerOnErrorCount++
           );
-          setTimeout(() => {
-            if (!this.client.isOpen && !this.client.isReady) {
-              this.client.connect().catch((error2) => {
-                console.error(
-                  "Failed to reconnect Redis client after connection loss:",
-                  error2
-                );
-              });
-            }
-          }, 1e3);
+          setTimeout(
+            () => this.client.connect().catch((error2) => {
+              console.error(
+                "Failed to reconnect Redis client after connection loss:",
+                error2
+              );
+            }),
+            1e3
+          );
           if (this.killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= this.killContainerOnErrorThreshold) {
             console.error(
               "Redis client error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
@@ -564,9 +565,12 @@ var RedisStringsHandler = class {
         });
         this.client.connect().then(() => {
           debug("green", "Redis client connected.");
-        }).catch((error) => {
-          console.error("Failed to connect Redis client:", error);
-          throw error;
+        }).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");
@@ -975,10 +979,324 @@ var CachedHandler = class {
   }
 };
 
+// src/CacheComponentsHandler.ts
+var import_redis2 = require("redis");
+var REVALIDATED_TAGS_KEY2 = "__cacheComponents_revalidated_tags__";
+var SHARED_TAGS_KEY = "__cacheComponents_sharedTags__";
+var killContainerOnErrorCount2 = 0;
+async function streamToBuffer(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+    }
+  }
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function bufferToReadableStream(buffer) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(buffer);
+      controller.close();
+    }
+  });
+}
+var RedisCacheComponentsHandler = class {
+  constructor({
+    redisUrl = process.env.REDIS_URL ? process.env.REDIS_URL : process.env.REDISHOST ? `redis://${process.env.REDISHOST}:${process.env.REDISPORT}` : "redis://localhost:6379",
+    database = process.env.VERCEL_ENV === "production" ? 0 : 1,
+    keyPrefix = process.env.VERCEL_URL || "UNDEFINED_URL_",
+    getTimeoutMs = process.env.REDIS_COMMAND_TIMEOUT_MS ? Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 500 : 500,
+    revalidateTagQuerySize = 250,
+    avgResyncIntervalMs = 60 * 60 * 1e3,
+    socketOptions,
+    clientOptions,
+    killContainerOnErrorThreshold = process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD ? Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0
+  }) {
+    try {
+      this.keyPrefix = keyPrefix;
+      this.getTimeoutMs = getTimeoutMs;
+      this.client = (0, import_redis2.createClient)({
+        url: redisUrl,
+        pingInterval: 1e4,
+        ...database !== 0 ? { database } : {},
+        ...socketOptions ? { socket: { ...socketOptions } } : {},
+        ...clientOptions || {}
+      });
+      this.client.on("error", (error) => {
+        console.error(
+          "RedisCacheComponentsHandler client error",
+          error,
+          killContainerOnErrorCount2++
+        );
+        setTimeout(
+          () => this.client.connect().catch((err) => {
+            console.error(
+              "Failed to reconnect RedisCacheComponentsHandler client after connection loss:",
+              err
+            );
+          }),
+          1e3
+        );
+        if (killContainerOnErrorThreshold > 0 && killContainerOnErrorCount2 >= killContainerOnErrorThreshold) {
+          console.error(
+            "RedisCacheComponentsHandler client error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+            error,
+            killContainerOnErrorCount2++
+          );
+          this.client.disconnect();
+          this.client.quit();
+          setTimeout(() => {
+            process.exit(1);
+          }, 500);
+        }
+      });
+      this.client.connect().then(() => {
+        debug("green", "RedisCacheComponentsHandler client connected.");
+      }).catch(() => {
+        this.client.connect().catch((error) => {
+          console.error(
+            "Failed to connect RedisCacheComponentsHandler client:",
+            error
+          );
+          this.client.disconnect();
+          throw error;
+        });
+      });
+      const filterKeys = (key) => key !== REVALIDATED_TAGS_KEY2 && key !== SHARED_TAGS_KEY;
+      this.revalidatedTagsMap = new SyncedMap({
+        client: this.client,
+        keyPrefix,
+        redisKey: REVALIDATED_TAGS_KEY2,
+        database,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        resyncIntervalMs: avgResyncIntervalMs + avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
+      });
+      this.sharedTagsMap = new SyncedMap({
+        client: this.client,
+        keyPrefix,
+        redisKey: SHARED_TAGS_KEY,
+        database,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        resyncIntervalMs: avgResyncIntervalMs - avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
+      });
+    } catch (error) {
+      console.error("RedisCacheComponentsHandler constructor error", error);
+      throw error;
+    }
+  }
+  async assertClientIsReady() {
+    if (!this.client.isReady && !this.client.isOpen) {
+      await this.client.connect().catch((error) => {
+        console.error(
+          "RedisCacheComponentsHandler assertClientIsReady reconnect error:",
+          error
+        );
+        throw error;
+      });
+    }
+    await Promise.all([
+      this.revalidatedTagsMap.waitUntilReady(),
+      this.sharedTagsMap.waitUntilReady()
+    ]);
+  }
+  async computeMaxRevalidation(tags) {
+    let max = 0;
+    for (const tag of tags) {
+      const ts = this.revalidatedTagsMap.get(tag);
+      if (ts && ts > max) {
+        max = ts;
+      }
+    }
+    return max;
+  }
+  async get(cacheKey, softTags) {
+    const redisKey = `${this.keyPrefix}${cacheKey}`;
+    try {
+      await this.assertClientIsReady();
+      const serialized = await redisErrorHandler(
+        "RedisCacheComponentsHandler.get(), operation: get " + this.getTimeoutMs + "ms " + redisKey,
+        this.client.get(
+          (0, import_redis2.commandOptions)({ signal: AbortSignal.timeout(this.getTimeoutMs) }),
+          redisKey
+        )
+      );
+      if (!serialized) {
+        return void 0;
+      }
+      const stored = JSON.parse(serialized);
+      const now = Date.now();
+      const expiryTime = stored.timestamp + stored.expire * 1e3;
+      if (Number.isFinite(stored.expire) && stored.expire > 0 && now > expiryTime) {
+        await this.client.unlink(redisKey).catch(() => {
+        });
+        await this.sharedTagsMap.delete(cacheKey).catch(() => {
+        });
+        return void 0;
+      }
+      const maxRevalidation = await this.computeMaxRevalidation([
+        ...stored.tags || [],
+        ...softTags || []
+      ]);
+      if (maxRevalidation > 0 && maxRevalidation > stored.timestamp) {
+        await this.client.unlink(redisKey).catch(() => {
+        });
+        await this.sharedTagsMap.delete(cacheKey).catch(() => {
+        });
+        return void 0;
+      }
+      const valueBuffer = typeof stored.value === "string" ? new Uint8Array(Buffer.from(stored.value, "base64")) : stored.value;
+      return {
+        ...stored,
+        value: bufferToReadableStream(valueBuffer)
+      };
+    } catch (error) {
+      console.error(
+        "RedisCacheComponentsHandler.get() Error occurred while getting cache entry. Returning undefined so site can continue to serve content while cache is disabled. The original error was:",
+        error,
+        killContainerOnErrorCount2++
+      );
+      return void 0;
+    }
+  }
+  async set(cacheKey, pendingEntry) {
+    try {
+      await this.assertClientIsReady();
+      const entry = await pendingEntry;
+      const [storeStream] = entry.value.tee();
+      const buffer = await streamToBuffer(storeStream);
+      const stored = {
+        value: Buffer.from(buffer).toString("base64"),
+        tags: entry.tags || [],
+        stale: entry.stale,
+        timestamp: entry.timestamp,
+        expire: entry.expire,
+        revalidate: entry.revalidate
+      };
+      let serialized;
+      try {
+        const cleanStored = {
+          value: stored.value,
+          tags: Array.isArray(stored.tags) ? [...stored.tags] : [],
+          stale: Number(stored.stale),
+          timestamp: Number(stored.timestamp),
+          expire: Number(stored.expire),
+          revalidate: Number(stored.revalidate)
+        };
+        serialized = JSON.stringify(cleanStored);
+      } catch (jsonError) {
+        console.error("JSON.stringify error:", jsonError);
+        console.error("Stored object:", stored);
+        throw jsonError;
+      }
+      const ttlSeconds = Number.isFinite(stored.expire) && stored.expire > 0 ? Math.floor(stored.expire) : void 0;
+      const redisKey = `${this.keyPrefix}${cacheKey}`;
+      const setOperation = redisErrorHandler(
+        "RedisCacheComponentsHandler.set(), operation: set " + redisKey,
+        this.client.set(redisKey, serialized, {
+          ...ttlSeconds ? { EX: ttlSeconds } : {}
+        })
+      );
+      let tagsOperation;
+      const tags = stored.tags || [];
+      if (tags.length > 0) {
+        const currentTags = this.sharedTagsMap.get(cacheKey);
+        const currentIsSameAsNew = currentTags?.length === tags.length && currentTags.every((v) => tags.includes(v)) && tags.every((v) => currentTags.includes(v));
+        if (!currentIsSameAsNew) {
+          tagsOperation = this.sharedTagsMap.set(cacheKey, [...tags]);
+        }
+      }
+      await Promise.all([setOperation, tagsOperation]);
+    } catch (error) {
+      console.error(
+        "RedisCacheComponentsHandler.set() Error occurred while setting cache entry. The original error was:",
+        error,
+        killContainerOnErrorCount2++
+      );
+      throw error;
+    }
+  }
+  async refreshTags() {
+    await this.assertClientIsReady();
+  }
+  async getExpiration(tags) {
+    try {
+      await this.assertClientIsReady();
+      return this.computeMaxRevalidation(tags || []);
+    } catch (error) {
+      console.error(
+        "RedisCacheComponentsHandler.getExpiration() Error occurred while getting expiration for tags. The original error was:",
+        error
+      );
+      return 0;
+    }
+  }
+  async updateTags(tags, _durations) {
+    try {
+      void _durations;
+      await this.assertClientIsReady();
+      const now = Date.now();
+      const tagsSet = new Set(tags || []);
+      for (const tag of tagsSet) {
+        await this.revalidatedTagsMap.set(tag, now);
+      }
+      const keysToDelete = /* @__PURE__ */ new Set();
+      for (const [key, storedTags] of this.sharedTagsMap.entries()) {
+        if (storedTags.some((tag) => tagsSet.has(tag))) {
+          keysToDelete.add(key);
+        }
+      }
+      if (keysToDelete.size === 0) {
+        return;
+      }
+      const cacheKeys = Array.from(keysToDelete);
+      const fullRedisKeys = cacheKeys.map((key) => `${this.keyPrefix}${key}`);
+      await redisErrorHandler(
+        "RedisCacheComponentsHandler.updateTags(), operation: unlink",
+        this.client.unlink(fullRedisKeys)
+      );
+      const deleteTagsOperation = this.sharedTagsMap.delete(cacheKeys);
+      await deleteTagsOperation;
+    } catch (error) {
+      console.error(
+        "RedisCacheComponentsHandler.updateTags() Error occurred while updating tags. The original error was:",
+        error,
+        killContainerOnErrorCount2++
+      );
+      throw error;
+    }
+  }
+};
+var singletonHandler;
+function getRedisCacheComponentsHandler(options = {}) {
+  if (!singletonHandler) {
+    singletonHandler = new RedisCacheComponentsHandler(options);
+  }
+  return singletonHandler;
+}
+var redisCacheHandler = getRedisCacheComponentsHandler();
+
 // src/index.ts
 var index_default = CachedHandler;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RedisStringsHandler
+  RedisStringsHandler,
+  getRedisCacheComponentsHandler,
+  redisCacheHandler
 });
 //# sourceMappingURL=index.js.map