fix: ensure middleware matchers evaluate default locale

edge-runtime/lib/next-request.ts

@@ -2,103 +2,89 @@ import type { Context } from '@netlify/edge-functions'
 
 import {
   addBasePath,
-  addTrailingSlash,
+  addLocale,
   normalizeDataUrl,
   normalizeLocalePath,
+  normalizeTrailingSlash,
   removeBasePath,
 } from './util.ts'
 
-interface I18NConfig {
-  defaultLocale: string
-  localeDetection?: false
-  locales: string[]
-}
+import type { NextConfig } from 'next/dist/server/config-shared'
+import type { NextRequest, RequestInit } from 'next/dist/server/web/spec-extension/request.js'
 
-export interface RequestData {
-  geo?: {
-    city?: string
-    country?: string
-    region?: string
-    latitude?: string
-    longitude?: string
-    timezone?: string
-  }
-  headers: Record<string, string>
-  ip?: string
-  method: string
-  nextConfig?: {
-    basePath?: string
-    i18n?: I18NConfig | null
-    trailingSlash?: boolean
-    skipMiddlewareUrlNormalize?: boolean
-  }
-  page?: {
-    name?: string
-    params?: { [key: string]: string }
+export type NetlifyNextRequest = Partial<Omit<NextRequest, 'headers'>> &
+  RequestInit & {
+    headers: HeadersInit
   }
-  url: string
-  body?: ReadableStream<Uint8Array>
-  detectedLocale?: string
-}
 
-const normalizeRequestURL = (
-  originalURL: string,
-  nextConfig?: RequestData['nextConfig'],
-): { url: string; detectedLocale?: string } => {
-  const url = new URL(originalURL)
+const normalizeRequest = (url: URL, nextConfig?: NextConfig): URL => {
+  url.pathname = removeBasePath(url.pathname, nextConfig?.basePath)
 
-  let pathname = removeBasePath(url.pathname, nextConfig?.basePath)
+  // We want to run middleware for data requests and expose the URL of the
+  // corresponding pages, so we have to normalize the URLs before running
+  // the handler.
+  url.pathname = normalizeDataUrl(url.pathname)
 
-  // If it exists, remove the locale from the URL and store it
-  const { detectedLocale } = normalizeLocalePath(pathname, nextConfig?.i18n?.locales)
+  // Normalizing the trailing slash based on the `trailingSlash` configuration
+  // property from the Next.js config.
+  url.pathname = normalizeTrailingSlash(url.pathname, nextConfig?.trailingSlash)
 
-  if (!nextConfig?.skipMiddlewareUrlNormalize) {
-    // We want to run middleware for data requests and expose the URL of the
-    // corresponding pages, so we have to normalize the URLs before running
-    // the handler.
-    pathname = normalizeDataUrl(pathname)
+  url.pathname = addBasePath(url.pathname, nextConfig?.basePath)
 
-    // Normalizing the trailing slash based on the `trailingSlash` configuration
-    // property from the Next.js config.
-    if (nextConfig?.trailingSlash) {
-      pathname = addTrailingSlash(pathname)
-    }
-  }
+  return url
+}
 
-  url.pathname = addBasePath(pathname, nextConfig?.basePath)
+export const localizeRequest = (
+  url: URL,
+  nextConfig?: NextConfig,
+): { localizedUrl: URL; locale?: string } => {
+  url.pathname = removeBasePath(url.pathname, nextConfig?.basePath)
+
+  // Detect the locale from the URL
+  const { detectedLocale } = normalizeLocalePath(url.pathname, nextConfig?.i18n?.locales)
+
+  // Add the locale to the URL if not already present
+  url.pathname = addLocale(url.pathname, detectedLocale ?? nextConfig?.i18n?.defaultLocale)
+
+  url.pathname = addBasePath(url.pathname, nextConfig?.basePath)
 
   return {
-    url: url.toString(),
-    detectedLocale,
+    localizedUrl: url,
+    locale: detectedLocale,
   }
 }
 
 export const buildNextRequest = (
   request: Request,
   context: Context,
-  nextConfig?: RequestData['nextConfig'],
-): RequestData => {
-  const { url, method, body, headers } = request
-  const { country, subdivision, city, latitude, longitude, timezone } = context.geo
-  const geo: RequestData['geo'] = {
-    city,
-    country: country?.code,
-    region: subdivision?.code,
-    latitude: latitude?.toString(),
-    longitude: longitude?.toString(),
-    timezone,
-  }
+  nextConfig?: NextConfig,
+): NetlifyNextRequest => {
+  const { method, body, headers } = request
+  const { country, subdivision, city, latitude, longitude } = context.geo
+  const { i18n, basePath, trailingSlash } = nextConfig ?? {}
 
-  const { detectedLocale, url: normalizedUrl } = normalizeRequestURL(url, nextConfig)
+  const url = new URL(request.url)
+  const normalizedUrl = nextConfig?.skipMiddlewareUrlNormalize
+    ? url
+    : normalizeRequest(url, nextConfig)
 
   return {
+    url: normalizedUrl.toString(),
     headers: Object.fromEntries(headers.entries()),
-    geo,
-    url: normalizedUrl,
-    method,
+    geo: {
+      city,
+      country: country?.code,
+      region: subdivision?.code,
+      latitude: latitude?.toString(),
+      longitude: longitude?.toString(),
+    },
     ip: context.ip,
-    body: body ?? undefined,
-    nextConfig,
-    detectedLocale,
+    method,
+    body,
+    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 { RequestData } from './next-request.ts'
+import { NetlifyNextRequest } from './next-request.ts'
 import {
   addBasePath,
   normalizeDataUrl,
@@ -20,20 +20,20 @@ export interface FetchEventResult {
 
 interface BuildResponseOptions {
   context: Context
-  logger: StructuredLogger
+  nextConfig?: NetlifyNextRequest['nextConfig']
+  locale?: string
   request: Request
   result: FetchEventResult
-  nextConfig?: RequestData['nextConfig']
-  requestLocale?: string
+  logger: StructuredLogger
 }
 
 export const buildResponse = async ({
   context,
-  logger,
+  nextConfig,
+  locale,
   request,
   result,
-  nextConfig,
-  requestLocale,
+  logger,
 }: BuildResponseOptions): Promise<Response | void> => {
   logger
     .withFields({ is_nextresponse_next: result.response.headers.has('x-middleware-next') })
@@ -198,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 && requestLocale) {
-    redirect = normalizeLocalizedTarget({ target: redirect, request, nextConfig, requestLocale })
+  if (redirect && locale) {
+    redirect = normalizeLocalizedTarget({ target: redirect, request, nextConfig })
     if (redirect === request.url) {
       logger.withFields({ rewrite_url: rewrite }).debug('Rewrite url is same as original url')
       return
@@ -234,27 +234,27 @@ function normalizeLocalizedTarget({
   target,
   request,
   nextConfig,
-  requestLocale,
+  locale,
 }: {
   target: string
   request: Request
-  nextConfig?: RequestData['nextConfig']
-  requestLocale?: string
+  nextConfig?: NetlifyNextRequest['nextConfig']
+  locale?: string
 }) {
   const targetUrl = new URL(target, request.url)
-
   const normalizedTarget = normalizeLocalePath(targetUrl.pathname, nextConfig?.i18n?.locales)
+  const targetPathname = normalizedTarget.pathname
+  const targetLocale = normalizedTarget.detectedLocale ?? locale
 
-  const locale = normalizedTarget.detectedLocale ?? requestLocale
   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}`, nextConfig?.basePath) || `/`
+      addBasePath(`/${targetLocale}${targetPathname}`, nextConfig?.basePath) || `/`
   } else {
-    targetUrl.pathname = addBasePath(normalizedTarget.pathname, nextConfig?.basePath) || `/`
+    targetUrl.pathname = addBasePath(targetPathname, nextConfig?.basePath) || `/`
   }
   return targetUrl.toString()
 }

edge-runtime/lib/routing.ts

@@ -7,8 +7,8 @@
 
 import type { Key } from '../vendor/deno.land/x/[email protected]/index.ts'
 
-import { compile, pathToRegexp } from '../vendor/deno.land/x/[email protected]/index.ts'
 import { getCookies } from '../vendor/deno.land/[email protected]/http/cookie.ts'
+import { compile, pathToRegexp } from '../vendor/deno.land/x/[email protected]/index.ts'
 
 /*
   ┌─────────────────────────────────────────────────────────────────────────┐

edge-runtime/lib/util.ts

@@ -29,6 +29,19 @@ export const addBasePath = (path: string, basePath?: string) => {
   return path
 }
 
+// add locale prefix if not present, allowing for locale fallbacks
+export const addLocale = (path: string, locale?: string) => {
+  if (
+    locale &&
+    path.toLowerCase() !== `/${locale.toLowerCase()}` &&
+    !path.toLowerCase().startsWith(`/${locale.toLowerCase()}/`) &&
+    !path.toLowerCase().startsWith(`/${locale.toLowerCase()}-`)
+  ) {
+    return `/${locale}${path}`
+  }
+  return path
+}
+
 // https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/i18n/normalize-locale-path.ts
 
 export interface PathLocale {

edge-runtime/middleware.ts

@@ -5,15 +5,15 @@ import nextConfig from './next.config.json' with { type: 'json' }
 
 import { InternalHeaders } from './lib/headers.ts'
 import { logger, LogLevel } from './lib/logging.ts'
-import { buildNextRequest, RequestData } from './lib/next-request.ts'
+import { buildNextRequest, localizeRequest, NetlifyNextRequest } from './lib/next-request.ts'
 import { buildResponse, FetchEventResult } from './lib/response.ts'
 import {
   getMiddlewareRouteMatcher,
   searchParamsToUrlQuery,
   type MiddlewareRouteMatch,
 } from './lib/routing.ts'
 
-type NextHandler = (params: { request: RequestData }) => Promise<FetchEventResult>
+type NextHandler = (params: { request: NetlifyNextRequest }) => Promise<FetchEventResult>
 
 const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
 
@@ -31,34 +31,39 @@ export async function handleMiddleware(
   context: Context,
   nextHandler: NextHandler,
 ) {
-  const nextRequest = buildNextRequest(request, context, nextConfig)
   const url = new URL(request.url)
+  const query = searchParamsToUrlQuery(url.searchParams)
+  const { localizedUrl, locale } = localizeRequest(url, nextConfig)
   const reqLogger = logger
     .withLogLevel(
       request.headers.has(InternalHeaders.NFDebugLogging) ? LogLevel.Debug : LogLevel.Log,
     )
     .withFields({ url_path: url.pathname })
     .withRequestID(request.headers.get(InternalHeaders.NFRequestID))
 
+  // Convert the incoming request to a Next.js request, which includes
+  // normalizing the URL, adding geo and IP information and converting
+  // the headers to a plain object, among other things.
+  const nextRequest = buildNextRequest(request, context, nextConfig)
+
   // 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(url.pathname, request, searchParamsToUrlQuery(url.searchParams))) {
+  if (!matchesMiddleware(localizedUrl.pathname, request, query)) {
     reqLogger.debug('Aborting middleware due to runtime rules')
-
     return
   }
 
   try {
     const result = await nextHandler({ request: nextRequest })
     const response = await buildResponse({
       context,
-      logger: reqLogger,
+      nextConfig: nextRequest.nextConfig,
+      locale,
       request,
       result,
-      requestLocale: nextRequest.detectedLocale,
-      nextConfig,
+      logger: reqLogger,
     })
 
     return response

src/build/functions/edge.ts

@@ -65,10 +65,7 @@ const writeHandlerFile = async (ctx: PluginContext, { matchers, name }: NextDefi
 
   // Writing a file with the matchers that should trigger this function. We'll
   // read this file from the function at runtime.
-  await writeFile(
-    join(handlerRuntimeDirectory, 'matchers.json'),
-    JSON.stringify(augmentMatchers(matchers, ctx)),
-  )
+  await writeFile(join(handlerRuntimeDirectory, 'matchers.json'), JSON.stringify(matchers))
 
   // The config is needed by the edge function to match and normalize URLs. To
   // avoid shipping and parsing a large file at runtime, let's strip it down to

tests/integration/edge-handler.test.ts

@@ -261,27 +261,27 @@ describe("aborts middleware execution when the matcher conditions don't match th
 
     ctx.cleanup?.push(() => origin.stop())
 
-    for (const path of ['/hello', '/en/hello', '/nl-NL/hello', '/nl-NL/about']) {
+    for (const path of ['/hello', '/en/hello', '/nl-NL/about']) {
       const response = await invokeEdgeFunction(ctx, {
         functions: ['___netlify-edge-handler-middleware'],
         origin,
         url: path,
       })
-      expect(response.headers.has('x-hello-from-middleware-res'), `does match ${path}`).toBeTruthy()
+      expect(
+        response.headers.has('x-hello-from-middleware-res'),
+        `does not match ${path}`,
+      ).toBeTruthy()
       expect(await response.text()).toBe('Hello from origin!')
       expect(response.status).toBe(200)
     }
 
-    for (const path of ['/hello/invalid', '/about', '/en/about']) {
+    for (const path of ['/hello/invalid', '/invalid/hello', '/about', '/en/about']) {
       const response = await invokeEdgeFunction(ctx, {
         functions: ['___netlify-edge-handler-middleware'],
         origin,
         url: path,
       })
-      expect(
-        response.headers.has('x-hello-from-middleware-res'),
-        `does not match ${path}`,
-      ).toBeFalsy()
+      expect(response.headers.has('x-hello-from-middleware-res'), `does match ${path}`).toBeFalsy()
       expect(await response.text()).toBe('Hello from origin!')
       expect(response.status).toBe(200)
     }