@netlify/plugin-nextjs 5.0.0-beta.2 → 5.0.0-beta.3

package/README.md

@@ -17,8 +17,11 @@ How to add new integration test scenarios to the application:
 4. Add your test
 
 > Currently the tests require a built version of the `dist/run/handlers/cache.cjs` so you need to
-> run `npm run build` before executing the integration tests. In addition, the integration tests
-> need to be prepared before first use. You can do this by running `npm run pretest`.
+> run `npm run build` before executing the integration tests.
+
+In addition, the integration tests need to be prepared before first use. You can do this by running
+`npm run pretest`. To speed up this process and build only the fixtures whose name starts with a
+given prefix, run `npm run pretest -- <prefix>`.
 
 ### E2E testing
 

package/dist/build/cache.js

@@ -7,7 +7,7 @@
 import {
   restoreBuildCache,
   saveBuildCache
-} from "../esm-chunks/chunk-GGHAQM5D.js";
+} from "../esm-chunks/chunk-XQ65S4R2.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {
   restoreBuildCache,

package/dist/build/functions/edge.js

@@ -6,7 +6,8 @@
     
 import {
   createEdgeHandlers
-} from "../../esm-chunks/chunk-3PTPU5GO.js";
+} from "../../esm-chunks/chunk-FFCTA32Q.js";
+import "../../esm-chunks/chunk-AVWFCGVE.js";
 import "../../esm-chunks/chunk-TJKO3X6O.js";
 import "../../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/esm-chunks/{chunk-3PTPU5GO.js → chunk-FFCTA32Q.js}

@@ -4,25 +4,52 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
 import {
   EDGE_HANDLER_NAME
 } from "./chunk-TJKO3X6O.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
 
 // src/build/functions/edge.ts
+var import_fast_glob = __toESM(require_out(), 1);
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 var writeEdgeManifest = async (ctx, manifest) => {
   await mkdir(ctx.edgeFunctionsDir, { recursive: true });
   await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
 };
+var copyRuntime = async (ctx, handlerDirectory) => {
+  const files = await (0, import_fast_glob.glob)("edge-runtime/**/*", {
+    cwd: ctx.pluginDir,
+    ignore: ["**/*.test.ts"],
+    dot: true
+  });
+  await Promise.all(
+    files.map(
+      (path) => cp(join(ctx.pluginDir, path), join(handlerDirectory, path), { recursive: true })
+    )
+  );
+};
 var writeHandlerFile = async (ctx, { matchers, name }) => {
+  const nextConfig = await ctx.getBuildConfig();
   const handlerName = getHandlerName({ name });
   const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
   const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
-  await cp(join(ctx.pluginDir, "edge-runtime"), handlerRuntimeDirectory, {
-    recursive: true
-  });
+  await copyRuntime(ctx, handlerDirectory);
   await writeFile(join(handlerRuntimeDirectory, "matchers.json"), JSON.stringify(matchers));
+  const minimalNextConfig = {
+    basePath: nextConfig.basePath,
+    i18n: nextConfig.i18n,
+    trailingSlash: nextConfig.trailingSlash
+  };
+  await writeFile(
+    join(handlerRuntimeDirectory, "next.config.json"),
+    JSON.stringify(minimalNextConfig)
+  );
   await writeFile(
     join(handlerDirectory, `${handlerName}.js`),
     `

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

@@ -0,0 +1,105 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// node_modules/@netlify/functions/dist/lib/system_logger.js
+var require_system_logger = __commonJS({
+  "node_modules/@netlify/functions/dist/lib/system_logger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.systemLogger = exports.LogLevel = void 0;
+    var process_1 = __require("process");
+    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 LogLevel2;
+    (function(LogLevel3) {
+      LogLevel3[LogLevel3["Debug"] = 1] = "Debug";
+      LogLevel3[LogLevel3["Log"] = 2] = "Log";
+      LogLevel3[LogLevel3["Error"] = 3] = "Error";
+    })(LogLevel2 = exports.LogLevel || (exports.LogLevel = {}));
+    var SystemLogger = class _SystemLogger {
+      fields;
+      logLevel;
+      constructor(fields = {}, logLevel = LogLevel2.Log) {
+        this.fields = fields;
+        this.logLevel = logLevel;
+      }
+      doLog(logger, message) {
+        if (process_1.env.NETLIFY_DEV && !process_1.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+          return;
+        }
+        logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+      }
+      log(message) {
+        if (this.logLevel > LogLevel2.Log) {
+          return;
+        }
+        this.doLog(console.log, message);
+      }
+      debug(message) {
+        if (this.logLevel > LogLevel2.Debug) {
+          return;
+        }
+        this.doLog(console.debug, message);
+      }
+      error(message) {
+        if (this.logLevel > LogLevel2.Error) {
+          return;
+        }
+        this.doLog(console.error, message);
+      }
+      withLogLevel(level) {
+        return new _SystemLogger(this.fields, level);
+      }
+      withFields(fields) {
+        return new _SystemLogger({
+          ...this.fields,
+          ...fields
+        }, this.logLevel);
+      }
+      withError(error) {
+        const fields = error instanceof Error ? serializeError(error) : { error };
+        return this.withFields(fields);
+      }
+    };
+    exports.systemLogger = new SystemLogger();
+  }
+});
+
+// node_modules/@netlify/functions/dist/internal.js
+var require_internal = __commonJS({
+  "node_modules/@netlify/functions/dist/internal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LogLevel = exports.systemLogger = void 0;
+    var system_logger_js_1 = require_system_logger();
+    Object.defineProperty(exports, "systemLogger", { enumerable: true, get: function() {
+      return system_logger_js_1.systemLogger;
+    } });
+    Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function() {
+      return system_logger_js_1.LogLevel;
+    } });
+  }
+});
+
+// src/run/systemlog.ts
+var import_internal = __toESM(require_internal(), 1);
+
+export {
+  import_internal
+};

package/dist/esm-chunks/{chunk-R4NHZWGU.js → chunk-OIL5MDCV.js}

@@ -22,7 +22,7 @@ var setRunConfig = (config) => {
   process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
 };
 var getTagsManifest = async () => {
-  return JSON.parse(await readFile(resolve(".netlify/tags-manifest.json"), "utf-8"));
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, ".netlify/tags-manifest.json"), "utf-8"));
 };
 
 export {

package/dist/esm-chunks/{chunk-GGHAQM5D.js → chunk-XQ65S4R2.js}

@@ -6,6 +6,7 @@
     
 
 // src/build/cache.ts
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 var saveBuildCache = async (ctx) => {
   if (await ctx.utils.cache.save(join(ctx.publishDir, "cache"))) {
@@ -15,7 +16,10 @@ var saveBuildCache = async (ctx) => {
   }
 };
 var restoreBuildCache = async (ctx) => {
-  if (await ctx.utils.cache.restore(join(ctx.publishDir, "cache"))) {
+  const { cache } = ctx.utils;
+  if (existsSync(join(ctx.publishDir, "cache"))) {
+    console.log("Next.js cache found.");
+  } else if (await cache.restore(join(ctx.publishDir, "cache"))) {
     console.log("Next.js cache restored.");
   } else {
     console.log("No Next.js cache to restore.");

package/dist/index.js

@@ -16,7 +16,7 @@ import {
 } from "./esm-chunks/chunk-Z7ZMLVTM.js";
 import {
   createEdgeHandlers
-} from "./esm-chunks/chunk-3PTPU5GO.js";
+} from "./esm-chunks/chunk-FFCTA32Q.js";
 import {
   createServerHandler
 } from "./esm-chunks/chunk-ALO2SSMH.js";
@@ -25,7 +25,7 @@ import "./esm-chunks/chunk-AVWFCGVE.js";
 import {
   restoreBuildCache,
   saveBuildCache
-} from "./esm-chunks/chunk-GGHAQM5D.js";
+} from "./esm-chunks/chunk-XQ65S4R2.js";
 import {
   setImageConfig
 } from "./esm-chunks/chunk-H46DW7YI.js";

package/dist/run/config.js

@@ -8,7 +8,7 @@ import {
   getRunConfig,
   getTagsManifest,
   setRunConfig
-} from "../esm-chunks/chunk-R4NHZWGU.js";
+} from "../esm-chunks/chunk-OIL5MDCV.js";
 import "../esm-chunks/chunk-4AJYXTWN.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
 export {

package/dist/run/handlers/server.js

@@ -5,11 +5,11 @@
       })();
     
 import {
-  logger
-} from "../../esm-chunks/chunk-YZXA5QBC.js";
+  import_internal
+} from "../../esm-chunks/chunk-GHDGGK6V.js";
 import {
   getTagsManifest
-} from "../../esm-chunks/chunk-R4NHZWGU.js";
+} from "../../esm-chunks/chunk-OIL5MDCV.js";
 import "../../esm-chunks/chunk-4AJYXTWN.js";
 import {
   adjustDateHeader,
@@ -3278,7 +3278,7 @@ var server_default = async (request) => {
   try {
     await nextHandler(req, resProxy);
   } catch (error) {
-    logger.withError(error).error("next handler error");
+    import_internal.systemLogger.withError(error).error("next handler error");
     console.error(error);
     resProxy.statusCode = 500;
     resProxy.end("Internal Server Error");

package/dist/run/systemlog.js

@@ -5,11 +5,12 @@
       })();
     
 import {
-  StructuredLogger,
-  logger
-} from "../esm-chunks/chunk-YZXA5QBC.js";
+  import_internal
+} from "../esm-chunks/chunk-GHDGGK6V.js";
 import "../esm-chunks/chunk-RSKIKBZH.js";
+var export_LogLevel = import_internal.LogLevel;
+var export_logger = import_internal.systemLogger;
 export {
-  StructuredLogger,
-  logger
+  export_LogLevel as LogLevel,
+  export_logger as logger
 };

package/edge-runtime/lib/headers.ts

@@ -1,3 +1,8 @@
+export const InternalHeaders = {
+  NFDebugLogging: 'x-nf-debug-logging',
+  NFRequestID: 'x-nf-request-id',
+}
+
 // Next 13 supports request header mutations and has the side effect of prepending header values with 'x-middleware-request'
 // as part of invoking NextResponse.next() in the middleware. We need to remove that before sending the response the user
 // as the code that removes it in Next isn't run based on how we handle the middleware

package/edge-runtime/lib/logging.ts

@@ -0,0 +1,5 @@
+export {
+  logger,
+  LogLevel,
+  StructuredLogger,
+} from '../vendor/v1-7-0--edge-utils.netlify.app/logger/mod.ts'

package/edge-runtime/lib/next-request.ts

@@ -1,5 +1,7 @@
 import type { Context } from '@netlify/edge-functions'
 
+import { normalizeDataUrl, removeBasePath, normalizeLocalePath } from './util.ts'
+
 interface I18NConfig {
   defaultLocale: string
   localeDetection?: false
@@ -29,6 +31,43 @@ export interface RequestData {
   }
   url: string
   body?: ReadableStream<Uint8Array>
+  detectedLocale?: string
+}
+
+const normalizeRequestURL = (
+  originalURL: string,
+  nextConfig?: RequestData['nextConfig'],
+): { url: string; detectedLocale?: string } => {
+  const url = new URL(originalURL)
+
+  url.pathname = removeBasePath(url.pathname, nextConfig?.basePath)
+
+  let detectedLocale: string | undefined
+
+  if (nextConfig?.i18n) {
+    const { pathname, detectedLocale: detected } = normalizeLocalePath(
+      url.pathname,
+      nextConfig?.i18n?.locales,
+    )
+    url.pathname = pathname
+    detectedLocale = detected
+  }
+
+  // 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)
+
+  // Normalizing the trailing slash based on the `trailingSlash` configuration
+  // property from the Next.js config.
+  if (nextConfig?.trailingSlash && url.pathname !== '/' && !url.pathname.endsWith('/')) {
+    url.pathname = `${url.pathname}/`
+  }
+
+  return {
+    url: url.toString(),
+    detectedLocale,
+  }
 }
 
 export const buildNextRequest = (
@@ -47,13 +86,16 @@ export const buildNextRequest = (
     timezone,
   }
 
+  const { detectedLocale, url: normalizedUrl } = normalizeRequestURL(url, nextConfig)
+
   return {
     headers: Object.fromEntries(headers.entries()),
     geo,
-    url,
+    url: normalizedUrl,
     method,
     ip: context.ip,
     body: body ?? undefined,
     nextConfig,
+    detectedLocale,
   }
 }

package/edge-runtime/lib/response.ts

@@ -2,23 +2,37 @@ import type { Context } from '@netlify/edge-functions'
 import { HTMLRewriter } from '../vendor/deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
 
 import { updateModifiedHeaders } from './headers.ts'
-import { normalizeDataUrl, relativizeURL } from './util.ts'
+import type { StructuredLogger } from './logging.ts'
+import { normalizeDataUrl, normalizeLocalePath, relativizeURL, rewriteDataPath } from './util.ts'
 import { addMiddlewareHeaders, isMiddlewareRequest, isMiddlewareResponse } from './middleware.ts'
+import { RequestData } from './next-request.ts'
 
 export interface FetchEventResult {
   response: Response
   waitUntil: Promise<any>
 }
 
+interface BuildResponseOptions {
+  context: Context
+  logger: StructuredLogger
+  request: Request
+  result: FetchEventResult
+  nextConfig?: RequestData['nextConfig']
+  requestLocale?: string
+}
+
 export const buildResponse = async ({
-  result,
-  request,
   context,
-}: {
-  result: FetchEventResult
-  request: Request
-  context: Context
-}) => {
+  logger,
+  request,
+  result,
+  nextConfig,
+  requestLocale,
+}: BuildResponseOptions): Promise<Response | void> => {
+  logger
+    .withFields({ is_nextresponse_next: result.response.headers.has('x-middleware-next') })
+    .debug('Building Next.js response')
+
   updateModifiedHeaders(request.headers, result.response.headers)
 
   // They've returned the MiddlewareRequest directly, so we'll call `next()` for them.
@@ -99,32 +113,79 @@ export const buildResponse = async ({
   const rewrite = res.headers.get('x-middleware-rewrite')
 
   // Data requests (i.e. requests for /_next/data ) need special handling
-  const isDataReq = request.headers.get('x-nextjs-data')
+  const isDataReq = request.headers.has('x-nextjs-data')
 
   if (rewrite) {
+    logger.withFields({ rewrite_url: rewrite }).debug('Found middleware rewrite')
+
     const rewriteUrl = new URL(rewrite, request.url)
     const baseUrl = new URL(request.url)
+    if (rewriteUrl.toString() === baseUrl.toString()) {
+      logger.withFields({ rewrite_url: rewrite }).debug('Rewrite url is same as original url')
+      return
+    }
+
     const relativeUrl = relativizeURL(rewrite, request.url)
+    const originalPath = new URL(request.url, `http://n`).pathname
 
-    // Data requests might be rewritten to an external URL
-    // This header tells the client router the redirect target, and if it's external then it will do a full navigation
     if (isDataReq) {
+      // Data requests might be rewritten to an external URL
+      // This header tells the client router the redirect target, and if it's external then it will do a full navigation
+
       res.headers.set('x-nextjs-rewrite', relativeUrl)
     }
+
     if (rewriteUrl.origin !== baseUrl.origin) {
-      // Netlify Edge Functions don't support proxying to external domains, but Next middleware does
-      const proxied = fetch(new Request(rewriteUrl.toString(), request))
-      return addMiddlewareHeaders(proxied, res)
+      logger.withFields({ rewrite_url: rewrite }).debug('Rewriting to external url')
+      let proxyRequest: Request
+
+      // Remove Netlify internal headers
+      const headers = new Headers(
+        [...request.headers.entries()].filter(([key]) => !key.startsWith('x-nf-')),
+      )
+      if (request.body && !request.bodyUsed) {
+        // This is not ideal, but streaming to an external URL doesn't work
+        const body = await request.arrayBuffer()
+        proxyRequest = new Request(rewriteUrl, {
+          headers,
+          method: request.method,
+          body,
+        })
+      } else {
+        proxyRequest = new Request(rewriteUrl, {
+          headers,
+          method: request.method,
+        })
+      }
+      return addMiddlewareHeaders(fetch(proxyRequest), res)
+    } else if (isDataReq) {
+      rewriteUrl.pathname = rewriteDataPath({
+        dataUrl: originalPath,
+        newRoute: rewriteUrl.pathname,
+        basePath: nextConfig?.basePath,
+      })
     }
     res.headers.set('x-middleware-rewrite', relativeUrl)
-
-    request.headers.set('x-original-path', new URL(request.url, `http://n`).pathname)
     request.headers.set('x-middleware-rewrite', rewrite)
-
-    return addMiddlewareHeaders(context.rewrite(rewrite), res)
+    return addMiddlewareHeaders(fetch(new Request(rewriteUrl, request)), res)
   }
 
-  const redirect = res.headers.get('Location')
+  let redirect = res.headers.get('location')
+
+  // If we are redirecting a request that had a locale in the URL, we need to add it back in
+  if (redirect && requestLocale) {
+    const redirectUrl = new URL(redirect, request.url)
+
+    const normalizedRedirect = normalizeLocalePath(redirectUrl.pathname, nextConfig?.i18n?.locales)
+
+    const locale = normalizedRedirect.detectedLocale ?? requestLocale
+    // Pages router API routes don't have a locale in the URL
+    if (locale && !redirectUrl.pathname.startsWith(`/api/`)) {
+      redirectUrl.pathname = `/${locale}${normalizedRedirect.pathname}`
+      redirect = redirectUrl.toString()
+      res.headers.set('location', redirect)
+    }
+  }
 
   // Data requests shouldn't automatically redirect in the browser (they might be HTML pages): they're handled by the router
   if (redirect && isDataReq) {
@@ -142,5 +203,6 @@ export const buildResponse = async ({
     res.headers.delete('x-middleware-next')
     return addMiddlewareHeaders(context.next(), res)
   }
+
   return res
 }

package/edge-runtime/lib/util.test.ts

@@ -0,0 +1,39 @@
+import { assertEquals } from 'https://deno.land/std@0.175.0/testing/asserts.ts'
+import { rewriteDataPath } from './util.ts'
+
+Deno.test('rewriteDataPath', async (t) => {
+  await t.step('should rewrite a data url', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite a data url with a base path', async () => {
+    const dataUrl = '/baseDir/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute, basePath: '/baseDir' })
+    assertEquals(result, '/baseDir/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite from an index data url', async () => {
+    const dataUrl = '/_next/data/build-id/index.json'
+    const newRoute = '/target'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+
+  await t.step('should rewrite to an index data url', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/index.json')
+  })
+
+  await t.step('should rewrite to a route with a trailing slash', async () => {
+    const dataUrl = '/_next/data/build-id/rewrite-me.json'
+    const newRoute = '/target/'
+    const result = rewriteDataPath({ dataUrl, newRoute })
+    assertEquals(result, '/_next/data/build-id/target.json')
+  })
+})

package/edge-runtime/lib/util.ts

@@ -1,16 +1,63 @@
-// If the redirect is a data URL, we need to normalize it.
-// https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
-export function normalizeDataUrl(redirect: string) {
-  if (redirect.startsWith('/_next/data/') && redirect.includes('.json')) {
-    const paths = redirect
+import type { RequestData } from './next-request.ts'
+
+/**
+ * Normalize a data URL into a route path.
+ * @see https://github.com/vercel/next.js/blob/25e0988e7c9033cb1503cbe0c62ba5de2e97849c/packages/next/src/shared/lib/router/utils/get-next-pathname-info.ts#L69-L76
+ */
+export function normalizeDataUrl(urlPath: string) {
+  if (urlPath.startsWith('/_next/data/') && urlPath.includes('.json')) {
+    const paths = urlPath
       .replace(/^\/_next\/data\//, '')
       .replace(/\.json/, '')
       .split('/')
 
-    redirect = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
+    urlPath = paths[1] !== 'index' ? `/${paths.slice(1).join('/')}` : '/'
   }
 
-  return redirect
+  return urlPath
+}
+
+export const removeBasePath = (path: string, basePath?: string) => {
+  if (basePath && path.startsWith(basePath)) {
+    return path.replace(basePath, '')
+  }
+  return path
+}
+
+// https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/i18n/normalize-locale-path.ts
+
+export interface PathLocale {
+  detectedLocale?: string
+  pathname: string
+}
+
+/**
+ * For a pathname that may include a locale from a list of locales, it
+ * removes the locale from the pathname returning it alongside with the
+ * detected locale.
+ *
+ * @param pathname A pathname that may include a locale.
+ * @param locales A list of locales.
+ * @returns The detected locale and pathname without locale
+ */
+export function normalizeLocalePath(pathname: string, locales?: string[]): PathLocale {
+  let detectedLocale: string | undefined
+  // first item will be empty string from splitting at first char
+  const pathnameParts = pathname.split('/')
+
+  ;(locales || []).some((locale) => {
+    if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
+      detectedLocale = locale
+      pathnameParts.splice(1, 1)
+      pathname = pathnameParts.join('/') || '/'
+      return true
+    }
+    return false
+  })
+  return {
+    pathname,
+    detectedLocale,
+  }
 }
 
 /**
@@ -24,3 +71,28 @@ export function relativizeURL(url: string | string, base: string | URL) {
     ? relative.toString().replace(origin, '')
     : relative.toString()
 }
+
+export const normalizeIndex = (path: string) => (path === '/' ? '/index' : path)
+
+const stripTrailingSlash = (path: string) =>
+  path !== '/' && path.endsWith('/') ? path.slice(0, -1) : path
+
+/**
+ * Modify a data url to point to a new page route.
+ */
+export function rewriteDataPath({
+  dataUrl,
+  newRoute,
+  basePath,
+}: {
+  dataUrl: string
+  newRoute: string
+  basePath?: string
+}) {
+  const normalizedDataUrl = normalizeDataUrl(removeBasePath(dataUrl, basePath))
+
+  return dataUrl.replace(
+    normalizeIndex(normalizedDataUrl),
+    stripTrailingSlash(normalizeIndex(newRoute)),
+  )
+}

package/edge-runtime/middleware.ts

@@ -1,7 +1,10 @@
 import type { Context } from '@netlify/edge-functions'
 
 import matchers from './matchers.json' assert { type: 'json' }
+import nextConfig from './next.config.json' assert { type: 'json' }
 
+import { InternalHeaders } from './lib/headers.ts'
+import { logger, LogLevel } from './lib/logging.ts'
 import { buildNextRequest, RequestData } from './lib/next-request.ts'
 import { buildResponse } from './lib/response.ts'
 import { FetchEventResult } from './lib/response.ts'
@@ -29,20 +32,34 @@ export async function handleMiddleware(
   context: Context,
   nextHandler: NextHandler,
 ) {
-  const nextRequest = buildNextRequest(request, context)
+  const nextRequest = buildNextRequest(request, context, nextConfig)
   const url = new URL(request.url)
+  const reqLogger = logger
+    .withLogLevel(
+      request.headers.has(InternalHeaders.NFDebugLogging) ? LogLevel.Debug : LogLevel.Log,
+    )
+    .withFields({ url_path: url.pathname })
+    .withRequestID(request.headers.get(InternalHeaders.NFRequestID))
 
   // 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))) {
+    reqLogger.debug('Aborting middleware due to runtime rules')
+
     return
   }
 
   try {
     const result = await nextHandler({ request: nextRequest })
-    const response = await buildResponse({ result, request: request, context })
+    const response = await buildResponse({
+      context,
+      logger: reqLogger,
+      request,
+      result,
+      requestLocale: nextRequest.detectedLocale,
+    })
 
     return response
   } catch (error) {

package/edge-runtime/next.config.json

@@ -0,0 +1 @@
+{}

package/edge-runtime/vendor/import_map.json

@@ -3,7 +3,8 @@
     "https://ghuc.cc/worker-tools/resolvable-promise/index.ts": "./raw.githubusercontent.com/worker-tools/resolvable-promise/master/index.ts",
     "https://deno.land/": "./deno.land/",
     "https://esm.sh/": "./esm.sh/",
-    "https://raw.githubusercontent.com/": "./raw.githubusercontent.com/"
+    "https://raw.githubusercontent.com/": "./raw.githubusercontent.com/",
+    "https://v1-7-0--edge-utils.netlify.app/": "./v1-7-0--edge-utils.netlify.app/"
   },
   "scopes": {
     "./esm.sh/": {

package/edge-runtime/vendor/v1-7-0--edge-utils.netlify.app/logger/logger.ts

@@ -0,0 +1,164 @@
+type Logger = (...data: unknown[]) => void;
+
+export enum LogLevel {
+  Debug = 1,
+  Log,
+  Error,
+}
+
+const serializeError = (error: Error): Record<string, unknown> => {
+  const cause = error?.cause instanceof Error
+    ? serializeError(error.cause)
+    : error.cause;
+
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack,
+  };
+};
+
+export class StructuredLogger {
+  private fields: Record<string, unknown>;
+  private logLevel: LogLevel;
+  private message: string;
+  private rawLogger?: Logger;
+  private requestID?: string;
+  __netlifyStructuredLogger: number;
+
+  constructor(
+    message?: string,
+    fields?: Record<string, unknown>,
+    requestID?: string,
+    rawLogger?: Logger,
+    logLevel?: LogLevel,
+  ) {
+    this.fields = fields ?? {};
+    this.logLevel = logLevel ?? LogLevel.Log;
+    this.message = message ?? "";
+    this.rawLogger = rawLogger;
+    this.requestID = requestID;
+
+    // Value should be equal to the major version
+    this.__netlifyStructuredLogger = 1;
+  }
+
+  debug(message: string) {
+    if (this.logLevel > LogLevel.Debug) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  error(message: string) {
+    if (this.logLevel > LogLevel.Error) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  log(message: string) {
+    if (this.logLevel > LogLevel.Log) {
+      return;
+    }
+
+    const logger = this.rawLogger ?? globalThis.console.log;
+
+    logger(
+      new StructuredLogger(
+        message,
+        this.fields,
+        this.requestID,
+        this.rawLogger,
+        this.logLevel,
+      ),
+    );
+  }
+
+  serialize() {
+    const log = {
+      fields: this.fields,
+      message: this.message,
+      requestID: this.requestID,
+    };
+
+    return log;
+  }
+
+  withError(error: unknown) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+
+    return this.withFields(fields);
+  }
+
+  withFields(fields: Record<string, unknown>) {
+    return new StructuredLogger(
+      this.message,
+      {
+        ...this.fields,
+        ...fields,
+      },
+      this.requestID,
+      this.rawLogger,
+      this.logLevel,
+    );
+  }
+
+  withLogLevel(logLevel: LogLevel) {
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      this.requestID,
+      this.rawLogger,
+      logLevel,
+    );
+  }
+
+  withRawLogger(logger: Logger) {
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      this.requestID,
+      logger,
+      this.logLevel,
+    );
+  }
+
+  withRequestID(requestID: string | null) {
+    if (requestID === null) {
+      return this;
+    }
+
+    return new StructuredLogger(
+      this.message,
+      this.fields,
+      requestID,
+      this.rawLogger,
+      this.logLevel,
+    );
+  }
+}
+
+export const logger = new StructuredLogger();

package/edge-runtime/vendor/v1-7-0--edge-utils.netlify.app/logger/mod.ts

@@ -0,0 +1 @@
+export * from "./logger.ts";

package/edge-runtime/vendor.ts

@@ -16,3 +16,5 @@ import 'https://deno.land/x/html_rewriter@v0.1.0-pre.17/index.ts'
 
 import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
 import 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'
+
+import 'https://v1-7-0--edge-utils.netlify.app/logger/mod.ts'

package/package.json

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

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

@@ -1,60 +0,0 @@
-
-      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
-};