feat: add additional paths for routes

Author: orinokai

packages/runtime/src/templates/getHandler.ts

@@ -29,7 +29,7 @@ type Mutable<T> = {
 }
 
 // We return a function and then call `toString()` on it to serialise it as the launcher function
-// eslint-disable-next-line max-params
+// eslint-disable-next-line max-params, max-lines-per-function
 const makeHandler = (conf: NextConfig, app, pageRoot, staticManifest: Array<[string, string]> = [], mode = 'ssr') => {
   // Change working directory into the site root, unless using Nx, which moves the
   // dist directory and handles this itself
@@ -66,21 +66,29 @@ const makeHandler = (conf: NextConfig, app, pageRoot, staticManifest: Array<[str
   // the first request because we need the host and port.
   let bridge: NodeBridge
   const getBridge = (event: HandlerEvent, context: HandlerContext): NodeBridge => {
+    const {
+      clientContext: { custom: customContext },
+    } = context
+
     if (bridge) {
       return bridge
     }
     const url = new URL(event.rawUrl)
     const port = Number.parseInt(url.port) || 80
     base = url.origin
 
-    const nextServer = new NetlifyNextServer({
-      conf,
-      dir,
-      customServer: false,
-      hostname: url.hostname,
-      port,
-      netlifyRevalidateToken: context.clientContext?.custom?.odb_refresh_hooks,
-    })
+    const nextServer = new NetlifyNextServer(
+      {
+        conf,
+        dir,
+        customServer: false,
+        hostname: url.hostname,
+        port,
+      },
+      {
+        revalidateToken: customContext.odb_refresh_hooks,
+      },
+    )
     const requestHandler = nextServer.getRequestHandler()
     const server = new Server(async (req, res) => {
       try {

packages/runtime/src/templates/handlerUtils.ts

@@ -224,6 +224,9 @@ export const normalizePath = (event: HandlerEvent) => {
   return new URL(event.rawUrl).pathname
 }
 
+/**
+ * Simple Netlify API client
+ */
 export const netlifyApiFetch = <T>({
   endpoint,
   payload,
@@ -266,3 +269,44 @@ export const netlifyApiFetch = <T>({
     req.write(body)
     req.end()
   })
+
+/**
+ * Get all paths related to a route including data, i18n and rsc routes
+ */
+export const getPathsForRoute = (
+  route: string,
+  buildId: string,
+  i18n?: {
+    defaultLocale: string
+    locales: string[]
+  },
+): string[] => {
+  const routes = []
+  // static files
+  routes.push(...localizeRoute(route, i18n))
+  // data routes
+  routes.push(
+    ...localizeRoute(route.endsWith('/') ? route.slice(0, -1) || '/index' : route, i18n, true).map(
+      (localizeRoute) => `/_next/data/${buildId}${localizeRoute}.json`,
+    ),
+  )
+  // rsc routes
+  routes.push(route.endsWith('/') ? `${route.slice(0, -1) || '/index'}.rsc/` : `${route}.rsc`)
+  return routes
+}
+
+/**
+ * Localize a route based on i18n config
+ * (don't localize if i18n is not configured or if the route is the default locale and not a data route)
+ */
+export const localizeRoute = (
+  route: string,
+  i18n?: {
+    defaultLocale: string
+    locales: string[]
+  },
+  data = false,
+): string[] =>
+  i18n
+    ? i18n.locales.map((locale) => (locale === i18n.defaultLocale && data === false ? route : `/${locale}${route}`))
+    : [route]

packages/runtime/src/templates/server.ts

@@ -1,52 +1,43 @@
 import { NodeRequestHandler, Options } from 'next/dist/server/next-server'
 
-// import { netlifyRoutesForNextRoute } from '../helpers/utils'
-
-import { netlifyApiFetch, getNextServer, NextServerType } from './handlerUtils'
+import { netlifyApiFetch, getNextServer, NextServerType, getPathsForRoute } from './handlerUtils'
 
 const NextServer: NextServerType = getNextServer()
 
-interface NetlifyNextServerOptions extends Options {
-  netlifyRevalidateToken?: string
+interface NetlifyOptions {
+  revalidateToken?: string
 }
 
 class NetlifyNextServer extends NextServer {
-  private netlifyRevalidateToken?: string
+  private netlifyOptions: NetlifyOptions
 
-  public constructor(options: NetlifyNextServerOptions) {
+  public constructor(options: Options, netlifyOptions: NetlifyOptions) {
     super(options)
-    this.netlifyRevalidateToken = options.netlifyRevalidateToken
+    this.netlifyOptions = netlifyOptions
   }
 
   public getRequestHandler(): NodeRequestHandler {
     const handler = super.getRequestHandler()
     return async (req, res, parsedUrl) => {
-      // on-demand revalidation request
       if (req.headers['x-prerender-revalidate']) {
+        // handle on-demand revalidation by purging the ODB cache
         await this.netlifyRevalidate(req.url)
       }
+      // handle the original res.revalidate() request
       return handler(req, res, parsedUrl)
     }
   }
 
-  private async netlifyRevalidate(url: string) {
+  private async netlifyRevalidate(route: string) {
     try {
-      // call netlify API to revalidate the path, including its data routes
+      // call netlify API to revalidate the path
       const result = await netlifyApiFetch<{ ok: boolean; code: number; message: string }>({
         endpoint: `sites/${process.env.SITE_ID}/refresh_on_demand_builders`,
         payload: {
-          paths: [
-            url,
-            // ...netlifyRoutesForNextRoute({
-            //   route: url,
-            //   buildId: this.buildId,
-            //   i18n: this.nextConfig.i18n,
-            // }),
-            // url.endsWith('/') ? `${url.slice(0, -1)}.rsc/` : `${url}.rsc`,
-          ],
+          paths: getPathsForRoute(route, this.buildId, this.nextConfig?.i18n),
           domain: this.hostname,
         },
-        token: this.netlifyRevalidateToken,
+        token: this.netlifyOptions.revalidateToken,
         method: 'POST',
       })
       if (result.ok !== true) {