@netlify/plugin-nextjs 4.21.2 → 4.23.0

package/lib/helpers/edge.js

@@ -44,9 +44,8 @@ const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) =
     chunks.push(exports);
     return chunks.join('\n');
 };
-const copyEdgeSourceFile = ({ file, target, edgeFunctionDir, }) => fs_1.promises.copyFile((0, path_1.join)(__dirname, '..', '..', 'src', 'templates', 'edge', file), (0, path_1.join)(edgeFunctionDir, target !== null && target !== void 0 ? target : file));
-// Edge functions don't support lookahead expressions
-const stripLookahead = (regex) => regex.replace('^/(?!_next)', '^/');
+const getEdgeTemplatePath = (file) => (0, path_1.join)(__dirname, '..', '..', 'src', 'templates', 'edge', file);
+const copyEdgeSourceFile = ({ file, target, edgeFunctionDir, }) => fs_1.promises.copyFile(getEdgeTemplatePath(file), (0, path_1.join)(edgeFunctionDir, target !== null && target !== void 0 ? target : file));
 const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, }) => {
     const name = sanitizeName(edgeFunctionDefinition.name);
     const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, name);
@@ -61,15 +60,22 @@ const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, net
         file: 'runtime.ts',
         target: 'index.ts',
     });
-    await copyEdgeSourceFile({ edgeFunctionDir, file: 'utils.ts' });
-    return {
-        function: name,
-        pattern: stripLookahead(edgeFunctionDefinition.regexp),
-    };
-};
-const cleanupEdgeFunctions = async ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions', }) => {
-    await (0, fs_extra_1.emptyDir)(INTERNAL_EDGE_FUNCTIONS_SRC);
+    const matchers = [];
+    // The v1 middleware manifest has a single regexp, but the v2 has an array of matchers
+    if ('regexp' in edgeFunctionDefinition) {
+        matchers.push({ regexp: edgeFunctionDefinition.regexp });
+    }
+    else {
+        matchers.push(...edgeFunctionDefinition.matchers);
+    }
+    await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionDir, 'matchers.json'), matchers);
+    // We add a defintion for each matching path
+    return matchers.map((matcher) => {
+        const pattern = matcher.regexp;
+        return { function: name, pattern };
+    });
 };
+const cleanupEdgeFunctions = ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions', }) => (0, fs_extra_1.emptyDir)(INTERNAL_EDGE_FUNCTIONS_SRC);
 exports.cleanupEdgeFunctions = cleanupEdgeFunctions;
 const writeDevEdgeFunction = async ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions', }) => {
     const manifest = {
@@ -84,10 +90,10 @@ const writeDevEdgeFunction = async ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/ed
     const edgeFunctionRoot = (0, path_1.resolve)(INTERNAL_EDGE_FUNCTIONS_SRC);
     await (0, fs_extra_1.emptyDir)(edgeFunctionRoot);
     await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionRoot, 'manifest.json'), manifest);
+    await (0, fs_extra_1.copy)(getEdgeTemplatePath('../edge-shared'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared'));
     const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, 'next-dev');
     await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
     await copyEdgeSourceFile({ edgeFunctionDir, file: 'next-dev.js', target: 'index.js' });
-    await copyEdgeSourceFile({ edgeFunctionDir, file: 'utils.ts' });
 };
 exports.writeDevEdgeFunction = writeDevEdgeFunction;
 /**
@@ -100,6 +106,7 @@ const writeEdgeFunctions = async (netlifyConfig) => {
     };
     const edgeFunctionRoot = (0, path_1.resolve)('.netlify', 'edge-functions');
     await (0, fs_extra_1.emptyDir)(edgeFunctionRoot);
+    await (0, fs_extra_1.copy)(getEdgeTemplatePath('../edge-shared'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared'));
     if (!process.env.NEXT_DISABLE_EDGE_IMAGES) {
         console.log('Using Netlify Edge Functions for image format detection. Set env var "NEXT_DISABLE_EDGE_IMAGES=true" to disable.');
         const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, 'ipx');
@@ -119,23 +126,23 @@ const writeEdgeFunctions = async (netlifyConfig) => {
         }
         for (const middleware of middlewareManifest.sortedMiddleware) {
             const edgeFunctionDefinition = middlewareManifest.middleware[middleware];
-            const functionDefinition = await writeEdgeFunction({
+            const functionDefinitions = await writeEdgeFunction({
                 edgeFunctionDefinition,
                 edgeFunctionRoot,
                 netlifyConfig,
             });
-            manifest.functions.push(functionDefinition);
+            manifest.functions.push(...functionDefinitions);
         }
         // Older versions of the manifest format don't have the functions field
         // No, the version field was not incremented
         if (typeof middlewareManifest.functions === 'object') {
             for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
-                const functionDefinition = await writeEdgeFunction({
+                const functionDefinitions = await writeEdgeFunction({
                     edgeFunctionDefinition,
                     edgeFunctionRoot,
                     netlifyConfig,
                 });
-                manifest.functions.push(functionDefinition);
+                manifest.functions.push(...functionDefinitions);
             }
         }
     }

package/lib/helpers/files.js

@@ -271,7 +271,13 @@ const getServerFile = (root, includeBase = true) => {
     return (0, utils_1.findModuleFromBase)({ candidates, paths: [root] });
 };
 const baseServerReplacements = [
-    [`let ssgCacheKey = `, `let ssgCacheKey = process.env._BYPASS_SSG || `],
+    // force manual revalidate during cache fetches
+    [
+        `checkIsManualRevalidate(req, this.renderOpts.previewProps)`,
+        `checkIsManualRevalidate(process.env._REVALIDATE_SSG ? { headers: { 'x-prerender-revalidate': this.renderOpts.previewProps.previewModeId } } : req, this.renderOpts.previewProps)`,
+    ],
+    // ensure ISR 404 pages send the correct SWR cache headers
+    [`private: isPreviewMode || is404Page && cachedData`, `private: isPreviewMode && cachedData`],
 ];
 const nextServerReplacements = [
     [

package/lib/helpers/redirects.js

@@ -9,6 +9,12 @@ const constants_1 = require("../constants");
 const files_1 = require("./files");
 const utils_1 = require("./utils");
 const matchesMiddleware = (middleware, route) => middleware.some((middlewarePath) => route.startsWith(middlewarePath));
+const generateHiddenPathRedirects = ({ basePath }) => constants_1.HIDDEN_PATHS.map((path) => ({
+    from: `${basePath}${path}`,
+    to: '/404.html',
+    status: 404,
+    force: true,
+}));
 const generateLocaleRedirects = ({ i18n, basePath, trailingSlash, }) => {
     const redirects = [];
     // If the cookie is set, we need to redirect at the origin
@@ -78,7 +84,7 @@ const generateStaticIsrRewrites = ({ staticRouteEntries, basePath, i18n, buildId
     const staticRoutePaths = new Set();
     const staticIsrRewrites = [];
     staticRouteEntries.forEach(([route, { initialRevalidateSeconds }]) => {
-        if ((0, utils_1.isApiRoute)(route)) {
+        if ((0, utils_1.isApiRoute)(route) || (0, utils_1.is404Route)(route, i18n)) {
             return;
         }
         staticRoutePaths.add(route);
@@ -125,7 +131,7 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
     const dynamicRewrites = [];
     const dynamicRoutesThatMatchMiddleware = [];
     dynamicRoutes.forEach((route) => {
-        if ((0, utils_1.isApiRoute)(route.page)) {
+        if ((0, utils_1.isApiRoute)(route.page) || (0, utils_1.is404Route)(route.page, i18n)) {
             return;
         }
         if (route.page in prerenderedDynamicRoutes) {
@@ -149,12 +155,7 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
 const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, }) => {
     const { dynamicRoutes: prerenderedDynamicRoutes, routes: prerenderedStaticRoutes } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(netlifyConfig.build.publish, 'prerender-manifest.json'));
     const { dynamicRoutes, staticRoutes } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(netlifyConfig.build.publish, 'routes-manifest.json'));
-    netlifyConfig.redirects.push(...constants_1.HIDDEN_PATHS.map((path) => ({
-        from: `${basePath}${path}`,
-        to: '/404.html',
-        status: 404,
-        force: true,
-    })));
+    netlifyConfig.redirects.push(...generateHiddenPathRedirects({ basePath }));
     if (i18n && i18n.localeDetection !== false) {
         netlifyConfig.redirects.push(...generateLocaleRedirects({ i18n, basePath, trailingSlash }));
     }
@@ -179,7 +180,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     netlifyConfig.redirects.push(...staticIsrRewrites);
     // Add rewrites for all static SSR routes. This is Next 12+
     staticRoutes === null || staticRoutes === void 0 ? void 0 : staticRoutes.forEach((route) => {
-        if (staticRoutePaths.has(route.page) || (0, utils_1.isApiRoute)(route.page)) {
+        if (staticRoutePaths.has(route.page) || (0, utils_1.isApiRoute)(route.page) || (0, utils_1.is404Route)(route.page)) {
             // Prerendered static routes are either handled by the CDN or are ISR
             return;
         }

package/lib/helpers/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = void 0;
+exports.getRemotePatterns = exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.is404Route = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = void 0;
 const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
@@ -63,6 +63,8 @@ const netlifyRoutesForNextRoute = (route, buildId, i18n) => {
 };
 const isApiRoute = (route) => route.startsWith('/api/') || route === '/api';
 exports.isApiRoute = isApiRoute;
+const is404Route = (route, i18n) => i18n ? i18n.locales.some((locale) => route === `/${locale}/404`) : route === '/404';
+exports.is404Route = is404Route;
 const redirectsForNextRoute = ({ route, buildId, basePath, to, i18n, status = 200, force = false, }) => netlifyRoutesForNextRoute(route, buildId, i18n).map((redirect) => ({
     from: `${basePath}${redirect}`,
     to,
@@ -156,4 +158,17 @@ const getCustomImageResponseHeaders = (headers) => {
 exports.getCustomImageResponseHeaders = getCustomImageResponseHeaders;
 const isBundleSizeCheckDisabled = () => process.env.DISABLE_BUNDLE_ZIP_SIZE_CHECK === '1' || process.env.DISABLE_BUNDLE_ZIP_SIZE_CHECK === 'true';
 exports.isBundleSizeCheckDisabled = isBundleSizeCheckDisabled;
+const getRemotePatterns = (experimental, images) => {
+    var _a;
+    // Where remote patterns is configured pre-v12.2.5
+    if ((_a = experimental.images) === null || _a === void 0 ? void 0 : _a.remotePatterns) {
+        return experimental.images.remotePatterns;
+    }
+    // Where remote patterns is configured after v12.2.5
+    if (images.remotePatterns) {
+        return images.remotePatterns || [];
+    }
+    return [];
+};
+exports.getRemotePatterns = getRemotePatterns;
 /* eslint-enable max-lines */

package/lib/index.js

@@ -40,7 +40,6 @@ const plugin = {
         }
         const { publish } = netlifyConfig.build;
         (0, verification_1.checkNextSiteHasBuilt)({ publish, failBuild });
-        let experimentalRemotePatterns = [];
         const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir, experimental } = await (0, config_1.getNextConfig)({
             publish,
             failBuild,
@@ -68,9 +67,6 @@ const plugin = {
           `));
             }
         }
-        if (experimental.images) {
-            experimentalRemotePatterns = experimental.images.remotePatterns || [];
-        }
         if ((0, utils_1.isNextAuthInstalled)()) {
             const config = await (0, config_1.getRequiredServerFiles)(publish);
             const userDefinedNextAuthUrl = config.config.env.NEXTAUTH_URL;
@@ -102,7 +98,7 @@ const plugin = {
             imageconfig: images,
             netlifyConfig,
             basePath,
-            remotePatterns: experimentalRemotePatterns,
+            remotePatterns: (0, utils_1.getRemotePatterns)(experimental, images),
             responseHeaders: (0, utils_1.getCustomImageResponseHeaders)(netlifyConfig.headers),
         });
         await (0, redirects_1.generateRedirects)({

package/lib/templates/getHandler.js

@@ -32,7 +32,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
     conf.experimental.isrFlushToDisk = false;
     // This is our flag that we use when patching the source
     // eslint-disable-next-line no-underscore-dangle
-    process.env._BYPASS_SSG = 'true';
+    process.env._REVALIDATE_SSG = 'true';
     for (const [key, value] of Object.entries(conf.env)) {
         process.env[key] = String(value);
     }

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.21.2",
+  "version": "4.23.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
     "lib/**/*",
     "src/templates/edge/*",
+    "src/templates/edge-shared/*",
     "manifest.yml"
   ],
   "dependencies": {
     "@netlify/esbuild": "0.14.25",
     "@netlify/functions": "^1.2.0",
-    "@netlify/ipx": "^1.2.4",
+    "@netlify/ipx": "^1.2.5",
     "@vercel/node-bridge": "^2.1.0",
     "chalk": "^4.1.2",
     "execa": "^5.1.1",
@@ -31,12 +32,12 @@
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^27.16.1",
+    "@netlify/build": "^27.17.2",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",
     "@types/node": "^17.0.25",
-    "next": "^12.2.0",
+    "next": "^12.3.0",
     "npm-run-all": "^4.1.5",
     "typescript": "^4.6.3"
   },
@@ -62,4 +63,4 @@
   "engines": {
     "node": ">=12.0.0"
   }
-}
+}

package/src/templates/edge/matchers.json

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

package/src/templates/edge/next-dev.js

@@ -1,7 +1,7 @@
 import { NextRequest } from 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
 import { NextResponse } from 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'
 import { fromFileUrl } from 'https://deno.land/std@0.151.0/path/mod.ts'
-import { buildResponse } from './utils.ts'
+import { buildResponse } from '../edge-shared/utils.ts'
 
 globalThis.NFRequestContextMap ||= new Map()
 globalThis.__dirname = fromFileUrl(new URL('./', import.meta.url)).slice(0, -1)

package/src/templates/edge/runtime.ts

@@ -1,7 +1,11 @@
 import type { Context } from 'https://edge.netlify.com'
-
+// Available at build time
+import matchers from './matchers.json' assert { type: 'json' }
 import edgeFunction from './bundle.js'
-import { buildResponse } from './utils.ts'
+import { buildResponse } from '../edge-shared/utils.ts'
+import { getMiddlewareRouteMatcher, MiddlewareRouteMatch, searchParamsToUrlQuery } from '../edge-shared/next-utils.ts'
+
+const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
 
 export interface FetchEventResult {
   response: Response
@@ -49,8 +53,15 @@ const handler = async (req: Request, context: Context) => {
     // Don't run in dev
     return
   }
+
   const url = new URL(req.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.
+  if (!matchesMiddleware(url.pathname, req, searchParamsToUrlQuery(url.searchParams))) {
+    return
+  }
+
   const geo = {
     country: context.geo.country?.code,
     region: context.geo.subdivision?.code,

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

@@ -0,0 +1,396 @@
+/**
+ * Various router utils ported to Deno from Next.js source
+ * https://github.com/vercel/next.js/blob/7280c3ced186bb9a7ae3d7012613ef93f20b0fa9/packages/next/shared/lib/router/utils/
+ * 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
+ */
+
+// Deno imports
+import type { Key } from 'https://deno.land/x/path_to_regexp@v6.2.1/index.ts'
+
+import { compile, pathToRegexp } from 'https://deno.land/x/path_to_regexp@v6.2.1/index.ts'
+import { getCookies } from 'https://deno.land/std@0.148.0/http/cookie.ts'
+
+// Inlined/re-implemented types
+
+export interface ParsedUrlQuery {
+  [key: string]: string | string[]
+}
+
+export interface Params {
+  // Yeah, best we get
+  // deno-lint-ignore no-explicit-any
+  [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[]
+  regex: string
+}
+
+export type Header = {
+  source: string
+  basePath?: false
+  locale?: false
+  headers: Array<{ key: string; value: string }>
+  has?: RouteHas[]
+  regex: string
+}
+export type Redirect = {
+  source: string
+  destination: string
+  basePath?: false
+  locale?: false
+  has?: 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[]
+}
+// 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
+}
+
+// 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
+}
+
+// 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,
+  }
+}
+
+// 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 {
+  const params: Params = {}
+  const cookies = getCookies(req.headers)
+  const url = new URL(req.url)
+  const allMatch = has.every((hasItem) => {
+    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
+  })
+
+  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, ':')
+}
+
+// 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
+// 12.3 middleware route matcher
+
+export interface MiddlewareRouteMatch {
+  (pathname: string | null | undefined, request: Pick<Request, 'headers' | 'url'>, query: Params): boolean
+}
+
+export interface MiddlewareMatcher {
+  regexp: string
+  locale?: false
+  has?: 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) {
+        const hasParams = matchHas(req, matcher.has, query)
+        if (!hasParams) {
+          continue
+        }
+      }
+
+      return true
+    }
+
+    return false
+  }
+}

package/src/templates/{edge → edge-shared}/utils.ts

@@ -83,7 +83,7 @@ export const buildResponse = async ({
       const transformed = response.dataTransforms.reduce((prev, transform) => {
         return transform(prev)
       }, props)
-      return context.json(transformed)
+      return new Response(JSON.stringify(transformed), response)
     }
     // This var will hold the contents of the script tag
     let buffer = ''