support dynamic routes

pieh · pieh · commit da1494fb9b97 · 2025-11-02T15:20:31.000+01:00
diff --git a/src/adapter/build/netlify-adapter-context.ts b/src/adapter/build/netlify-adapter-context.ts
@@ -16,6 +16,7 @@ export function createNetlifyAdapterContext(nextAdapterContext: OnBuildCompleteC
     frameworksAPIConfig: undefined as FrameworksAPIConfig | undefined,
     preparedOutputs: {
       staticAssets: [] as string[],
+      staticAssetsAliases: {} as Record<string, string>,
       endpoints: [] as string[],
       middleware: false,
     },
diff --git a/src/adapter/build/pages-and-app-handlers.ts b/src/adapter/build/pages-and-app-handlers.ts
@@ -21,6 +21,8 @@ const PAGES_AND_APP_FUNCTION_DIR = join(
   PAGES_AND_APP_FUNCTION_INTERNAL_NAME,
 )
 
+// const abc: OneOfThePaths = 'asa(/abc/)dsa'
+
 export async function onBuildComplete(
   nextAdapterContext: OnBuildCompleteContext,
   netlifyAdapterContext: NetlifyAdapterContext,
@@ -110,9 +112,13 @@ export async function onBuildComplete(
         return new Response('Not Found', { status: 404 })
       }
 
-      const nextHandler = require('./' + entry).handler
+      const nextHandler = await require('./' + entry)
+
+      if (typeof nextHandler.handler !== 'function') {
+        console.log('.handler is not a function', { nextHandler })
+      }
 
-      return runNextHandler(request, context, nextHandler)
+      return runNextHandler(request, context, nextHandler.handler)
     }
 
     export const config = ${JSON.stringify(functionConfig, null, 2)}
diff --git a/src/adapter/build/routing.ts b/src/adapter/build/routing.ts
@@ -13,6 +13,34 @@ import {
 } from './constants.js'
 import type { NetlifyAdapterContext, OnBuildCompleteContext } from './types.js'
 
+function fixDestinationGroupReplacements(destination: string, sourceRegex: string): string {
+  // convert $nxtPslug to $<nxtPslug> etc
+
+  // find all capturing groups in sourceRegex
+  const segments = [...sourceRegex.matchAll(/\(\?<(?<segment_name>[^>]+)>/g)]
+
+  let adjustedDestination = destination
+  for (const segment of segments) {
+    if (segment.groups?.segment_name) {
+      adjustedDestination = adjustedDestination.replaceAll(
+        `$${segment.groups.segment_name}`,
+        `$<${segment.groups.segment_name}>`,
+      )
+    }
+  }
+
+  if (adjustedDestination !== destination) {
+    console.log('fixing named captured group replacement', {
+      sourceRegex,
+      segments,
+      destination,
+      adjustedDestination,
+    })
+  }
+
+  return adjustedDestination
+}
+
 export function convertRedirectToRoutingRule(
   redirect: Pick<
     OnBuildCompleteContext['routes']['redirects'][number],
@@ -27,11 +55,34 @@ export function convertRedirectToRoutingRule(
     },
     apply: {
       type: 'redirect',
-      destination: redirect.destination,
+      destination: fixDestinationGroupReplacements(redirect.destination, redirect.sourceRegex),
     },
   } satisfies RoutingRuleRedirect
 }
 
+export function convertDynamicRouteToRoutingRule(
+  dynamicRoute: Pick<
+    OnBuildCompleteContext['routes']['dynamicRoutes'][number],
+    'sourceRegex' | 'destination'
+  >,
+  description: string,
+): RoutingRuleRewrite {
+  return {
+    description,
+    match: {
+      path: dynamicRoute.sourceRegex,
+    },
+    apply: {
+      type: 'rewrite',
+      destination: fixDestinationGroupReplacements(
+        dynamicRoute.destination,
+        dynamicRoute.sourceRegex,
+      ),
+      rerunRoutingPhases: ['filesystem', 'rewrite'], // this is attempt to mimic Vercel's check: true
+    },
+  } satisfies RoutingRuleRewrite
+}
+
 export async function generateRoutingRules(
   nextAdapterContext: OnBuildCompleteContext,
   netlifyAdapterContext: NetlifyAdapterContext,
@@ -62,6 +113,34 @@ export async function generateRoutingRules(
     }
   }
 
+  const dynamicRoutes: RoutingRuleRewrite[] = []
+
+  for (const dynamicRoute of nextAdapterContext.routes.dynamicRoutes) {
+    const isNextData = dynamicRoute.sourceRegex.includes('_next/data')
+
+    if (hasPages && !hasMiddleware) {
+      // this was copied from Vercel adapter, not fully sure what it does - especially with the condition
+      // not applying equavalent right now, but leaving it commented out
+      // if (!route.sourceRegex.includes('_next/data') && !addedNextData404Route) {
+      //   addedNextData404Route = true
+      //   dynamicRoutes.push({
+      //     src: path.posix.join('/', config.basePath || '', '_next/data/(.*)'),
+      //     dest: path.posix.join('/', config.basePath || '', '404'),
+      //     status: 404,
+      //     check: true,
+      //   })
+      // }
+    }
+    dynamicRoutes.push(
+      convertDynamicRouteToRoutingRule(
+        dynamicRoute,
+        isNextData
+          ? `Mapping dynamic route _next/data to entrypoint: ${dynamicRoute.destination}`
+          : `Mapping dynamic route to entrypoint: ${dynamicRoute.destination}`,
+      ),
+    )
+  }
+
   const normalizeNextData: RoutingRuleRewrite[] = shouldDenormalizeJsonDataForMiddleware
     ? [
         {
@@ -150,6 +229,12 @@ export async function generateRoutingRules(
     // - User rewrites
     // - Builder rewrites
 
+    {
+      // this is no-op on its own, it's just marker to be able to run subset of routing rules
+      description: "'entry' routing phase marker",
+      routingPhase: 'entry',
+    },
+
     // priority redirects includes trailing slash redirect
     ...priorityRedirects, // originally: ...convertedPriorityRedirects,
 
@@ -260,7 +345,7 @@ export async function generateRoutingRules(
     // and we don't want to match a catch-all dynamic route
 
     // apply normal dynamic routes
-    // ...convertedDynamicRoutes,
+    ...dynamicRoutes, // originally: ...convertedDynamicRoutes,
 
     // apply x-nextjs-matched-path header and __next_data_catchall rewrite
     // if middleware + pages
diff --git a/src/adapter/build/static-assets.ts b/src/adapter/build/static-assets.ts
@@ -36,10 +36,14 @@ export async function onBuildComplete(
         }
 
         // register static asset for routing before applying .html extension for pretty urls
-        netlifyAdapterContext.preparedOutputs.staticAssets.push(distPathname)
+        const extensionLessPathname = distPathname
 
         // if pathname is extension-less, but source file has an .html extension, preserve it
         distPathname += distPathname.endsWith('/') ? 'index.html' : '.html'
+
+        netlifyAdapterContext.preparedOutputs.staticAssets.push(distPathname)
+        netlifyAdapterContext.preparedOutputs.staticAssetsAliases[extensionLessPathname] =
+          distPathname
       } else {
         // register static asset for routing
         netlifyAdapterContext.preparedOutputs.staticAssets.push(distPathname)
diff --git a/src/adapter/run/routing.ts b/src/adapter/run/routing.ts
@@ -4,6 +4,8 @@ import type { Context } from '@netlify/edge-functions'
 
 import type { NetlifyAdapterContext } from '../build/types.js'
 
+export type RoutingPhase = 'entry' | 'filesystem' | 'rewrite'
+
 type RoutingRuleBase = {
   /**
    * Human readable description of the rule (for debugging purposes only)
@@ -41,6 +43,8 @@ export type RoutingRuleRewrite = RoutingRuleBase & {
     destination: string
     /** Forced status code for response, if not defined rewrite response status code will be used */
     statusCode?: 200 | 404 | 500
+    /** Phases to re-run after matching this rewrite */
+    rerunRoutingPhases?: RoutingPhase[]
   }
 }
 
@@ -50,8 +54,6 @@ export type RoutingRuleMatchPrimitive = RoutingRuleBase & {
   }
 }
 
-export type RoutingPhase = 'filesystem' | 'rewrite'
-
 export type RoutingPhaseRule = RoutingRuleBase & {
   routingPhase: RoutingPhase
 }
@@ -62,62 +64,73 @@ export type RoutingRule =
   | RoutingPhaseRule
   | RoutingRuleMatchPrimitive
 
-export function testRedirectRewriteRule(rule: RoutingRuleRedirect, request: Request) {
-  const sourceRegexp = new RegExp(rule.match.path)
-  const { pathname } = new URL(request.url)
-  if (sourceRegexp.test(pathname)) {
-    const replaced = pathname.replace(sourceRegexp, rule.apply.destination)
-    return { matched: true, replaced }
+function selectRoutingPhasesRules(routingRules: RoutingRule[], phases: RoutingPhase[]) {
+  const selectedRules: RoutingRule[] = []
+  let currentPhase: RoutingPhase | undefined
+  for (const rule of routingRules) {
+    if ('routingPhase' in rule) {
+      currentPhase = rule.routingPhase
+    } else if (currentPhase && phases.includes(currentPhase)) {
+      selectedRules.push(rule)
+    }
   }
-  return { matched: false }
+
+  return selectedRules
 }
 
 let requestCounter = 0
 
-export async function runNextRouting(
+function normalizeIndex(request: Request, prefix: string) {
+  const currentURL = new URL(request.url)
+  const { pathname } = currentURL
+  if (pathname === '/') {
+    const destURL = new URL('/index', currentURL)
+    console.log(prefix, 'Normalizing "/" to "/index" for routing purposes')
+    return new Request(destURL, request)
+  }
+  return request
+}
+
+// eslint-disable-next-line max-params
+async function match(
   request: Request,
   context: Context,
   routingRules: RoutingRule[],
   outputs: NetlifyAdapterContext['preparedOutputs'],
+  prefix: string,
 ) {
-  if (request.headers.has('x-ntl-routing')) {
-    // don't route multiple times for same request
-    return
-  }
-
-  const prefix = `[${
-    request.headers.get('x-nf-request-id') ??
-    // for ntl serve, we use a combination of timestamp and pid to have a unique id per request as we don't have x-nf-request-id header then
-    // eslint-disable-next-line no-plusplus
-    `${Date.now()} - #${process.pid}:${++requestCounter}`
-  }]`
-
-  console.log(prefix, 'Incoming request for routing:', request.url)
-
-  let currentRequest = new Request(request)
-  currentRequest.headers.set('x-ntl-routing', '1')
+  let currentRequest = normalizeIndex(request, prefix)
   let maybeResponse: Response | undefined
 
+  const currentURL = new URL(currentRequest.url)
+  let { pathname } = currentURL
+
   for (const rule of routingRules) {
     console.log(prefix, 'Evaluating rule:', rule.description ?? JSON.stringify(rule))
     if ('match' in rule) {
-      const currentURL = new URL(currentRequest.url)
-      const { pathname } = currentURL
-
       if ('type' in rule.match) {
-        const pathnameToMatch = pathname === '/' ? '/index' : pathname
-
         if (rule.match.type === 'static-asset-or-function') {
-          let matchedType: 'static-asset' | 'function' | null = null
+          let matchedType: 'static-asset' | 'function' | 'static-asset-alias' | null = null
 
-          if (outputs.staticAssets.includes(pathnameToMatch)) {
+          // below assumes no overlap between static assets (files and aliases) and functions
+          if (outputs.staticAssets.includes(pathname)) {
             matchedType = 'static-asset'
-          } else if (outputs.endpoints.includes(pathnameToMatch)) {
+          } else if (outputs.endpoints.includes(pathname)) {
             matchedType = 'function'
+          } else {
+            const staticAlias = outputs.staticAssetsAliases[pathname]
+            if (staticAlias) {
+              matchedType = 'static-asset-alias'
+              currentRequest = new Request(new URL(staticAlias, currentRequest.url), currentRequest)
+              pathname = staticAlias
+            }
           }
 
           if (matchedType) {
-            console.log(prefix, `Matched static asset or function (${matchedType}):`)
+            console.log(
+              prefix,
+              `Matched static asset or function (${matchedType}): ${pathname} -> ${currentRequest.url}`,
+            )
             maybeResponse = await context.next(currentRequest)
           }
         } else if (rule.match.type === 'image-cdn' && pathname.startsWith('/.netlify/image/')) {
@@ -146,9 +159,18 @@ export async function runNextRouting(
           const replaced = pathname.replace(sourceRegexp, rule.apply.destination)
 
           if (rule.apply.type === 'rewrite') {
-            console.log(prefix, `Rewriting ${pathname} to ${replaced}`)
             const destURL = new URL(replaced, currentURL)
             currentRequest = new Request(destURL, currentRequest)
+
+            if (rule.apply.rerunRoutingPhases) {
+              maybeResponse = await match(
+                currentRequest,
+                context,
+                selectRoutingPhasesRules(routingRules, rule.apply.rerunRoutingPhases),
+                outputs,
+                prefix,
+              )
+            }
           } else {
             console.log(prefix, `Redirecting ${pathname} to ${replaced}`)
             maybeResponse = new Response(null, {
@@ -163,10 +185,44 @@ export async function runNextRouting(
     }
 
     if (maybeResponse) {
-      // for debugging add log prefixes to response headers to make it easy to find logs for a given request
-      maybeResponse.headers.set('x-ntl-log-prefix', prefix)
-      console.log(prefix, 'Serving response', maybeResponse.status)
       return maybeResponse
     }
   }
 }
+
+export async function runNextRouting(
+  request: Request,
+  context: Context,
+  routingRules: RoutingRule[],
+  outputs: NetlifyAdapterContext['preparedOutputs'],
+) {
+  if (request.headers.has('x-ntl-routing')) {
+    // don't route multiple times for same request
+    return
+  }
+
+  const prefix = `[${
+    request.headers.get('x-nf-request-id') ??
+    // for ntl serve, we use a combination of timestamp and pid to have a unique id per request as we don't have x-nf-request-id header then
+    // eslint-disable-next-line no-plusplus
+    `${Date.now()} - #${process.pid}:${++requestCounter}`
+  }]`
+
+  console.log(prefix, 'Incoming request for routing:', request.url)
+
+  const currentRequest = new Request(request)
+  currentRequest.headers.set('x-ntl-routing', '1')
+
+  let maybeResponse = await match(currentRequest, context, routingRules, outputs, prefix)
+
+  if (!maybeResponse) {
+    console.log(prefix, 'No route matched - 404ing')
+    maybeResponse = new Response('Not Found', { status: 404 })
+  }
+
+  // for debugging add log prefixes to response headers to make it easy to find logs for a given request
+  maybeResponse.headers.set('x-ntl-log-prefix', prefix)
+  console.log(prefix, 'Serving response', maybeResponse.status)
+
+  return maybeResponse
+}
