fix: pass NextConfig in NextRequest (needed even though it's not in the Next types)

Author: orinokai

edge-runtime/lib/next-request.ts

@@ -10,24 +10,12 @@ import {
 } from './util.ts'
 
 import type { NextConfig } from 'next/dist/server/config-shared'
-import type { NextRequest } from 'next/server'
-
-export type NetlifyNextRequest = Pick<
-  NextRequest,
-  'url' | 'headers' | 'geo' | 'ip' | 'method' | 'body'
->
-
-export type NetlifyNextContext = {
-  localizedUrl: string
-  detectedLocale?: string
-  i18n?: NextConfig['i18n']
-  basePath?: NextConfig['basePath']
-  trailingSlash?: NextConfig['trailingSlash']
-}
+import type { NextRequest, RequestInit } from 'next/dist/server/web/spec-extension/request.js'
 
-const normalizeRequestURL = (originalURL: string, nextConfig?: NextConfig): string => {
-  const url = new URL(originalURL)
+export type NetlifyNextRequest = RequestInit &
+  Pick<NextRequest, 'url' | 'headers' | 'geo' | 'ip' | 'method' | 'body'>
 
+const normalizeRequest = (url: URL, nextConfig?: NextConfig): URL => {
   url.pathname = removeBasePath(url.pathname, nextConfig?.basePath)
 
   // We want to run middleware for data requests and expose the URL of the
@@ -41,15 +29,13 @@ const normalizeRequestURL = (originalURL: string, nextConfig?: NextConfig): stri
 
   url.pathname = addBasePath(url.pathname, nextConfig?.basePath)
 
-  return url.toString()
+  return url
 }
 
-const localizeRequestURL = (
-  originalURL: string,
+export const localizeRequest = (
+  url: URL,
   nextConfig?: NextConfig,
-): { localizedUrl: string; detectedLocale?: string } => {
-  const url = new URL(originalURL)
-
+): { localizedUrl: URL; locale?: string } => {
   url.pathname = removeBasePath(url.pathname, nextConfig?.basePath)
 
   // Detect the locale from the URL
@@ -61,28 +47,27 @@ const localizeRequestURL = (
   url.pathname = addBasePath(url.pathname, nextConfig?.basePath)
 
   return {
-    localizedUrl: url.toString(),
-    detectedLocale,
+    localizedUrl: url,
+    locale: detectedLocale,
   }
 }
 
 export const buildNextRequest = (
   request: Request,
   context: Context,
   nextConfig?: NextConfig,
-): { nextRequest: NetlifyNextRequest; nextContext: NetlifyNextContext } => {
-  const { url, method, body, headers } = request
+): NetlifyNextRequest => {
+  const { method, body, headers } = request
   const { country, subdivision, city, latitude, longitude } = context.geo
   const { i18n, basePath, trailingSlash } = nextConfig ?? {}
 
+  const url = new URL(request.url)
   const normalizedUrl = nextConfig?.skipMiddlewareUrlNormalize
     ? url
-    : normalizeRequestURL(url, nextConfig)
-
-  const { localizedUrl, detectedLocale } = localizeRequestURL(normalizedUrl, nextConfig)
+    : normalizeRequest(url, nextConfig)
 
-  const nextRequest: NetlifyNextRequest = {
-    url: normalizedUrl,
+  return {
+    url: normalizedUrl.toString(),
     headers,
     geo: {
       city,
@@ -94,18 +79,10 @@ export const buildNextRequest = (
     ip: context.ip,
     method,
     body,
-  }
-
-  const nextContext = {
-    localizedUrl,
-    detectedLocale,
-    i18n,
-    trailingSlash,
-    basePath,
-  }
-
-  return {
-    nextRequest,
-    nextContext,
+    nextConfig: {
+      i18n,
+      basePath,
+      trailingSlash,
+    },
   }
 }

edge-runtime/lib/response.ts

@@ -4,7 +4,7 @@ import { HTMLRewriter } from '../vendor/deno.land/x/[email protected]/
 import { updateModifiedHeaders } from './headers.ts'
 import type { StructuredLogger } from './logging.ts'
 import { addMiddlewareHeaders, isMiddlewareRequest, isMiddlewareResponse } from './middleware.ts'
-import { NetlifyNextContext } from './next-request.ts'
+import { NetlifyNextRequest } from './next-request.ts'
 import {
   addBasePath,
   normalizeDataUrl,
@@ -20,15 +20,17 @@ export interface FetchEventResult {
 
 interface BuildResponseOptions {
   context: Context
-  nextContext?: NetlifyNextContext
+  config?: NetlifyNextRequest['nextConfig']
+  locale?: string
   request: Request
   result: FetchEventResult
   logger: StructuredLogger
 }
 
 export const buildResponse = async ({
   context,
-  nextContext,
+  config,
+  locale,
   request,
   result,
   logger,
@@ -183,9 +185,9 @@ export const buildResponse = async ({
     }
 
     // respect trailing slash rules to prevent 308s
-    rewriteUrl.pathname = normalizeTrailingSlash(rewriteUrl.pathname, nextContext?.trailingSlash)
+    rewriteUrl.pathname = normalizeTrailingSlash(rewriteUrl.pathname, config?.trailingSlash)
 
-    const target = normalizeLocalizedTarget({ target: rewriteUrl.toString(), request, nextContext })
+    const target = normalizeLocalizedTarget({ target: rewriteUrl.toString(), request, config })
     if (target === request.url) {
       logger.withFields({ rewrite_url: rewrite }).debug('Rewrite url is same as original url')
       return
@@ -196,8 +198,8 @@ export const buildResponse = async ({
   }
 
   // If we are redirecting a request that had a locale in the URL, we need to add it back in
-  if (redirect && nextContext?.detectedLocale) {
-    redirect = normalizeLocalizedTarget({ target: redirect, request, nextContext })
+  if (redirect && locale) {
+    redirect = normalizeLocalizedTarget({ target: redirect, request, config })
     if (redirect === request.url) {
       logger.withFields({ rewrite_url: rewrite }).debug('Rewrite url is same as original url')
       return
@@ -231,26 +233,27 @@ export const buildResponse = async ({
 function normalizeLocalizedTarget({
   target,
   request,
-  nextContext,
+  config,
+  locale,
 }: {
   target: string
   request: Request
-  nextContext?: NetlifyNextContext
+  config?: NetlifyNextRequest['nextConfig']
+  locale?: string
 }) {
   const targetUrl = new URL(target, request.url)
+  const normalizedTarget = normalizeLocalePath(targetUrl.pathname, config?.i18n?.locales)
+  const targetPathname = normalizedTarget.pathname
+  const targetLocale = normalizedTarget.detectedLocale ?? locale
 
-  const normalizedTarget = normalizeLocalePath(targetUrl.pathname, nextContext?.i18n?.locales)
-
-  const locale = normalizedTarget.detectedLocale ?? nextContext?.detectedLocale
   if (
-    locale &&
-    !normalizedTarget.pathname.startsWith(`/api/`) &&
-    !normalizedTarget.pathname.startsWith(`/_next/static/`)
+    targetLocale &&
+    !targetPathname.startsWith(`/api/`) &&
+    !targetPathname.startsWith(`/_next/static/`)
   ) {
-    targetUrl.pathname =
-      addBasePath(`/${locale}${normalizedTarget.pathname}`, nextContext?.basePath) || `/`
+    targetUrl.pathname = addBasePath(`/${targetLocale}${targetPathname}`, config?.basePath) || `/`
   } else {
-    targetUrl.pathname = addBasePath(normalizedTarget.pathname, nextContext?.basePath) || `/`
+    targetUrl.pathname = addBasePath(targetPathname, config?.basePath) || `/`
   }
   return targetUrl.toString()
 }

edge-runtime/middleware.ts

@@ -5,7 +5,7 @@ import nextConfig from './next.config.json' with { type: 'json' }
 
 import { InternalHeaders } from './lib/headers.ts'
 import { logger, LogLevel } from './lib/logging.ts'
-import { buildNextRequest, NetlifyNextRequest } from './lib/next-request.ts'
+import { buildNextRequest, localizeRequest, NetlifyNextRequest } from './lib/next-request.ts'
 import { buildResponse, FetchEventResult } from './lib/response.ts'
 import {
   getMiddlewareRouteMatcher,
@@ -39,14 +39,15 @@ export async function handleMiddleware(
     .withFields({ url_path: url.pathname })
     .withRequestID(request.headers.get(InternalHeaders.NFRequestID))
 
-  const { nextRequest, nextContext } = buildNextRequest(request, context, nextConfig)
-  const { pathname: localizedPath } = new URL(nextContext.localizedUrl)
+  const nextRequest = buildNextRequest(request, context, nextConfig)
+  const { localizedUrl, locale } = localizeRequest(url, nextConfig)
+  const query = searchParamsToUrlQuery(url.searchParams)
 
   // While we have already checked the path when mapping to the edge function,
   // Next.js supports extra rules that we need to check here too, because we
   // might be running an edge function for a path we should not. If we find
   // that's the case, short-circuit the execution.
-  if (!matchesMiddleware(localizedPath, request, searchParamsToUrlQuery(url.searchParams))) {
+  if (!matchesMiddleware(localizedUrl.pathname, request, query)) {
     reqLogger.debug('Aborting middleware due to runtime rules')
     return
   }
@@ -55,7 +56,8 @@ export async function handleMiddleware(
     const result = await nextHandler({ request: nextRequest })
     const response = await buildResponse({
       context,
-      nextContext,
+      config: nextRequest.nextConfig,
+      locale,
       request,
       result,
       logger: reqLogger,