fix: cache and normalize manifest routes

Author: orinokai

packages/runtime/src/templates/handlerUtils.ts

@@ -224,9 +224,7 @@ export const normalizePath = (event: HandlerEvent) => {
   return new URL(event.rawUrl).pathname
 }
 
-/**
- * Simple Netlify API client
- */
+// Simple Netlify API client
 export const netlifyApiFetch = <T>({
   endpoint,
   payload,
@@ -270,57 +268,26 @@ export const netlifyApiFetch = <T>({
     req.end()
   })
 
-/**
- * Remove trailing slash from a route (but not the root route)
- */
-export const removeTrailingSlash = (route: string): string => (route.endsWith('/') ? route.slice(0, -1) || '/' : route)
+// Remove trailing slash from a route (except for the root route)
+export const normalizeRoute = (route: string): string => (route.endsWith('/') ? route.slice(0, -1) || '/' : route)
 
-/**
- * Normalize a data route to include the build ID and index suffix
- *
- * @param route The route to normalize
- * @param buildId The Next.js build ID
- * @param i18n The i18n config from next.config.js
- * @returns The normalized route
- * @example
- * normalizeDataRoute('/_next/data/en.json', 'dev', { defaultLocale: 'en', locales: ['en', 'fr'] }) // '/_next/data/dev/en/index.json'
- */
-export const normalizeDataRoute = (
-  route: string,
-  buildId: string,
-  i18n?: {
-    defaultLocale: string
-    locales: string[]
-  },
-): string => {
-  if (route.endsWith('.rsc')) return route
-  const withBuildId = route.replace(/^\/_next\/data\//, `/_next/data/${buildId}/`)
-  return i18n && i18n.locales.some((locale) => withBuildId.endsWith(`${buildId}/${locale}.json`))
-    ? withBuildId.replace(/\.json$/, '/index.json')
-    : withBuildId
-}
+// Check if a route has a locale prefix (including the root route)
+const isLocalized = (route: string, i18n: { defaultLocale: string; locales: string[] }): boolean =>
+  i18n.locales.some((locale) => route === `/${locale}` || route.startsWith(`/${locale}/`))
 
-/**
- * Ensure that a route has a locale prefix
- *
- * @param route The route to ensure has a locale prefix
- * @param i18n The i18n config from next.config.js
- * @returns The route with a locale prefix
- * @example
- * ensureLocalePrefix('/', { defaultLocale: 'en', locales: ['en', 'fr'] }) // '/en'
- * ensureLocalePrefix('/foo', { defaultLocale: 'en', locales: ['en', 'fr'] }) // '/en/foo'
- * ensureLocalePrefix('/en/foo', { defaultLocale: 'en', locales: ['en', 'fr'] }) // '/en/foo'
- */
-export const ensureLocalePrefix = (
-  route: string,
-  i18n?: {
-    defaultLocale: string
-    locales: string[]
-  },
-): string =>
-  i18n
-    ? // eslint-disable-next-line unicorn/no-nested-ternary
-      i18n.locales.some((locale) => route === `/${locale}` || route.startsWith(`/${locale}/`))
-      ? route
-      : `/${i18n.defaultLocale}${route === '/' ? '' : route}`
-    : route
+// Remove the locale prefix from a route (if any)
+export const unlocalizeRoute = (route: string, i18n: { defaultLocale: string; locales: string[] }): string =>
+  isLocalized(route, i18n) ? `/${route.split('/').slice(2).join('/')}` : route
+
+// Add the default locale prefix to a route (if necessary)
+export const localizeRoute = (route: string, i18n: { defaultLocale: string; locales: string[] }): string =>
+  isLocalized(route, i18n) ? route : normalizeRoute(`/${i18n.defaultLocale}${route}`)
+
+// Normalize a data route to include the locale prefix and remove the index suffix
+export const localizeDataRoute = (dataRoute: string, localizedRoute: string): string => {
+  if (dataRoute.endsWith('.rsc')) return dataRoute
+  const locale = localizedRoute.split('/').find(Boolean)
+  return dataRoute
+    .replace(new RegExp(`/_next/data/(.+?)/(${locale}/)?`), `/_next/data/$1/${locale}/`)
+    .replace(/\/index\.json$/, '.json')
+}

packages/runtime/src/templates/server.ts

@@ -1,40 +1,48 @@
+import { PrerenderManifest } from 'next/dist/build'
 import { NodeRequestHandler, Options } from 'next/dist/server/next-server'
 
 import {
   netlifyApiFetch,
   getNextServer,
   NextServerType,
-  removeTrailingSlash,
-  ensureLocalePrefix,
-  normalizeDataRoute,
+  normalizeRoute,
+  localizeRoute,
+  localizeDataRoute,
+  unlocalizeRoute,
 } from './handlerUtils'
 
 const NextServer: NextServerType = getNextServer()
 
-interface NetlifyOptions {
+interface NetlifyConfig {
   revalidateToken?: string
 }
 
 class NetlifyNextServer extends NextServer {
-  private netlifyOptions: NetlifyOptions
+  private netlifyConfig: NetlifyConfig
+  private netlifyPrerenderManifest: PrerenderManifest
 
-  public constructor(options: Options, netlifyOptions: NetlifyOptions) {
+  public constructor(options: Options, netlifyConfig: NetlifyConfig) {
     super(options)
-    this.netlifyOptions = netlifyOptions
+    this.netlifyConfig = netlifyConfig
+    // copy the prerender manifest so it doesn't get mutated by Next.js
+    const manifest = this.getPrerenderManifest()
+    this.netlifyPrerenderManifest = {
+      ...manifest,
+      routes: { ...manifest.routes },
+      dynamicRoutes: { ...manifest.dynamicRoutes },
+    }
   }
 
   public getRequestHandler(): NodeRequestHandler {
     const handler = super.getRequestHandler()
     return async (req, res, parsedUrl) => {
       // preserve the URL before Next.js mutates it for i18n
-      const originalUrl = req.url
-
+      const { url, headers } = req
       // handle the original res.revalidate() request
       await handler(req, res, parsedUrl)
-
       // handle on-demand revalidation by purging the ODB cache
-      if (res.statusCode === 200 && req.headers['x-prerender-revalidate']) {
-        await this.netlifyRevalidate(originalUrl)
+      if (res.statusCode === 200 && headers['x-prerender-revalidate'] && this.netlifyConfig.revalidateToken) {
+        await this.netlifyRevalidate(url)
       }
     }
   }
@@ -48,7 +56,7 @@ class NetlifyNextServer extends NextServer {
           paths: this.getNetlifyPathsForRoute(route),
           domain: this.hostname,
         },
-        token: this.netlifyOptions.revalidateToken,
+        token: this.netlifyConfig.revalidateToken,
         method: 'POST',
       })
       if (!result.ok) {
@@ -61,39 +69,43 @@ class NetlifyNextServer extends NextServer {
   }
 
   private getNetlifyPathsForRoute(route: string): string[] {
-    const { routes, dynamicRoutes } = this.getPrerenderManifest()
+    const { i18n } = this.nextConfig
+    const { routes, dynamicRoutes } = this.netlifyPrerenderManifest
 
-    // matches static appDir and non-i18n routes
-    const normalizedRoute = removeTrailingSlash(route)
+    // matches static non-i18n routes
+    const normalizedRoute = normalizeRoute(route)
     if (normalizedRoute in routes) {
-      const dataRoute = normalizeDataRoute(routes[normalizedRoute].dataRoute, this.buildId)
+      const { dataRoute } = routes[normalizedRoute]
       return [route, dataRoute]
     }
 
-    // matches static pageDir i18n routes
-    const localizedRoute = ensureLocalePrefix(normalizedRoute, this.nextConfig?.i18n)
-    if (localizedRoute in routes) {
-      const dataRoute = normalizeDataRoute(routes[localizedRoute].dataRoute, this.buildId, this.nextConfig?.i18n)
-      return [route, dataRoute]
+    // matches static i18n routes
+    if (i18n) {
+      const localizedRoute = localizeRoute(normalizedRoute, i18n)
+      if (localizedRoute in routes) {
+        const dataRoute = localizeDataRoute(routes[localizedRoute].dataRoute, localizedRoute)
+        return [route, dataRoute]
+      }
     }
 
     // matches dynamic routes
     for (const dynamicRoute in dynamicRoutes) {
-      const matches = normalizedRoute.match(dynamicRoutes[dynamicRoute].routeRegex)
+      const unlocalizedRoute = i18n ? unlocalizeRoute(normalizedRoute, i18n) : normalizedRoute
+      const matches = unlocalizedRoute.match(dynamicRoutes[dynamicRoute].routeRegex)
       if (matches && matches.length !== 0) {
         // remove the first match, which is the full route
         matches.shift()
         // replace the dynamic segments with the actual values
-        const dataRoute = normalizeDataRoute(
-          dynamicRoutes[dynamicRoute].dataRoute.replace(/\[(.*?)]/g, () => matches.shift()),
-          this.buildId,
-        )
+        const interpolatedDataRoute = dynamicRoutes[dynamicRoute].dataRoute.replace(/\[(.*?)]/g, () => matches.shift())
+        const dataRoute = i18n
+          ? localizeDataRoute(interpolatedDataRoute, localizeRoute(normalizedRoute, i18n))
+          : interpolatedDataRoute
         return [route, dataRoute]
       }
     }
 
-    throw new Error(`could not find a route to revalidate`)
+    throw new Error(`not an ISR route`)
   }
 }
 
-export { NetlifyNextServer }
+export { NetlifyNextServer, NetlifyConfig }