@netlify/plugin-nextjs 4.30.2 → 4.30.3

package/lib/helpers/edge.js

@@ -87,6 +87,7 @@ const IMPORT_UNSUPPORTED = [
 const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) => {
     const { publish } = netlifyConfig.build;
     const chunks = [preamble];
+    chunks.push(`export const _DEFINITION = ${JSON.stringify(edgeFunctionDefinition)}`);
     if ('wasm' in edgeFunctionDefinition) {
         for (const { name, filePath } of edgeFunctionDefinition.wasm) {
             const wasm = await fs_1.promises.readFile((0, path_1.join)(publish, filePath));
@@ -289,13 +290,17 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
             });
             manifest.functions.push(...matchers.map((matcher) => middlewareMatcherToEdgeFunctionDefinition(matcher, functionName)));
         }
+        // Functions (i.e. not middleware, but edge SSR and API routes)
         if (typeof middlewareManifest.functions === 'object') {
             // When using the app dir, we also need to check if the EF matches a page
             const appPathRoutesManifest = await (0, exports.loadAppPathRoutesManifest)(netlifyConfig);
+            // A map of all route pages to their page regex. This is used for pages dir and appDir.
             const pageRegexMap = new Map([...(routesManifest.dynamicRoutes || []), ...(routesManifest.staticRoutes || [])].map((route) => [
                 route.page,
                 route.regex,
             ]));
+            // Create a map of pages-dir routes to their data route regex (appDir uses the same route as the HTML)
+            const dataRoutesMap = new Map([...(routesManifest.dataRoutes || [])].map((route) => [route.page, route.dataRouteRegex]));
             for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
                 usesEdge = true;
                 const functionName = sanitizeName(edgeFunctionDefinition.name);
@@ -317,6 +322,16 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
                     // cache: "manual" is currently experimental, so we restrict it to sites that use experimental appDir
                     cache: usesAppDir ? 'manual' : undefined,
                 });
+                // pages-dir page routes also have a data route. If there's a match, add an entry mapping that to the function too
+                const dataRoute = dataRoutesMap.get(edgeFunctionDefinition.page);
+                if (dataRoute) {
+                    manifest.functions.push({
+                        function: functionName,
+                        name: edgeFunctionDefinition.name,
+                        pattern: dataRoute,
+                        cache: usesAppDir ? 'manual' : undefined,
+                    });
+                }
             }
         }
         if (usesEdge) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.30.2",
+  "version": "4.30.3",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [

package/src/templates/edge/bundle.js

@@ -1,7 +1,8 @@
 /**
  * This placeholder is replaced with the compiled Next.js bundle at build time
  * @param {Object} props
- * @param {import("./runtime.ts").RequestData} props.request
+ * @param {import("./function-runtime.ts").RequestData} props.request
  * @returns {Promise<import("../edge-shared/utils.ts").FetchEventResult>}
  */
 export default async ({ request }) => {}
+export const _DEFINITION = { env: [], files: [], page: 'placeholder', name: 'pages_placeholder', matchers: [] }

package/src/templates/edge/function-runtime.ts

@@ -1,6 +1,6 @@
 import type { Context } from 'https://edge.netlify.com'
 // Available at build time
-import edgeFunction from './bundle.js'
+import { _DEFINITION as edgeFunctionDefinition, default as edgeFunction } from './bundle.js'
 import { buildNextRequest, buildResponse, redirectTrailingSlash } from '../edge-shared/utils.ts'
 import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
 
@@ -11,6 +11,7 @@ const handler = async (req: Request, context: Context) => {
     return redirect
   }
   const request = buildNextRequest(req, context, nextConfig)
+  request.headers['x-matched-path'] ||= edgeFunctionDefinition.page
   try {
     const result = await edgeFunction({ request })
     return buildResponse({ result, request: req, context })

package/src/templates/edge-shared/next-utils.ts

@@ -42,6 +42,7 @@ export type Rewrite = {
   basePath?: false
   locale?: false
   has?: RouteHas[]
+  missing?: RouteHas[]
   regex: string
 }
 
@@ -51,6 +52,7 @@ export type Header = {
   locale?: false
   headers: Array<{ key: string; value: string }>
   has?: RouteHas[]
+  missing?: RouteHas[]
   regex: string
 }
 export type Redirect = {
@@ -59,6 +61,7 @@ export type Redirect = {
   basePath?: false
   locale?: false
   has?: RouteHas[]
+  missing?: RouteHas[]
   statusCode?: number
   permanent?: boolean
   regex: string
@@ -138,11 +141,16 @@ export function parseUrl(url: string): ParsedUrl {
 
 // prepare-destination.ts
 // Changed to use WHATWG Fetch Request instead of IncomingMessage
-export function matchHas(req: Pick<Request, 'headers' | 'url'>, has: RouteHas[], query: Params): false | Params {
+export function matchHas(
+  req: Pick<Request, 'headers' | 'url'>,
+  query: Params,
+  has: RouteHas[] = [],
+  missing: RouteHas[] = [],
+): false | Params {
   const params: Params = {}
   const cookies = getCookies(req.headers)
   const url = new URL(req.url)
-  const allMatch = has.every((hasItem) => {
+  const hasMatch = (hasItem: RouteHas) => {
     let value: undefined | string | null
     let key = hasItem.key
 
@@ -189,7 +197,9 @@ export function matchHas(req: Pick<Request, 'headers' | 'url'>, has: RouteHas[],
       }
     }
     return false
-  })
+  }
+
+  const allMatch = has.every((item) => hasMatch(item)) && !missing.some((item) => hasMatch(item))
 
   if (allMatch) {
     return params
@@ -371,6 +381,7 @@ export interface MiddlewareMatcher {
   regexp: string
   locale?: false
   has?: RouteHas[]
+  missing?: RouteHas[]
 }
 
 export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch {
@@ -381,8 +392,8 @@ export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): Middle
         continue
       }
 
-      if (matcher.has) {
-        const hasParams = matchHas(req, matcher.has, query)
+      if (matcher.has || matcher.missing) {
+        const hasParams = matchHas(req, query, matcher.has, matcher.missing)
         if (!hasParams) {
           continue
         }