@netlify/plugin-nextjs 5.0.0-beta.0 → 5.0.0-beta.1

package/dist/build/content/server.js

@@ -8,7 +8,7 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "../../esm-chunks/chunk-G2VRYWGL.js";
+} from "../../esm-chunks/chunk-A22224GM.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/build/content/static.js

@@ -9,7 +9,7 @@ import {
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "../../esm-chunks/chunk-62KDS27E.js";
+} from "../../esm-chunks/chunk-Z7ZMLVTM.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/build/functions/edge.js

@@ -6,8 +6,8 @@
     
 import {
   createEdgeHandlers
-} from "../../esm-chunks/chunk-XD5TSLZO.js";
-import "../../esm-chunks/chunk-HPGTYMVD.js";
+} from "../../esm-chunks/chunk-UXLNY5XK.js";
+import "../../esm-chunks/chunk-VP3PT3VV.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {
   createEdgeHandlers

package/dist/build/functions/server.js

@@ -6,10 +6,10 @@
     
 import {
   createServerHandler
-} from "../../esm-chunks/chunk-PEBUKFKH.js";
-import "../../esm-chunks/chunk-G2VRYWGL.js";
+} from "../../esm-chunks/chunk-NOX2JUQZ.js";
+import "../../esm-chunks/chunk-A22224GM.js";
 import "../../esm-chunks/chunk-AVWFCGVE.js";
-import "../../esm-chunks/chunk-HPGTYMVD.js";
+import "../../esm-chunks/chunk-VP3PT3VV.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {
   createServerHandler

package/dist/build/plugin-context.js

@@ -8,7 +8,7 @@ import {
   EDGE_HANDLER_NAME,
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-HPGTYMVD.js";
+} from "../esm-chunks/chunk-VP3PT3VV.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {
   EDGE_HANDLER_NAME,

package/dist/esm-chunks/{chunk-ZBX3SNQG.js → chunk-5N2CWXSJ.js}

@@ -382,6 +382,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }
@@ -532,9 +535,9 @@ var adjustDateHeader = async (headers, request) => {
   headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
   headers.set("date", lastModifiedDate.toUTCString());
 };
-var setCacheControlHeaders = (headers) => {
+var setCacheControlHeaders = (headers, request) => {
   const cacheControl = headers.get("cache-control");
-  if (cacheControl !== null && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
+  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
     const privateCacheControl = omitHeaderValues(cacheControl, [
       "s-maxage",
       "stale-while-revalidate"

package/dist/esm-chunks/{chunk-G2VRYWGL.js → chunk-A22224GM.js}

@@ -25,13 +25,17 @@ var copyNextServerCode = async (ctx) => {
   });
   await Promise.all(
     paths.map(async (path) => {
+      const srcPath = join(srcDir, path);
       const destPath = join(destDir, path);
       if (path === "server/middleware-manifest.json") {
-        await mkdir(dirname(destPath), { recursive: true });
-        await writeFile(destPath, getEmptyMiddlewareManifest());
+        try {
+          await replaceMiddlewareManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch middleware manifest file", { cause: error });
+        }
         return;
       }
-      await cp(join(srcDir, path), destPath, { recursive: true });
+      await cp(srcPath, destPath, { recursive: true });
     })
   );
 };
@@ -90,14 +94,16 @@ var writeTagsManifest = async (ctx) => {
     "utf-8"
   );
 };
-var getEmptyMiddlewareManifest = () => {
-  const manifest = {
-    sortedMiddleware: [],
-    middleware: {},
-    functions: {},
-    version: 2
+var replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
   };
-  return JSON.stringify(manifest);
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
 };
 
 export {

package/dist/esm-chunks/{chunk-PEBUKFKH.js → chunk-NOX2JUQZ.js}

@@ -8,13 +8,13 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "./chunk-G2VRYWGL.js";
+} from "./chunk-A22224GM.js";
 import {
   require_out
 } from "./chunk-AVWFCGVE.js";
 import {
   SERVER_HANDLER_NAME
-} from "./chunk-HPGTYMVD.js";
+} from "./chunk-VP3PT3VV.js";
 import {
   __toESM
 } from "./chunk-RSKIKBZH.js";

package/dist/esm-chunks/{chunk-XD5TSLZO.js → chunk-UXLNY5XK.js}

@@ -6,7 +6,7 @@
     
 import {
   EDGE_HANDLER_NAME
-} from "./chunk-HPGTYMVD.js";
+} from "./chunk-VP3PT3VV.js";
 
 // src/build/functions/edge.ts
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
@@ -15,15 +15,16 @@ var writeEdgeManifest = async (ctx, manifest) => {
   await mkdir(ctx.edgeFunctionsDir, { recursive: true });
   await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
 };
-var writeHandlerFile = async (ctx, { name }) => {
+var writeHandlerFile = async (ctx, { matchers, name }) => {
   const handlerName = getHandlerName({ name });
-  await cp(
-    join(ctx.pluginDir, "edge-runtime"),
-    join(ctx.edgeFunctionsDir, handlerName, "edge-runtime"),
-    { recursive: true }
-  );
+  const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
+  const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
+  await cp(join(ctx.pluginDir, "edge-runtime"), handlerRuntimeDirectory, {
+    recursive: true
+  });
+  await writeFile(join(handlerRuntimeDirectory, "matchers.json"), JSON.stringify(matchers));
   await writeFile(
-    join(ctx.edgeFunctionsDir, handlerName, `${handlerName}.js`),
+    join(handlerDirectory, `${handlerName}.js`),
     `
     import {handleMiddleware} from './edge-runtime/middleware.ts';
     import handler from './server/${name}.js';

package/dist/esm-chunks/{chunk-HPGTYMVD.js → chunk-VP3PT3VV.js}

@@ -87,6 +87,12 @@ var PluginContext = class {
       await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
     );
   }
+  /**
+   * Get Next.js routes manifest from the build output
+   */
+  async getRoutesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
+  }
   /**
    * Write a cache entry to the blob upload directory using
    * base64 keys to avoid collisions with directories

package/dist/esm-chunks/chunk-YZXA5QBC.js

@@ -0,0 +1,60 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/systemlog.ts
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var StructuredLogger = class _StructuredLogger {
+  fields;
+  message;
+  constructor(message, fields) {
+    this.fields = fields ?? {};
+    this.message = message ?? "";
+  }
+  // TODO: add sampling
+  doLog(logger2, message) {
+    logger2(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    this.doLog(console.log, message);
+  }
+  info(message) {
+    this.doLog(console.info, message);
+  }
+  debug(message) {
+    this.doLog(console.debug, message);
+  }
+  warn(message) {
+    this.doLog(console.warn, message);
+  }
+  error(message) {
+    this.doLog(console.error, message);
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+  withFields(fields) {
+    return new _StructuredLogger(this.message, {
+      ...this.fields,
+      ...fields
+    });
+  }
+};
+var logger = new StructuredLogger();
+
+export {
+  StructuredLogger,
+  logger
+};

package/dist/esm-chunks/{chunk-62KDS27E.js → chunk-Z7ZMLVTM.js}

@@ -38,11 +38,12 @@ var copyStaticContent = async (ctx) => {
 var copyStaticAssets = async (ctx) => {
   try {
     await rm(ctx.staticDir, { recursive: true, force: true });
+    const { basePath } = await ctx.getRoutesManifest();
     if (existsSync(ctx.resolve("public"))) {
-      await cp(ctx.resolve("public"), ctx.staticDir, { recursive: true });
+      await cp(ctx.resolve("public"), join(ctx.staticDir, basePath), { recursive: true });
     }
     if (existsSync(join(ctx.publishDir, "static"))) {
-      await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, "_next/static"), {
+      await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, basePath, "_next/static"), {
         recursive: true
       });
     }

package/dist/index.js

@@ -4,31 +4,31 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  createServerHandler
-} from "./esm-chunks/chunk-PEBUKFKH.js";
 import {
   copyFetchContent,
   copyPrerenderedContent
 } from "./esm-chunks/chunk-G3GM7JNF.js";
-import "./esm-chunks/chunk-G2VRYWGL.js";
 import {
   copyStaticAssets,
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-62KDS27E.js";
+} from "./esm-chunks/chunk-Z7ZMLVTM.js";
+import {
+  createEdgeHandlers
+} from "./esm-chunks/chunk-UXLNY5XK.js";
+import {
+  createServerHandler
+} from "./esm-chunks/chunk-NOX2JUQZ.js";
+import "./esm-chunks/chunk-A22224GM.js";
 import "./esm-chunks/chunk-AVWFCGVE.js";
 import {
   restoreBuildCache,
   saveBuildCache
 } from "./esm-chunks/chunk-GGHAQM5D.js";
-import {
-  createEdgeHandlers
-} from "./esm-chunks/chunk-XD5TSLZO.js";
 import {
   PluginContext
-} from "./esm-chunks/chunk-HPGTYMVD.js";
+} from "./esm-chunks/chunk-VP3PT3VV.js";
 import "./esm-chunks/chunk-RSKIKBZH.js";
 
 // src/index.ts

package/dist/run/handlers/cache.cjs

@@ -631,6 +631,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }

package/dist/run/handlers/server.js

@@ -13,10 +13,13 @@ import {
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../../esm-chunks/chunk-ZBX3SNQG.js";
+} from "../../esm-chunks/chunk-5N2CWXSJ.js";
 import {
   nextResponseProxy
 } from "../../esm-chunks/chunk-B6QMRLBH.js";
+import {
+  logger
+} from "../../esm-chunks/chunk-YZXA5QBC.js";
 import {
   __commonJS,
   __toESM
@@ -3260,9 +3263,10 @@ var server_default = async (request) => {
     setRunConfig(nextConfig);
     tagsManifest = await getTagsManifest();
     const { getMockedRequestHandlers } = await import("../next.cjs");
+    const url = new URL(request.url);
     [nextHandler] = await getMockedRequestHandlers({
-      port: 3e3,
-      hostname: "localhost",
+      port: Number(url.port) || 443,
+      hostname: url.hostname,
       dir: process.cwd(),
       isDev: false
     });
@@ -3273,15 +3277,19 @@ var server_default = async (request) => {
   try {
     await nextHandler(req, resProxy);
   } catch (error) {
+    logger.withError(error).error("next handler error");
     console.error(error);
     resProxy.statusCode = 500;
     resProxy.end("Internal Server Error");
   }
   const response = await toComputeResponse(resProxy);
   await adjustDateHeader(response.headers, request);
-  setCacheControlHeaders(response.headers);
+  setCacheControlHeaders(response.headers, request);
   setCacheTagsHeaders(response.headers, request, tagsManifest);
   setVaryHeaders(response.headers, request, nextConfig);
+  if (response.status > 300 && response.status < 400) {
+    return new Response(null, response);
+  }
   return response;
 };
 export {

package/dist/run/headers.js

@@ -9,7 +9,7 @@ import {
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../esm-chunks/chunk-ZBX3SNQG.js";
+} from "../esm-chunks/chunk-5N2CWXSJ.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {
   adjustDateHeader,

package/dist/run/next.cjs

@@ -933,6 +933,9 @@ var Store = class _Store {
     };
   }
   static validateKey(key) {
+    if (key === "") {
+      throw new Error("Blob key must not be empty.");
+    }
     if (key.startsWith("/") || key.startsWith("%2F")) {
       throw new Error("Blob key must not start with forward slash (/).");
     }

package/dist/run/systemlog.js

@@ -0,0 +1,15 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  StructuredLogger,
+  logger
+} from "../esm-chunks/chunk-YZXA5QBC.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  StructuredLogger,
+  logger
+};

package/edge-runtime/lib/routing.ts

@@ -0,0 +1,451 @@
+/**
+ * Various router utils ported to Deno from Next.js source
+ * Licence: https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/license.md
+ *
+ * Some types have been re-implemented to be more compatible with Deno or avoid chains of dependent files
+ */
+
+import type { Key } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
+
+import { compile, pathToRegexp } from '../vendor/deno.land/x/path_to_regexp@v6.2.1/index.ts'
+import { getCookies } from '../vendor/deno.land/std@0.175.0/http/cookie.ts'
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ Inlined/re-implemented types                                            │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export interface ParsedUrlQuery {
+  [key: string]: string | string[]
+}
+
+export interface Params {
+  [param: string]: any
+}
+
+export type RouteHas =
+  | {
+      type: 'header' | 'query' | 'cookie'
+      key: string
+      value?: string
+    }
+  | {
+      type: 'host'
+      key?: undefined
+      value: string
+    }
+
+export type Rewrite = {
+  source: string
+  destination: string
+  basePath?: false
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  regex: string
+}
+
+export type Header = {
+  source: string
+  basePath?: false
+  locale?: false
+  headers: Array<{ key: string; value: string }>
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  regex: string
+}
+
+export type Redirect = {
+  source: string
+  destination: string
+  basePath?: false
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+  statusCode?: number
+  permanent?: boolean
+  regex: string
+}
+
+export type DynamicRoute = {
+  page: string
+  regex: string
+  namedRegex?: string
+  routeKeys?: { [key: string]: string }
+}
+
+export type RoutesManifest = {
+  basePath: string
+  redirects: Redirect[]
+  headers: Header[]
+  rewrites: {
+    beforeFiles: Rewrite[]
+    afterFiles: Rewrite[]
+    fallback: Rewrite[]
+  }
+  dynamicRoutes: DynamicRoute[]
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/escape-regexp.ts                           │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+// regexp is based on https://github.com/sindresorhus/escape-string-regexp
+const reHasRegExp = /[|\\{}()[\]^$+*?.-]/
+const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g
+
+export function escapeStringRegexp(str: string) {
+  // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+  if (reHasRegExp.test(str)) {
+    return str.replace(reReplaceRegExp, '\\$&')
+  }
+
+  return str
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/querystring.ts                │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery {
+  const query: ParsedUrlQuery = {}
+
+  searchParams.forEach((value, key) => {
+    if (typeof query[key] === 'undefined') {
+      query[key] = value
+    } else if (Array.isArray(query[key])) {
+      ;(query[key] as string[]).push(value)
+    } else {
+      query[key] = [query[key] as string, value]
+    }
+  })
+
+  return query
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/parse-url.ts                  │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+interface ParsedUrl {
+  hash: string
+  hostname?: string | null
+  href: string
+  pathname: string
+  port?: string | null
+  protocol?: string | null
+  query: ParsedUrlQuery
+  search: string
+}
+
+export function parseUrl(url: string): ParsedUrl {
+  const parsedURL = url.startsWith('/') ? new URL(url, 'http://n') : new URL(url)
+
+  return {
+    hash: parsedURL.hash,
+    hostname: parsedURL.hostname,
+    href: parsedURL.href,
+    pathname: parsedURL.pathname,
+    port: parsedURL.port,
+    protocol: parsedURL.protocol,
+    query: searchParamsToUrlQuery(parsedURL.searchParams),
+    search: parsedURL.search,
+  }
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/prepare-destination.ts        │
+  │ — Changed to use WHATWG Fetch `Request` instead of                      │
+  │ `http.IncomingMessage`.                                                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+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 hasMatch = (hasItem: RouteHas) => {
+    let value: undefined | string | null
+    let key = hasItem.key
+
+    switch (hasItem.type) {
+      case 'header': {
+        key = hasItem.key.toLowerCase()
+        value = req.headers.get(key)
+        break
+      }
+      case 'cookie': {
+        value = cookies[hasItem.key]
+        break
+      }
+      case 'query': {
+        value = query[hasItem.key]
+        break
+      }
+      case 'host': {
+        value = url.hostname
+        break
+      }
+      default: {
+        break
+      }
+    }
+    if (!hasItem.value && value && key) {
+      params[getSafeParamName(key)] = value
+
+      return true
+    } else if (value) {
+      const matcher = new RegExp(`^${hasItem.value}$`)
+      const matches = Array.isArray(value)
+        ? value.slice(-1)[0].match(matcher)
+        : value.match(matcher)
+
+      if (matches) {
+        if (Array.isArray(matches)) {
+          if (matches.groups) {
+            Object.keys(matches.groups).forEach((groupKey) => {
+              params[groupKey] = matches.groups![groupKey]
+            })
+          } else if (hasItem.type === 'host' && matches[0]) {
+            params.host = matches[0]
+          }
+        }
+        return true
+      }
+    }
+    return false
+  }
+
+  const allMatch = has.every((item) => hasMatch(item)) && !missing.some((item) => hasMatch(item))
+
+  if (allMatch) {
+    return params
+  }
+  return false
+}
+
+export function compileNonPath(value: string, params: Params): string {
+  if (!value.includes(':')) {
+    return value
+  }
+
+  for (const key of Object.keys(params)) {
+    if (value.includes(`:${key}`)) {
+      value = value
+        .replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISKS`)
+        .replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`)
+        .replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`)
+        .replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`)
+    }
+  }
+  value = value
+    .replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1')
+    .replace(/--ESCAPED_PARAM_PLUS/g, '+')
+    .replace(/--ESCAPED_PARAM_COLON/g, ':')
+    .replace(/--ESCAPED_PARAM_QUESTION/g, '?')
+    .replace(/--ESCAPED_PARAM_ASTERISKS/g, '*')
+  // the value needs to start with a forward-slash to be compiled
+  // correctly
+  return compile(`/${value}`, { validate: false })(params).slice(1)
+}
+
+export function prepareDestination(args: {
+  appendParamsToQuery: boolean
+  destination: string
+  params: Params
+  query: ParsedUrlQuery
+}) {
+  const query = Object.assign({}, args.query)
+  delete query.__nextLocale
+  delete query.__nextDefaultLocale
+  delete query.__nextDataReq
+
+  let escapedDestination = args.destination
+
+  for (const param of Object.keys({ ...args.params, ...query })) {
+    escapedDestination = escapeSegment(escapedDestination, param)
+  }
+
+  const parsedDestination: ParsedUrl = parseUrl(escapedDestination)
+  const destQuery = parsedDestination.query
+  const destPath = unescapeSegments(`${parsedDestination.pathname!}${parsedDestination.hash || ''}`)
+  const destHostname = unescapeSegments(parsedDestination.hostname || '')
+  const destPathParamKeys: Key[] = []
+  const destHostnameParamKeys: Key[] = []
+  pathToRegexp(destPath, destPathParamKeys)
+  pathToRegexp(destHostname, destHostnameParamKeys)
+
+  const destParams: (string | number)[] = []
+
+  destPathParamKeys.forEach((key) => destParams.push(key.name))
+  destHostnameParamKeys.forEach((key) => destParams.push(key.name))
+
+  const destPathCompiler = compile(
+    destPath,
+    // we don't validate while compiling the destination since we should
+    // have already validated before we got to this point and validating
+    // breaks compiling destinations with named pattern params from the source
+    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
+    // since compile validation is meant for reversing and not for inserting
+    // params from a separate path-regex into another
+    { validate: false },
+  )
+
+  const destHostnameCompiler = compile(destHostname, { validate: false })
+
+  // update any params in query values
+  for (const [key, strOrArray] of Object.entries(destQuery)) {
+    // the value needs to start with a forward-slash to be compiled
+    // correctly
+    if (Array.isArray(strOrArray)) {
+      destQuery[key] = strOrArray.map((value) =>
+        compileNonPath(unescapeSegments(value), args.params),
+      )
+    } else {
+      destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params)
+    }
+  }
+
+  // add path params to query if it's not a redirect and not
+  // already defined in destination query or path
+  const paramKeys = Object.keys(args.params).filter((name) => name !== 'nextInternalLocale')
+
+  if (args.appendParamsToQuery && !paramKeys.some((key) => destParams.includes(key))) {
+    for (const key of paramKeys) {
+      if (!(key in destQuery)) {
+        destQuery[key] = args.params[key]
+      }
+    }
+  }
+
+  let newUrl
+
+  try {
+    newUrl = destPathCompiler(args.params)
+
+    const [pathname, hash] = newUrl.split('#')
+    parsedDestination.hostname = destHostnameCompiler(args.params)
+    parsedDestination.pathname = pathname
+    parsedDestination.hash = `${hash ? '#' : ''}${hash || ''}`
+    delete (parsedDestination as any).search
+  } catch (err: any) {
+    if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
+      throw new Error(
+        `To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`,
+      )
+    }
+    throw err
+  }
+
+  // Query merge order lowest priority to highest
+  // 1. initial URL query values
+  // 2. path segment values
+  // 3. destination specified query values
+  parsedDestination.query = {
+    ...query,
+    ...parsedDestination.query,
+  }
+
+  return {
+    newUrl,
+    destQuery,
+    parsedDestination,
+  }
+}
+
+/**
+ * Ensure only a-zA-Z are used for param names for proper interpolating
+ * with path-to-regexp
+ */
+function getSafeParamName(paramName: string) {
+  let newParamName = ''
+
+  for (let i = 0; i < paramName.length; i++) {
+    const charCode = paramName.charCodeAt(i)
+
+    if (
+      (charCode > 64 && charCode < 91) || // A-Z
+      (charCode > 96 && charCode < 123) // a-z
+    ) {
+      newParamName += paramName[i]
+    }
+  }
+  return newParamName
+}
+
+function escapeSegment(str: string, segmentName: string) {
+  return str.replace(
+    new RegExp(`:${escapeStringRegexp(segmentName)}`, 'g'),
+    `__ESC_COLON_${segmentName}`,
+  )
+}
+
+function unescapeSegments(str: string) {
+  return str.replace(/__ESC_COLON_/gi, ':')
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/src/shared/lib/router/utils/is-dynamic.ts                 │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+// Identify /[param]/ in route string
+const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/
+
+export function isDynamicRoute(route: string): boolean {
+  return TEST_ROUTE.test(route)
+}
+
+/* 
+  ┌─────────────────────────────────────────────────────────────────────────┐
+  │ packages/next/shared/lib/router/utils/middleware-route-matcher.ts       │
+  └─────────────────────────────────────────────────────────────────────────┘
+ */
+export interface MiddlewareRouteMatch {
+  (
+    pathname: string | null | undefined,
+    request: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ): boolean
+}
+
+export interface MiddlewareMatcher {
+  regexp: string
+  locale?: false
+  has?: RouteHas[]
+  missing?: RouteHas[]
+}
+
+export function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch {
+  return (
+    pathname: string | null | undefined,
+    req: Pick<Request, 'headers' | 'url'>,
+    query: Params,
+  ) => {
+    for (const matcher of matchers) {
+      const routeMatch = new RegExp(matcher.regexp).exec(pathname!)
+      if (!routeMatch) {
+        continue
+      }
+
+      if (matcher.has || matcher.missing) {
+        const hasParams = matchHas(req, query, matcher.has, matcher.missing)
+        if (!hasParams) {
+          continue
+        }
+      }
+
+      return true
+    }
+
+    return false
+  }
+}

package/edge-runtime/matchers.json

@@ -0,0 +1 @@
+[]

package/edge-runtime/middleware.ts

@@ -1,11 +1,20 @@
 import type { Context } from '@netlify/edge-functions'
 
+import matchers from './matchers.json' assert { type: 'json' }
+
 import { buildNextRequest, RequestData } from './lib/next-request.ts'
 import { buildResponse } from './lib/response.ts'
 import { FetchEventResult } from './lib/response.ts'
+import {
+  type MiddlewareRouteMatch,
+  getMiddlewareRouteMatcher,
+  searchParamsToUrlQuery,
+} from './lib/routing.ts'
 
 type NextHandler = (params: { request: RequestData }) => Promise<FetchEventResult>
 
+const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
+
 /**
  * Runs a Next.js middleware as a Netlify Edge Function. It translates a web
  * platform Request into a NextRequest instance on the way in, and translates
@@ -20,13 +29,17 @@ export async function handleMiddleware(
   context: Context,
   nextHandler: NextHandler,
 ) {
-  // Don't run in dev
-  if (Netlify.env.has('NETLIFY_DEV')) {
+  const nextRequest = buildNextRequest(request, context)
+  const url = new URL(request.url)
+
+  // 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))) {
     return
   }
 
-  const nextRequest = buildNextRequest(request, context)
-
   try {
     const result = await nextHandler({ request: nextRequest })
     const response = await buildResponse({ result, request: request, context })

package/edge-runtime/shim/index.js

@@ -2,6 +2,9 @@
 // a Webpack bundle. You should not import this file from anywhere in the
 // application.
 import { AsyncLocalStorage } from 'node:async_hooks'
+import process from 'node:process'
+
+globalThis.process = process
 
 globalThis.AsyncLocalStorage = AsyncLocalStorage
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.0-beta.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",