@trieb.work/nextjs-turbo-redis-cache 1.16.2 → 1.18.0

package/dist/index.js

@@ -36,7 +36,9 @@ __export(index_exports, {
   default: () => index_default,
   getRedisCacheComponentsHandler: () => getRedisCacheComponentsHandler,
   jsonCacheValueSerializer: () => jsonCacheValueSerializer,
-  redisCacheHandler: () => redisCacheHandler
+  redisCacheHandler: () => redisCacheHandler,
+  resolveCacheEntryTtlSeconds: () => resolveCacheEntryTtlSeconds,
+  shouldDeferRedisConnection: () => shouldDeferRedisConnection
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -64,6 +66,12 @@ function debugVerbose(color, ...args) {
   }
 }
 
+// src/utils/redisConnection.ts
+var PHASE_PRODUCTION_BUILD = "phase-production-build";
+function shouldDeferRedisConnection() {
+  return process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD;
+}
+
 // src/SyncedMap.ts
 var SYNC_CHANNEL_SUFFIX = ":sync-channel:";
 var SyncedMap = class {
@@ -89,6 +97,10 @@ var SyncedMap = class {
     });
   }
   async setup() {
+    if (shouldDeferRedisConnection()) {
+      this.setupLockResolve();
+      return;
+    }
     let setupPromises = [];
     if (!this.customizedSync?.withoutRedisHashmap) {
       setupPromises.push(this.initialSync());
@@ -119,7 +131,9 @@ var SyncedMap = class {
         }
         cursor = remoteItems.cursor;
       } while (cursor !== 0);
-      await this.cleanupKeysNotInRedis();
+      if (!this.customizedSync?.withoutOrphanCleanup) {
+        await this.cleanupKeysNotInRedis();
+      }
     } catch (error) {
       console.error("Error during initial sync:", error);
       throw error;
@@ -531,6 +545,37 @@ var jsonCacheValueSerializer = {
   }
 };
 
+// src/utils/cacheTtl.ts
+function resolveCacheEntryTtlSeconds(ctx, data, options) {
+  const expire = ctx.cacheControl?.expire;
+  if (Number.isFinite(expire) && expire > 0) {
+    return Math.max(1, Math.ceil(expire));
+  }
+  const revalidate = resolveRevalidateValue(ctx, data);
+  if (revalidate === false) {
+    return options.estimateExpireAge(options.defaultStaleAge);
+  }
+  if (revalidate && Number.isSafeInteger(revalidate) && revalidate > 0) {
+    return options.estimateExpireAge(revalidate);
+  }
+  return void 0;
+}
+function resolveRevalidateValue(ctx, data) {
+  if (data?.kind === "FETCH" && data.revalidate !== void 0) {
+    return data.revalidate;
+  }
+  if (ctx.revalidate !== void 0) {
+    return ctx.revalidate;
+  }
+  if (ctx.cacheControl?.revalidate !== void 0) {
+    return ctx.cacheControl.revalidate;
+  }
+  if (data?.revalidate !== void 0) {
+    return data.revalidate;
+  }
+  return void 0;
+}
+
 // src/RedisStringsHandler.ts
 function redisErrorHandler(debugInfo, redisCommandResult) {
   const beforeTimestamp = performance.now();
@@ -608,6 +653,7 @@ var RedisStringsHandler = class {
       this.killContainerOnErrorThreshold = killContainerOnErrorThreshold;
       this.getTimeoutMs = getTimeoutMs;
       this.valueSerializer = valueSerializer;
+      this.redisConnectionDeferred = shouldDeferRedisConnection();
       try {
         this.client = (0, import_redis.createClient)({
           url: redisUrl,
@@ -646,12 +692,14 @@ var RedisStringsHandler = class {
             }, 500);
           }
         });
-        this.client.connect().then(() => {
-          debug("green", "Redis client connected.");
-        }).catch((error) => {
-          console.error("Failed to connect Redis client:", error);
-          throw error;
-        });
+        if (!this.redisConnectionDeferred) {
+          this.client.connect().then(() => {
+            debug("green", "Redis client connected.");
+          }).catch((error) => {
+            console.error("Failed to connect Redis client:", error);
+            throw error;
+          });
+        }
       } catch (error) {
         console.error("Failed to initialize Redis client");
         throw error;
@@ -673,6 +721,7 @@ var RedisStringsHandler = class {
         database,
         querySize: revalidateTagQuerySize,
         filterKeys,
+        customizedSync: { withoutOrphanCleanup: true },
         resyncIntervalMs: avgResyncIntervalMs + avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
       this.inMemoryDeduplicationCache = new SyncedMap({
@@ -742,11 +791,17 @@ var RedisStringsHandler = class {
     }
     this.clientReadyCalls = 0;
     if (!this.client.isReady) {
+      if (this.redisConnectionDeferred) {
+        return;
+      }
       throw new Error(
         "assertClientIsReady: Redis client is not ready yet or connection is lost."
       );
     }
   }
+  isClientUnavailable() {
+    return this.redisConnectionDeferred || !this.client.isReady;
+  }
   async get(key, ctx) {
     try {
       if (!SUPPORTED_GET_KINDS.includes(ctx.kind)) {
@@ -760,6 +815,9 @@ var RedisStringsHandler = class {
       }
       debug("green", "RedisStringsHandler.get() called with", key, ctx);
       await this.assertClientIsReady();
+      if (this.isClientUnavailable()) {
+        return null;
+      }
       const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(key) : this.redisGet;
       const redisGetOperation = clientGet(
         (0, import_redis.commandOptions)({ signal: AbortSignal.timeout(this.getTimeoutMs) }),
@@ -893,6 +951,9 @@ var RedisStringsHandler = class {
         );
       }
       await this.assertClientIsReady();
+      if (this.isClientUnavailable()) {
+        return;
+      }
       if (data?.kind === "APP_PAGE" || data?.kind === "APP_ROUTE") {
         const tags = data.headers["x-next-cache-tags"]?.split(",");
         ctx.tags = [...ctx.tags || [], ...tags || []];
@@ -915,18 +976,14 @@ var RedisStringsHandler = class {
           serializedCacheEntry
         );
       }
-      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 || // 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 expireAt = resolveCacheEntryTtlSeconds(ctx, data, {
+        estimateExpireAge: this.estimateExpireAge,
+        defaultStaleAge: this.defaultStaleAge
+      });
       const setOperation = redisErrorHandler(
         "RedisStringsHandler.set(), operation: set " + this.keyPrefix + " " + key,
         this.client.set(this.keyPrefix + key, serializedCacheEntry, {
-          EX: expireAt
+          ...expireAt ? { EX: expireAt } : {}
         })
       );
       debug(
@@ -989,6 +1046,9 @@ var RedisStringsHandler = class {
       );
       const tags = new Set([tagOrTags || []].flat());
       await this.assertClientIsReady();
+      if (this.isClientUnavailable()) {
+        return;
+      }
       const keysToDelete = /* @__PURE__ */ new Set();
       for (const tag of tags) {
         if (tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID)) {
@@ -1127,6 +1187,88 @@ var CachedHandler = class {
 
 // src/CacheComponentsHandler.ts
 var import_redis2 = require("redis");
+
+// src/utils/compareAndUnlink.ts
+var COMPARE_AND_UNLINK = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('UNLINK', KEYS[1])
+end
+return 0
+`;
+async function compareAndUnlink(client, key, expected) {
+  const deleted = await client.eval(COMPARE_AND_UNLINK, {
+    keys: [key],
+    arguments: [expected]
+  });
+  return deleted === 1 || deleted === 1n;
+}
+
+// src/utils/tagRevalidation.ts
+function normalizeTagManifest(stored, now = Date.now()) {
+  if (typeof stored === "number" && Number.isFinite(stored)) {
+    return { expired: Math.min(stored, now) };
+  }
+  if (stored && typeof stored === "object") {
+    const rec = stored;
+    const stale = typeof rec.stale === "number" && Number.isFinite(rec.stale) ? rec.stale : typeof rec.last === "number" && Number.isFinite(rec.last) ? rec.last : void 0;
+    const expired = typeof rec.expired === "number" && Number.isFinite(rec.expired) ? rec.expired : typeof rec.pending === "number" && Number.isFinite(rec.pending) ? rec.pending : void 0;
+    return {
+      ...stale !== void 0 ? { stale } : {},
+      ...expired !== void 0 ? { expired } : {}
+    };
+  }
+  return {};
+}
+function applyTagUpdate(existing, durations, now) {
+  if (durations) {
+    const updates = { ...existing };
+    updates.stale = now;
+    if (durations.expire !== void 0) {
+      updates.expired = now + durations.expire * 1e3;
+    }
+    return updates;
+  }
+  return {
+    ...existing,
+    expired: now
+  };
+}
+function persistableTagManifest(entry, now) {
+  if (typeof entry.expired === "number" && entry.expired <= now && (entry.stale === void 0 || entry.stale <= entry.expired)) {
+    return entry.expired;
+  }
+  return entry;
+}
+function areTagsExpired(tags, entryTimestamp, now, getEntry) {
+  for (const tag of tags) {
+    const expiredAt = getEntry(tag)?.expired;
+    if (typeof expiredAt === "number" && expiredAt <= now && expiredAt > entryTimestamp) {
+      return true;
+    }
+  }
+  return false;
+}
+function areTagsStale(tags, entryTimestamp, getEntry) {
+  for (const tag of tags) {
+    const staleAt = getEntry(tag)?.stale ?? 0;
+    if (typeof staleAt === "number" && staleAt > entryTimestamp) {
+      return true;
+    }
+  }
+  return false;
+}
+function maxExpiredTimestamp(tags, getEntry) {
+  let max = 0;
+  for (const tag of tags) {
+    const expired = getEntry(tag)?.expired || 0;
+    if (expired > max) {
+      max = expired;
+    }
+  }
+  return max;
+}
+
+// src/CacheComponentsHandler.ts
 var REVALIDATED_TAGS_KEY2 = "__cacheComponents_revalidated_tags__";
 var SHARED_TAGS_KEY = "__cacheComponents_sharedTags__";
 var killContainerOnErrorCount2 = 0;
@@ -1184,6 +1326,7 @@ var RedisCacheComponentsHandler = class {
       this.getTimeoutMs = getTimeoutMs;
       this.redisGetDeduplication = redisGetDeduplication;
       this.inMemoryCachingTime = inMemoryCachingTime;
+      this.redisConnectionDeferred = shouldDeferRedisConnection();
       this.client = (0, import_redis2.createClient)({
         url: redisUrl,
         pingInterval: 1e4,
@@ -1219,18 +1362,20 @@ var RedisCacheComponentsHandler = class {
           }, 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;
+      if (!this.redisConnectionDeferred) {
+        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,
@@ -1239,6 +1384,7 @@ var RedisCacheComponentsHandler = class {
         database,
         querySize: revalidateTagQuerySize,
         filterKeys,
+        customizedSync: { withoutOrphanCleanup: true },
         resyncIntervalMs: avgResyncIntervalMs + avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
       this.sharedTagsMap = new SyncedMap({
@@ -1276,6 +1422,13 @@ var RedisCacheComponentsHandler = class {
     }
   }
   async assertClientIsReady() {
+    if (this.redisConnectionDeferred) {
+      await Promise.all([
+        this.revalidatedTagsMap.waitUntilReady(),
+        this.sharedTagsMap.waitUntilReady()
+      ]);
+      return;
+    }
     if (!this.client.isReady && !this.client.isOpen) {
       await this.client.connect().catch((error) => {
         console.error(
@@ -1290,57 +1443,76 @@ var RedisCacheComponentsHandler = class {
       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;
+  isClientUnavailable() {
+    return this.redisConnectionDeferred || !this.client.isReady;
   }
-  async get(cacheKey, softTags) {
+  tagManifestFor(tag, now = Date.now()) {
+    return normalizeTagManifest(this.revalidatedTagsMap.get(tag), now);
+  }
+  async get(cacheKey, _softTags) {
+    void _softTags;
     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.redisGetDeduplication ? " deduplicated" : "") + " " + this.getTimeoutMs + "ms " + redisKey,
-        clientGet(
+      if (this.isClientUnavailable()) {
+        return void 0;
+      }
+      const readSerialized = (useDedup) => redisErrorHandler(
+        "RedisCacheComponentsHandler.get(), operation: get" + (useDedup ? " deduplicated" : "") + " " + this.getTimeoutMs + "ms " + redisKey,
+        (useDedup ? this.deduplicatedRedisGet(cacheKey) : this.redisGet)(
           (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;
+      let usedDedup = this.redisGetDeduplication;
+      let serialized = await readSerialized(usedDedup);
+      for (let attempt = 0; attempt < 2; attempt++) {
+        if (!serialized) {
+          return void 0;
+        }
+        const stored = JSON.parse(serialized);
+        const now = Date.now();
+        const tags = stored.tags || [];
+        const expiryTime = stored.timestamp + stored.expire * 1e3;
+        const ttlExpired = Number.isFinite(stored.expire) && stored.expire > 0 && now > expiryTime;
+        const tagsExpired = areTagsExpired(
+          tags,
+          stored.timestamp,
+          now,
+          (tag) => this.tagManifestFor(tag, now)
+        );
+        if (ttlExpired || tagsExpired) {
+          if (usedDedup) {
+            usedDedup = false;
+            serialized = await readSerialized(false);
+            continue;
+          }
+          const dropped = await compareAndUnlink(
+            this.client,
+            redisKey,
+            serialized
+          );
+          if (dropped) {
+            await this.sharedTagsMap.delete(cacheKey).catch(() => {
+            });
+          }
+          return void 0;
+        }
+        const valueBuffer = typeof stored.value === "string" ? new Uint8Array(Buffer.from(stored.value, "base64")) : stored.value;
+        const entry = {
+          ...stored,
+          value: bufferToReadableStream(valueBuffer)
+        };
+        if (areTagsStale(
+          tags,
+          stored.timestamp,
+          (tag) => this.tagManifestFor(tag, now)
+        )) {
+          entry.revalidate = -1;
+        }
+        return entry;
       }
-      const valueBuffer = typeof stored.value === "string" ? new Uint8Array(Buffer.from(stored.value, "base64")) : stored.value;
-      return {
-        ...stored,
-        value: bufferToReadableStream(valueBuffer)
-      };
+      return void 0;
     } 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:",
@@ -1353,6 +1525,9 @@ var RedisCacheComponentsHandler = class {
   async set(cacheKey, pendingEntry) {
     try {
       await this.assertClientIsReady();
+      if (this.isClientUnavailable()) {
+        return;
+      }
       const entry = await pendingEntry;
       const [storeStream] = entry.value.tee();
       const buffer = await streamToBuffer(storeStream);
@@ -1416,7 +1591,7 @@ var RedisCacheComponentsHandler = class {
   async getExpiration(tags) {
     try {
       await this.assertClientIsReady();
-      return this.computeMaxRevalidation(tags || []);
+      return maxExpiredTimestamp(tags || [], (tag) => this.tagManifestFor(tag));
     } catch (error) {
       console.error(
         "RedisCacheComponentsHandler.getExpiration() Error occurred while getting expiration for tags. The original error was:",
@@ -1425,37 +1600,28 @@ var RedisCacheComponentsHandler = class {
       return 0;
     }
   }
-  async updateTags(tags, _durations) {
+  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) {
+      if (this.isClientUnavailable()) {
         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 now = Date.now();
+      const updated = new Set(tags || []);
+      for (const tag of updated) {
+        const next = applyTagUpdate(this.tagManifestFor(tag), durations, now);
+        await this.revalidatedTagsMap.set(
+          tag,
+          persistableTagManifest(next, now)
+        );
+      }
       if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
-        for (const key of keysToDelete) {
-          this.inMemoryDeduplicationCache.delete(key);
+        for (const [key, sharedTags] of this.sharedTagsMap.entries()) {
+          if (sharedTags.some((tag) => updated.has(tag))) {
+            await this.inMemoryDeduplicationCache.delete(key, true);
+          }
         }
       }
-      const deleteTagsOperation = this.sharedTagsMap.delete(cacheKeys);
-      await deleteTagsOperation;
     } catch (error) {
       console.error(
         "RedisCacheComponentsHandler.updateTags() Error occurred while updating tags. The original error was:",
@@ -1499,6 +1665,8 @@ var index_default = CachedHandler;
   bufferAndMapReviver,
   getRedisCacheComponentsHandler,
   jsonCacheValueSerializer,
-  redisCacheHandler
+  redisCacheHandler,
+  resolveCacheEntryTtlSeconds,
+  shouldDeferRedisConnection
 });
 //# sourceMappingURL=index.js.map