feat: initial implementation

Author: pieh

src/run/handlers/server.ts

@@ -25,6 +25,7 @@ import { setupWaitUntil } from './wait-until.cjs'
 setFetchBeforeNextPatchedIt(globalThis.fetch)
 // configure some globals that Next.js make use of before we start importing any Next.js code
 // as some globals are consumed at import time
+// TODO: only call this if Next.js version is using CacheHandlerV2 as we don't have V1 compatible implementation
 configureUseCacheHandlers()
 setupWaitUntil()
 

src/run/handlers/tags-handler.cts

@@ -2,17 +2,55 @@ import { purgeCache } from '@netlify/functions'
 
 import { name as nextRuntimePkgName, version as nextRuntimePkgVersion } from '../../../package.json'
 import { TagManifest } from '../../shared/blob-types.cjs'
-import { getMemoizedKeyValueStoreBackedByRegionalBlobStore } from '../storage/storage.cjs'
+import {
+  getMemoizedKeyValueStoreBackedByRegionalBlobStore,
+  MemoizedKeyValueStoreBackedByRegionalBlobStore,
+} from '../storage/storage.cjs'
 
 import { getLogger, getRequestContext } from './request-context.cjs'
 
 const purgeCacheUserAgent = `${nextRuntimePkgName}@${nextRuntimePkgVersion}`
 
+/**
+ * Get timestamp of the last revalidation for a tag
+ */
+async function lastTagRevalidationTimestamp(
+  tag: string,
+  cacheStore: MemoizedKeyValueStoreBackedByRegionalBlobStore,
+): Promise<number | null> {
+  const tagManifest = await cacheStore.get<TagManifest>(tag, 'tagManifest.get')
+  if (!tagManifest) {
+    return null
+  }
+  return tagManifest.revalidatedAt
+}
+
+/**
+ *
+ */
+export async function getMostRecentTagRevalidationTimestamp(tags: string[]) {
+  if (tags.length === 0) {
+    return 0
+  }
+
+  const cacheStore = getMemoizedKeyValueStoreBackedByRegionalBlobStore({ consistency: 'strong' })
+
+  const timestampsOrNulls = await Promise.all(
+    tags.map((tag) => lastTagRevalidationTimestamp(tag, cacheStore)),
+  )
+
+  const timestamps = timestampsOrNulls.filter((timestamp) => timestamp !== null)
+  if (timestamps.length === 0) {
+    return 0
+  }
+  return Math.max(...timestamps)
+}
+
 /**
  * Check if any of the tags were invalidated since the given timestamp
  */
 export function isAnyTagStale(tags: string[], timestamp: number): Promise<boolean> {
-  if (tags.length === 0) {
+  if (tags.length === 0 || !timestamp) {
     return Promise.resolve(false)
   }
 
@@ -22,17 +60,14 @@ export function isAnyTagStale(tags: string[], timestamp: number): Promise<boolea
     const tagManifestPromises: Promise<boolean>[] = []
 
     for (const tag of tags) {
-      const tagManifestPromise: Promise<TagManifest | null> = cacheStore.get<TagManifest>(
-        tag,
-        'tagManifest.get',
-      )
+      const lastRevalidationTimestampPromise = lastTagRevalidationTimestamp(tag, cacheStore)
 
       tagManifestPromises.push(
-        tagManifestPromise.then((tagManifest) => {
-          if (!tagManifest) {
+        lastRevalidationTimestampPromise.then((lastRevalidationTimestamp) => {
+          if (!lastRevalidationTimestamp) {
             return false
           }
-          const isStale = tagManifest.revalidatedAt >= (timestamp || Date.now())
+          const isStale = lastRevalidationTimestamp >= timestamp
           if (isStale) {
             resolve(true)
             return true