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

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

@@ -1,28 +1,55 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
+import {
+  require_out
+} from "./chunk-MFN4GH7U.js";
 import {
   EDGE_HANDLER_NAME
-} from "./chunk-TJKO3X6O.js";
+} from "./chunk-IZY5TPZE.js";
+import {
+  __toESM
+} from "./chunk-WELZ7LFO.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`),
     `
@@ -34,7 +61,7 @@ var writeHandlerFile = async (ctx, { matchers, name }) => {
 };
 var copyHandlerDependencies = async (ctx, { name, files }) => {
   const edgeRuntimePath = join(ctx.pluginDir, "edge-runtime");
-  const srcDir = ctx.resolve(".next/standalone/.next");
+  const srcDir = join(ctx.standaloneDir, ".next");
   const shimPath = join(edgeRuntimePath, "shim/index.js");
   const shim = await readFile(shimPath, "utf8");
   const imports = `import './edge-runtime-webpack.js';`;
@@ -58,13 +85,19 @@ var createEdgeHandler = async (ctx, definition) => {
   await writeHandlerFile(ctx, definition);
 };
 var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
-var buildHandlerDefinition = (ctx, { name, matchers, page }) => ({
-  function: getHandlerName({ name }),
-  name: name === "middleware" ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`,
-  pattern: matchers[0].regexp,
-  cache: name === "middleware" ? void 0 : "manual",
-  generator: `${ctx.pluginName}@${ctx.pluginVersion}`
-});
+var buildHandlerDefinition = (ctx, { name, matchers, page }) => {
+  const fun = getHandlerName({ name });
+  const funName = name === "middleware" ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`;
+  const cache = name === "middleware" ? void 0 : "manual";
+  const generator = `${ctx.pluginName}@${ctx.pluginVersion}`;
+  return matchers.map((matcher) => ({
+    function: fun,
+    name: funName,
+    pattern: matcher.regexp,
+    cache,
+    generator
+  }));
+};
 var createEdgeHandlers = async (ctx) => {
   await rm(ctx.edgeFunctionsDir, { recursive: true, force: true });
   const nextManifest = await ctx.getMiddlewareManifest();
@@ -73,7 +106,7 @@ var createEdgeHandlers = async (ctx) => {
     // ...Object.values(nextManifest.functions)
   ];
   await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
-  const netlifyDefinitions = nextDefinitions.map((def) => buildHandlerDefinition(ctx, def));
+  const netlifyDefinitions = nextDefinitions.flatMap((def) => buildHandlerDefinition(ctx, def));
   const netlifyManifest = {
     version: 1,
     functions: netlifyDefinitions

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

@@ -0,0 +1,39 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  PLUGIN_DIR
+} from "./chunk-K233JI4O.js";
+
+// src/run/config.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var getRunConfig = async () => {
+  return JSON.parse(await readFile(resolve(".next/required-server-files.json"), "utf-8")).config;
+};
+var setRunConfig = (config) => {
+  const cacheHandler = join(PLUGIN_DIR, "dist/run/handlers/cache.cjs");
+  if (!existsSync(cacheHandler)) {
+    throw new Error(`Cache handler not found at ${cacheHandler}`);
+  }
+  config.experimental = {
+    ...config.experimental,
+    incrementalCacheHandlerPath: cacheHandler
+  };
+  config.cacheHandler = cacheHandler;
+  config.cacheMaxMemorySize = 0;
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+};
+var getTagsManifest = async () => {
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, ".netlify/tags-manifest.json"), "utf-8"));
+};
+
+export {
+  getRunConfig,
+  setRunConfig,
+  getTagsManifest
+};

package/dist/esm-chunks/{chunk-SMSOJ2OS.js → chunk-YG3G7B2X.js}

@@ -1,6 +1,6 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     

package/dist/index.js

@@ -1,44 +1,46 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
 import {
   copyFetchContent,
   copyPrerenderedContent
-} from "./esm-chunks/chunk-S5JXJCXP.js";
+} from "./esm-chunks/chunk-DZM5AUXX.js";
 import {
   copyStaticAssets,
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-Z7ZMLVTM.js";
+} from "./esm-chunks/chunk-KMPIVUVT.js";
 import {
   createEdgeHandlers
-} from "./esm-chunks/chunk-3PTPU5GO.js";
+} from "./esm-chunks/chunk-XC7T747I.js";
 import {
   createServerHandler
-} from "./esm-chunks/chunk-ALO2SSMH.js";
-import "./esm-chunks/chunk-5SZ5JD6J.js";
-import "./esm-chunks/chunk-AVWFCGVE.js";
+} from "./esm-chunks/chunk-X4Q4MYBW.js";
+import "./esm-chunks/chunk-6HBXWNZS.js";
+import "./esm-chunks/chunk-MFN4GH7U.js";
 import {
   restoreBuildCache,
   saveBuildCache
-} from "./esm-chunks/chunk-GGHAQM5D.js";
+} from "./esm-chunks/chunk-XA2CZH5Y.js";
 import {
   setImageConfig
-} from "./esm-chunks/chunk-H46DW7YI.js";
+} from "./esm-chunks/chunk-EPSI5TTB.js";
 import {
   PluginContext
-} from "./esm-chunks/chunk-TJKO3X6O.js";
-import "./esm-chunks/chunk-RSKIKBZH.js";
+} from "./esm-chunks/chunk-IZY5TPZE.js";
+import "./esm-chunks/chunk-WELZ7LFO.js";
 
 // src/index.ts
 import { existsSync } from "node:fs";
 var onPreBuild = async (options) => {
   process.env.NEXT_PRIVATE_STANDALONE = "true";
-  await restoreBuildCache(new PluginContext(options));
+  if (!options.constants.IS_LOCAL) {
+    await restoreBuildCache(new PluginContext(options));
+  }
 };
 var onBuild = async (options) => {
   const ctx = new PluginContext(options);
@@ -46,7 +48,9 @@ var onBuild = async (options) => {
     ctx.failBuild("Publish directory not found, please check your netlify.toml");
   }
   await setImageConfig(ctx);
-  await saveBuildCache(ctx);
+  if (!options.constants.IS_LOCAL) {
+    await saveBuildCache(ctx);
+  }
   await Promise.all([
     copyStaticAssets(ctx),
     copyStaticContent(ctx),

package/dist/run/config.js

@@ -1,6 +1,6 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
@@ -8,9 +8,9 @@ import {
   getRunConfig,
   getTagsManifest,
   setRunConfig
-} from "../esm-chunks/chunk-R4NHZWGU.js";
-import "../esm-chunks/chunk-4AJYXTWN.js";
-import "../esm-chunks/chunk-RSKIKBZH.js";
+} from "../esm-chunks/chunk-XIP2W57K.js";
+import "../esm-chunks/chunk-K233JI4O.js";
+import "../esm-chunks/chunk-WELZ7LFO.js";
 export {
   getRunConfig,
   getTagsManifest,

package/dist/run/constants.js

@@ -1,14 +1,14 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
 import {
   MODULE_DIR,
   PLUGIN_DIR
-} from "../esm-chunks/chunk-4AJYXTWN.js";
-import "../esm-chunks/chunk-RSKIKBZH.js";
+} from "../esm-chunks/chunk-K233JI4O.js";
+import "../esm-chunks/chunk-WELZ7LFO.js";
 export {
   MODULE_DIR,
   PLUGIN_DIR

package/dist/run/handlers/server.js

@@ -1,30 +1,30 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
 import {
-  logger
-} from "../../esm-chunks/chunk-YZXA5QBC.js";
+  import_internal
+} from "../../esm-chunks/chunk-X7XIMV6B.js";
 import {
   getTagsManifest
-} from "../../esm-chunks/chunk-R4NHZWGU.js";
-import "../../esm-chunks/chunk-4AJYXTWN.js";
+} from "../../esm-chunks/chunk-XIP2W57K.js";
+import "../../esm-chunks/chunk-K233JI4O.js";
 import {
   adjustDateHeader,
   handleNextCacheHeader,
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../../esm-chunks/chunk-SMSOJ2OS.js";
+} from "../../esm-chunks/chunk-YG3G7B2X.js";
 import {
   nextResponseProxy
-} from "../../esm-chunks/chunk-B6QMRLBH.js";
+} from "../../esm-chunks/chunk-NE4HYI2D.js";
 import {
   __commonJS,
   __toESM
-} from "../../esm-chunks/chunk-RSKIKBZH.js";
+} from "../../esm-chunks/chunk-WELZ7LFO.js";
 
 // node_modules/node-inspect-extracted/dist/inspect.js
 var require_inspect = __commonJS({
@@ -1966,6 +1966,7 @@ var ComputeJsIncomingMessage = class extends Readable {
       this._consuming = true;
     }
     if (this._stream == null) {
+      this.complete = true;
       this.push(null);
       return;
     }
@@ -1973,6 +1974,7 @@ var ComputeJsIncomingMessage = class extends Readable {
     try {
       const data = await reader.read();
       if (data.done) {
+        this.complete = true;
         this.push(null);
       } else {
         this.push(data.value);
@@ -2425,13 +2427,13 @@ var ComputeJsOutgoingMessage = class extends Writable {
       }
       const { statusCode: statusCodeText, statusMessage } = (_b2 = statusLineResult.groups) !== null && _b2 !== void 0 ? _b2 : {};
       const statusCode = parseInt(statusCodeText, 10);
-      const headers = {};
+      const headers = [];
       for (const headerLine of headerLines) {
         if (headerLine !== "") {
           const pos = headerLine.indexOf(": ");
           const k = headerLine.slice(0, pos);
           const v = headerLine.slice(pos + 2);
-          headers[k] = v;
+          headers.push([k, v]);
         }
       }
       this._headerSent = true;
@@ -3186,8 +3188,8 @@ var ComputeJsServerResponse = class _ComputeJsServerResponse extends ComputeJsOu
   }
   _toComputeResponse(status, statusText, sentHeaders, initialDataChunks, finished) {
     const headers = new Headers();
-    for (const [key, value] of Object.entries(sentHeaders)) {
-      headers.append(key, value);
+    for (const [header, value] of sentHeaders) {
+      headers.append(header, value);
     }
     const _this = this;
     const body = this._hasBody ? new ReadableStream({
@@ -3278,7 +3280,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/headers.js

@@ -1,6 +1,6 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
@@ -10,8 +10,8 @@ import {
   setCacheControlHeaders,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../esm-chunks/chunk-SMSOJ2OS.js";
-import "../esm-chunks/chunk-RSKIKBZH.js";
+} from "../esm-chunks/chunk-YG3G7B2X.js";
+import "../esm-chunks/chunk-WELZ7LFO.js";
 export {
   adjustDateHeader,
   handleNextCacheHeader,

package/dist/run/revalidate.js

@@ -1,13 +1,13 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
         return createRequire(import.meta.url);
       })();
     
 import {
   nextResponseProxy
-} from "../esm-chunks/chunk-B6QMRLBH.js";
-import "../esm-chunks/chunk-RSKIKBZH.js";
+} from "../esm-chunks/chunk-NE4HYI2D.js";
+import "../esm-chunks/chunk-WELZ7LFO.js";
 export {
   nextResponseProxy
 };

package/dist/run/systemlog.js

@@ -1,15 +1,16 @@
 
-      const require = await (async () => {
-        const { createRequire } = await import("node:module");
+      var require = await (async () => {
+        var { 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";
+  import_internal
+} from "../esm-chunks/chunk-X7XIMV6B.js";
+import "../esm-chunks/chunk-WELZ7LFO.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
 }