fix: use response cache key for tag manifest first before falling back to pathname (#280)

* test: add i18n+basePath page router fixture, add tests for cache-tag correctness

* fix: use response cache key for tag manifest first before falling back to pathname

* fix: mark request as on-demand revalidate so we purge cdn cache tag after updating response cache

Author: pieh

src/run/handlers/cache.cts

@@ -177,6 +177,18 @@ export class NetlifyCacheHandler implements CacheHandler {
         lastModified,
         value: data,
       })
+
+      if (data?.kind === 'PAGE') {
+        const requestContext = getRequestContext()
+        if (requestContext?.didPagesRouterOnDemandRevalidate) {
+          const tag = `_N_T_${key === '/index' ? '/' : key}`
+          console.debug('Purging CDN cache for:', [tag])
+          purgeCache({ tags: [tag] }).catch((error) => {
+            // TODO: add reporting here
+            console.error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`, error)
+          })
+        }
+      }
       span.end()
     })
   }

src/run/handlers/request-context.cts

@@ -4,6 +4,7 @@ export type RequestContext = {
   responseCacheGetLastModified?: number
   responseCacheKey?: string
   usedFsRead?: boolean
+  didPagesRouterOnDemandRevalidate?: boolean
 }
 
 type RequestContextAsyncLocalStorage = AsyncLocalStorage<RequestContext>

src/run/handlers/server.ts

@@ -51,10 +51,10 @@ export default async (request: Request) => {
   return await tracer.startActiveSpan('generate response', async (span) => {
     const { req, res } = toReqRes(request)
 
-    const resProxy = nextResponseProxy(res)
-
     const requestContext = createRequestContext()
 
+    const resProxy = nextResponseProxy(res, requestContext)
+
     // We don't await this here, because it won't resolve until the response is finished.
     const nextHandlerPromise = runWithRequestContext(requestContext, () =>
       nextHandler(req, resProxy).catch((error) => {
@@ -83,7 +83,7 @@ export default async (request: Request) => {
     await adjustDateHeader({ headers: response.headers, request, span, tracer, requestContext })
 
     setCacheControlHeaders(response.headers, request, requestContext)
-    setCacheTagsHeaders(response.headers, request, tagsManifest)
+    setCacheTagsHeaders(response.headers, request, tagsManifest, requestContext)
     setVaryHeaders(response.headers, request, nextConfig)
     setCacheStatusHeader(response.headers)
 

src/run/headers.ts

@@ -213,8 +213,18 @@ export const setCacheControlHeaders = (
   }
 }
 
-export const setCacheTagsHeaders = (headers: Headers, request: Request, manifest: TagsManifest) => {
-  const path = new URL(request.url).pathname
+function getCanonicalPathFromCacheKey(cacheKey: string | undefined): string | undefined {
+  return cacheKey === '/index' ? '/' : cacheKey
+}
+
+export const setCacheTagsHeaders = (
+  headers: Headers,
+  request: Request,
+  manifest: TagsManifest,
+  requestContext: RequestContext,
+) => {
+  const path =
+    getCanonicalPathFromCacheKey(requestContext.responseCacheKey) ?? new URL(request.url).pathname
   const tags = manifest[path]
   if (tags !== undefined) {
     headers.set('netlify-cache-tag', tags)

src/run/revalidate.ts

@@ -1,24 +1,17 @@
 import type { ServerResponse } from 'node:http'
 
-import { purgeCache } from '@netlify/functions'
+import type { RequestContext } from './handlers/request-context.cjs'
 
 // Needing to proxy the response object to intercept the revalidate call for on-demand revalidation on page routes
-export const nextResponseProxy = (res: ServerResponse) => {
+export const nextResponseProxy = (res: ServerResponse, requestContext: RequestContext) => {
   return new Proxy(res, {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get(target: any[string], key: string) {
       const originalValue = target[key]
       if (key === 'revalidate') {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return async function newRevalidate(...args: any[]) {
-          try {
-            console.debug('Purging cache for:', [args[0]])
-            await purgeCache({ tags: [`_N_T_${args[0]}`] })
-          } catch {
-            throw new Error(
-              `An internal error occurred while trying to purge cache for ${args[0]}}`,
-            )
-          }
+          requestContext.didPagesRouterOnDemandRevalidate = true
           return originalValue?.apply(target, args)
         }
       }