@leejpsd/nextjs-cache-handler 0.3.1 → 0.3.3

package/dist/index.js

@@ -979,47 +979,54 @@ async function getImpl(state, cacheKey, softTags) {
     });
     return void 0;
   }
-  if (softTags.length > 0) {
+  const freshnessTags = softTags.length > 0 ? [...softTags, ...envelope.tags] : envelope.tags;
+  let tagStale = false;
+  if (freshnessTags.length > 0) {
     let mostRecent = 0;
-    for (const t of softTags) {
+    for (const t of freshnessTags) {
       const ts = state.localTagTimestamps.get(t);
       if (ts !== void 0 && ts > mostRecent) mostRecent = ts;
     }
     if (mostRecent > envelope.timestamp) {
-      state.emit({
-        type: "cache.miss",
-        meta: { reason: "soft-tag-invalidated" }
-      });
-      return void 0;
+      if (state.opts.staleWhileRevalidate && partition.freshness !== "expired") {
+        tagStale = true;
+      } else {
+        state.emit({ type: "cache.miss", meta: { reason: "tag-invalidated" } });
+        return void 0;
+      }
     }
   }
-  if (partition.freshness === "stale") {
+  const freshness = tagStale ? "stale" : partition.freshness;
+  if (freshness === "stale") {
+    const staleMeta = tagStale ? { freshness, reason: "tag-invalidated" } : { freshness };
     if (state.opts.singleFlight) {
       const isLeader = await tryAcquireRefreshLock(state, cacheKey);
       state.emit({
         type: isLeader ? "cache.stale.refresh.leader" : "cache.stale.refresh.follower",
         ms: Date.now() - start,
-        meta: { freshness: partition.freshness }
+        meta: staleMeta
       });
     } else {
       state.emit({
         type: "cache.stale",
         ms: Date.now() - start,
-        meta: { freshness: partition.freshness }
+        meta: staleMeta
       });
     }
   } else {
     state.emit({
       type: "cache.hit",
       ms: Date.now() - start,
-      meta: { freshness: partition.freshness }
+      meta: { freshness }
     });
   }
+  const revalidateMs = Math.max(0, envelope.revalidate) * 1e3;
+  const outTimestamp = tagStale ? Math.min(envelope.timestamp, Date.now() - revalidateMs - 1) : envelope.timestamp;
   return {
     value: bufferToStream(Buffer.from(envelope.value, "base64")),
     tags: envelope.tags,
     stale: envelope.stale,
-    timestamp: envelope.timestamp,
+    timestamp: outTimestamp,
     expire: envelope.expire,
     revalidate: envelope.revalidate
   };
@@ -1557,8 +1564,35 @@ var IncrementalRedisCacheHandler = class {
         this.state.emit({ type: "cache.miss", meta: { reason: "tag-state-expired" } });
         return null;
       }
+      let lastModified = parsed.lastModified;
+      if (!isFetch && typeof lastModified === "number") {
+        const softTs = Math.max(
+          0,
+          ...tagStates.map(
+            (s) => s && typeof s.stale === "number" ? s.stale : 0
+          )
+        );
+        if (softTs >= lastModified) {
+          const rev = parsed.revalidateSec;
+          if (typeof rev !== "number" || rev <= 0 || rev >= ONE_YEAR_SEC2) {
+            this.state.emit({
+              type: "cache.miss",
+              meta: { reason: "tag-invalidated" }
+            });
+            return null;
+          }
+          lastModified = Math.min(
+            lastModified,
+            Date.now() - (rev + 1) * 1e3
+          );
+          this.state.emit({
+            type: "cache.stale",
+            meta: { reason: "tag-invalidated" }
+          });
+        }
+      }
       this.state.emit({ type: "cache.hit" });
-      return { ...parsed, tags };
+      return { ...parsed, lastModified, tags };
     } catch (err) {
       this.state.logger.error("get() unexpected error", {
         message: err.message
@@ -1572,7 +1606,11 @@ var IncrementalRedisCacheHandler = class {
       const tags = extractTagsFromValue(data, ctx);
       const useLocal = shouldUseLocalIncrementalStore(tags);
       const ttl = normalizeTtlSeconds(data, ctx);
-      const record = { lastModified: Date.now(), value: data };
+      const record = {
+        lastModified: Date.now(),
+        value: data,
+        revalidateSec: ttl
+      };
       const serialized = serializeCacheRecord(record);
       const eKey = entryKey2(this.state, cacheKey);
       this.requestMemo.delete(eKey);