fix: don't permamently cache fallback html

Author: pieh

src/build/content/prerendered.ts

@@ -9,6 +9,8 @@ import { glob } from 'fast-glob'
 import pLimit from 'p-limit'
 import { satisfies } from 'semver'
 
+import { FS_BLOBS_MANIFEST } from '../../run/constants.js'
+import { type FSBlobsManifest } from '../../run/next.cjs'
 import { encodeBlobKey } from '../../shared/blobkey.js'
 import type {
   CachedFetchValueForMultipleVersions,
@@ -158,6 +160,11 @@ export const copyPrerenderedContent = async (ctx: PluginContext): Promise<void>
           })
         : false
 
+      const fsBlobsManifest = {
+        fallbackPaths: [],
+        outputRoot: posixJoin(ctx.relativeAppDir, ctx.distDir),
+      } satisfies FSBlobsManifest
+
       await Promise.all([
         ...Object.entries(manifest.routes).map(
           ([route, meta]): Promise<void> =>
@@ -254,6 +261,10 @@ export const copyPrerenderedContent = async (ctx: PluginContext): Promise<void>
         )
         await writeCacheEntry(key, value, lastModified, ctx)
       }
+      await writeFile(
+        join(ctx.serverHandlerDir, FS_BLOBS_MANIFEST),
+        JSON.stringify(fsBlobsManifest),
+      )
     } catch (error) {
       ctx.failBuild('Failed assembling prerendered content for upload', error)
     }

src/run/constants.ts

@@ -5,3 +5,4 @@ export const MODULE_DIR = fileURLToPath(new URL('.', import.meta.url))
 export const PLUGIN_DIR = resolve(`${MODULE_DIR}../../..`)
 // a file where we store the required-server-files config object in to access during runtime
 export const RUN_CONFIG = 'run-config.json'
+export const FS_BLOBS_MANIFEST = 'fs-blobs-manifest.json'

src/run/handlers/request-context.cts

@@ -11,7 +11,7 @@ export type RequestContext = {
   responseCacheGetLastModified?: number
   responseCacheKey?: string
   responseCacheTags?: string[]
-  usedFsRead?: boolean
+  usedFsReadForNonFallback?: boolean
   didPagesRouterOnDemandRevalidate?: boolean
   serverTiming?: string
   routeHandlerRevalidate?: NetlifyCachedRouteValue['revalidate']

src/run/headers.ts

@@ -263,7 +263,7 @@ export const setCacheControlHeaders = (
     cacheControl === null &&
     !headers.has('cdn-cache-control') &&
     !headers.has('netlify-cdn-cache-control') &&
-    requestContext.usedFsRead
+    requestContext.usedFsReadForNonFallback
   ) {
     // handle CDN Cache Control on static files
     headers.set('cache-control', 'public, max-age=0, must-revalidate')

src/run/next.cts

@@ -1,4 +1,4 @@
-import fs from 'fs/promises'
+import fs, { readFile } from 'fs/promises'
 import { relative, resolve } from 'path'
 
 // @ts-expect-error no types installed
@@ -80,6 +80,27 @@ console.timeEnd('import next server')
 
 type FS = typeof import('fs')
 
+export type FSBlobsManifest = {
+  fallbackPaths: string[]
+  outputRoot: string
+}
+
+function normalizeStaticAssetPath(path: string) {
+  return path.startsWith('/') ? path : `/${path}`
+}
+
+let fsBlobsManifestPromise: Promise<FSBlobsManifest> | undefined
+const getFSBlobsManifest = (): Promise<FSBlobsManifest> => {
+  if (!fsBlobsManifestPromise) {
+    fsBlobsManifestPromise = (async () => {
+      const { FS_BLOBS_MANIFEST, PLUGIN_DIR } = await import('./constants.js')
+      return JSON.parse(await readFile(resolve(PLUGIN_DIR, FS_BLOBS_MANIFEST), 'utf-8'))
+    })()
+  }
+
+  return fsBlobsManifestPromise
+}
+
 export async function getMockedRequestHandlers(...args: Parameters<typeof getRequestHandlers>) {
   const tracer = getTracer()
   return tracer.withActiveSpan('mocked request handler', async () => {
@@ -96,13 +117,17 @@ export async function getMockedRequestHandlers(...args: Parameters<typeof getReq
       } catch (error) {
         // only try to get .html files from the blob store
         if (typeof path === 'string' && path.endsWith('.html')) {
+          const fsBlobsManifest = await getFSBlobsManifest()
+
           const store = getRegionalBlobStore()
-          const relPath = relative(resolve('.next/server/pages'), path)
+          const relPath = relative(resolve(fsBlobsManifest.outputRoot, '/server/pages'), path)
           const file = await store.get(await encodeBlobKey(relPath))
           if (file !== null) {
-            const requestContext = getRequestContext()
-            if (requestContext) {
-              requestContext.usedFsRead = true
+            if (!fsBlobsManifest.fallbackPaths.includes(normalizeStaticAssetPath(relPath))) {
+              const requestContext = getRequestContext()
+              if (requestContext) {
+                requestContext.usedFsReadForNonFallback = true
+              }
             }
 
             return file