@netlify/plugin-nextjs 4.15.0 → 4.17.1-runtime.1

package/lib/helpers/cache.js

@@ -9,7 +9,7 @@ const findDistDir = (publish) => {
     if (!(0, utils_1.shouldSkip)()) {
         return publish;
     }
-    // In this situation, the user has disabled the plugin, which means that they might be using next export,
+    // In this situation, the user has disabled the next-runtime, which means that they might be using next export,
     // so we'll look in a few places to find the site root. This allows us to find the .next directory.
     for (const root of [(0, path_1.resolve)(publish, '..'), (0, path_1.resolve)(publish, '..', '..')]) {
         if ((0, fs_1.existsSync)((0, path_1.join)(root, 'next.config.js'))) {

package/lib/helpers/dev.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPreDev = void 0;
+const path_1 = require("path");
+const execa_1 = __importDefault(require("execa"));
+const fs_extra_1 = require("fs-extra");
+const edge_1 = require("./edge");
+const files_1 = require("./files");
+// The types haven't been updated yet
+const onPreDev = async ({ constants, netlifyConfig }) => {
+    // Need to patch the files, because build might not have been run
+    await (0, files_1.patchNextFiles)((0, path_1.resolve)(netlifyConfig.build.publish, '..'));
+    //  Clean up old functions
+    await (0, fs_extra_1.unlink)((0, path_1.resolve)('.netlify', 'middleware.js')).catch(() => {
+        // Ignore if it doesn't exist
+    });
+    await (0, edge_1.writeDevEdgeFunction)(constants);
+    if (!(0, fs_extra_1.existsSync)((0, path_1.resolve)(netlifyConfig.build.base, 'middleware.ts')) &&
+        !(0, fs_extra_1.existsSync)((0, path_1.resolve)(netlifyConfig.build.base, 'middleware.js'))) {
+        console.log("No middleware found. Create a 'middleware.ts' or 'middleware.js' file in your project root to add custom middleware.");
+    }
+    else {
+        console.log('Watching for changes in Next.js middleware...');
+    }
+    // Eventually we might want to do this via esbuild's API, but for now the CLI works fine
+    const childProcess = (0, execa_1.default)(`esbuild`, [
+        `--bundle`,
+        `--outdir=${(0, path_1.resolve)('.netlify')}`,
+        `--format=esm`,
+        '--watch',
+        // Watch for both, because it can have either ts or js
+        (0, path_1.resolve)(netlifyConfig.build.base, 'middleware.ts'),
+        (0, path_1.resolve)(netlifyConfig.build.base, 'middleware.js'),
+    ]);
+    childProcess.stdout.pipe(process.stdout);
+    childProcess.stderr.pipe(process.stderr);
+    // Don't return the promise because we don't want to wait for the child process to finish
+};
+exports.onPreDev = onPreDev;

package/lib/helpers/edge.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateConfig = exports.writeEdgeFunctions = exports.loadMiddlewareManifest = void 0;
+exports.enableEdgeInNextConfig = exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.loadMiddlewareManifest = void 0;
 /* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -67,6 +67,25 @@ const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, net
         pattern: stripLookahead(edgeFunctionDefinition.regexp),
     };
 };
+const writeDevEdgeFunction = async ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions', }) => {
+    const manifest = {
+        functions: [
+            {
+                function: 'next-dev',
+                path: '/*',
+            },
+        ],
+        version: 1,
+    };
+    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);
+    const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, 'next-dev');
+    await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
+    await copyEdgeSourceFile({ edgeFunctionDir, file: 'next-dev.ts', target: 'index.ts' });
+    await copyEdgeSourceFile({ edgeFunctionDir, file: 'utils.ts' });
+};
+exports.writeDevEdgeFunction = writeDevEdgeFunction;
 /**
  * Writes Edge Functions for the Next middleware
  */
@@ -78,9 +97,7 @@ const writeEdgeFunctions = async (netlifyConfig) => {
     const edgeFunctionRoot = (0, path_1.resolve)('.netlify', 'edge-functions');
     await (0, fs_extra_1.emptyDir)(edgeFunctionRoot);
     if (!process.env.NEXT_DISABLE_EDGE_IMAGES) {
-        if (!process.env.NEXT_USE_NETLIFY_EDGE) {
-            console.log('Using Netlify Edge Functions for image format detection. Set env var "NEXT_DISABLE_EDGE_IMAGES=true" to disable.');
-        }
+        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');
         await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
         await copyEdgeSourceFile({ edgeFunctionDir, file: 'ipx.ts', target: 'index.ts' });
@@ -90,7 +107,7 @@ const writeEdgeFunctions = async (netlifyConfig) => {
             path: '/_next/image*',
         });
     }
-    if (process.env.NEXT_USE_NETLIFY_EDGE) {
+    if (!process.env.NEXT_DISABLE_NETLIFY_EDGE) {
         const middlewareManifest = await (0, exports.loadMiddlewareManifest)(netlifyConfig);
         if (!middlewareManifest) {
             console.error("Couldn't find the middleware manifest");
@@ -121,11 +138,10 @@ const writeEdgeFunctions = async (netlifyConfig) => {
     await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionRoot, 'manifest.json'), manifest);
 };
 exports.writeEdgeFunctions = writeEdgeFunctions;
-const updateConfig = async (publish) => {
+const enableEdgeInNextConfig = async (publish) => {
     const configFile = (0, path_1.join)(publish, 'required-server-files.json');
     const config = await (0, fs_extra_1.readJSON)(configFile);
-    config.config.env.NEXT_USE_NETLIFY_EDGE = 'true';
     await (0, fs_extra_1.writeJSON)(configFile, config);
 };
-exports.updateConfig = updateConfig;
+exports.enableEdgeInNextConfig = enableEdgeInNextConfig;
 /* eslint-enable max-lines */

package/lib/helpers/files.js

@@ -54,7 +54,7 @@ const matchesRewrite = (file, rewrites) => {
 exports.matchesRewrite = matchesRewrite;
 const getMiddleware = async (publish) => {
     var _a;
-    if (process.env.NEXT_USE_NETLIFY_EDGE) {
+    if (!process.env.NEXT_DISABLE_NETLIFY_EDGE) {
         return [];
     }
     const manifestPath = (0, pathe_1.join)(publish, 'server', 'middleware-manifest.json');
@@ -229,6 +229,7 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
     }
 };
 exports.moveStaticPages = moveStaticPages;
+const PATCH_WARNING = `/* File patched by Netlify */`;
 /**
  * Attempt to patch a source file, preserving a backup
  */
@@ -237,7 +238,11 @@ const patchFile = async ({ file, replacements, }) => {
         console.warn('File was not found');
         return false;
     }
-    const content = await (0, fs_extra_1.readFile)(file, 'utf8');
+    let content = await (0, fs_extra_1.readFile)(file, 'utf8');
+    // If the file has already been patched, patch the backed-up original instead
+    if (content.includes(PATCH_WARNING) && (0, fs_extra_1.existsSync)(`${file}.orig`)) {
+        content = await (0, fs_extra_1.readFile)(`${file}.orig`, 'utf8');
+    }
     const newContent = replacements.reduce((acc, [from, to]) => {
         if (acc.includes(to)) {
             console.log('Already patched. Skipping.');
@@ -250,7 +255,7 @@ const patchFile = async ({ file, replacements, }) => {
         return false;
     }
     await (0, fs_extra_1.writeFile)(`${file}.orig`, content);
-    await (0, fs_extra_1.writeFile)(file, newContent);
+    await (0, fs_extra_1.writeFile)(file, `${newContent}\n${PATCH_WARNING}`);
     console.log('Done');
     return true;
 };
@@ -271,19 +276,19 @@ const baseServerReplacements = [
 const nextServerReplacements = [
     [
         `getMiddlewareManifest() {\n        if (this.minimalMode) return null;`,
-        `getMiddlewareManifest() {\n        if (this.minimalMode || process.env.NEXT_USE_NETLIFY_EDGE) return null;`,
+        `getMiddlewareManifest() {\n        if (this.minimalMode || !process.env.NEXT_DISABLE_NETLIFY_EDGE) return null;`,
     ],
     [
         `generateCatchAllMiddlewareRoute(devReady) {\n        if (this.minimalMode) return []`,
-        `generateCatchAllMiddlewareRoute(devReady) {\n        if (this.minimalMode || process.env.NEXT_USE_NETLIFY_EDGE) return [];`,
+        `generateCatchAllMiddlewareRoute(devReady) {\n        if (this.minimalMode || !process.env.NEXT_DISABLE_NETLIFY_EDGE) return [];`,
     ],
     [
         `generateCatchAllMiddlewareRoute() {\n        if (this.minimalMode) return undefined;`,
-        `generateCatchAllMiddlewareRoute() {\n        if (this.minimalMode || process.env.NEXT_USE_NETLIFY_EDGE) return undefined;`,
+        `generateCatchAllMiddlewareRoute() {\n        if (this.minimalMode || !process.env.NEXT_DISABLE_NETLIFY_EDGE) return undefined;`,
     ],
     [
         `getMiddlewareManifest() {\n        if (this.minimalMode) {`,
-        `getMiddlewareManifest() {\n        if (!this.minimalMode && !process.env.NEXT_USE_NETLIFY_EDGE) {`,
+        `getMiddlewareManifest() {\n        if (!this.minimalMode && process.env.NEXT_DISABLE_NETLIFY_EDGE) {`,
     ],
 ];
 const patchNextFiles = async (root) => {

package/lib/helpers/utils.js

@@ -136,7 +136,7 @@ const findModuleFromBase = ({ paths, candidates }) => {
 exports.findModuleFromBase = findModuleFromBase;
 const isNextAuthInstalled = () => {
     try {
-        // eslint-disable-next-line import/no-unassigned-import, import/no-unresolved, n/no-missing-require
+        // eslint-disable-next-line import/no-unassigned-import, import/no-extraneous-dependencies, n/no-extraneous-require
         require('next-auth');
         return true;
     }

package/lib/helpers/verification.js

@@ -42,7 +42,7 @@ const verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild,
     // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
     if (IS_LOCAL && !(0, semver_1.satisfies)(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
         return failBuild((0, outdent_1.outdent) `
-      This version of the Essential Next.js plugin requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
+      This version of the Next Runtime requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
       You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"
     `);
     }
@@ -136,7 +136,7 @@ exports.checkZipSize = checkZipSize;
 const getProblematicUserRewrites = ({ redirects, basePath, }) => {
     const userRewrites = [];
     for (const redirect of redirects) {
-        // This is the first of the plugin-generated redirects so we can stop checking
+        // This is the first of the runtime-generated redirects so we can stop checking
         if (redirect.from === `${basePath}/_next/static/*` && redirect.to === `/static/:splat` && redirect.status === 200) {
             break;
         }
@@ -159,7 +159,7 @@ const warnForProblematicUserRewrites = ({ redirects, basePath, }) => {
         return;
     }
     console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
-      You have the following Netlify rewrite${userRewrites.length === 1 ? '' : 's'} that might cause conflicts with the Next.js plugin:
+      You have the following Netlify rewrite${userRewrites.length === 1 ? '' : 's'} that might cause conflicts with the Next.js Runtime:
 
       ${(0, chalk_1.reset)(userRewrites.map(({ from, to, status }) => `- ${from} ${to} ${status}`).join('\n'))}
 

package/lib/index.js

@@ -8,6 +8,7 @@ const outdent_1 = require("outdent");
 const constants_1 = require("./constants");
 const cache_1 = require("./helpers/cache");
 const config_1 = require("./helpers/config");
+const dev_1 = require("./helpers/dev");
 const edge_1 = require("./helpers/edge");
 const files_1 = require("./helpers/files");
 const functions_1 = require("./helpers/functions");
@@ -20,7 +21,7 @@ const plugin = {
         const { publish } = netlifyConfig.build;
         if ((0, utils_1.shouldSkip)()) {
             await (0, cache_1.restoreCache)({ cache, publish });
-            console.log('Not running Essential Next.js plugin');
+            console.log('Not running Next Runtime');
             if ((0, fs_extra_1.existsSync)((0, path_1.join)(constants.INTERNAL_FUNCTIONS_SRC, constants_1.HANDLER_FUNCTION_NAME))) {
                 console.log(`Please ensure you remove any generated functions from ${constants.INTERNAL_FUNCTIONS_SRC}`);
             }
@@ -34,7 +35,6 @@ const plugin = {
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
-        var _a;
         if ((0, utils_1.shouldSkip)()) {
             return;
         }
@@ -45,6 +45,28 @@ const plugin = {
             publish,
             failBuild,
         });
+        const middlewareManifest = await (0, edge_1.loadMiddlewareManifest)(netlifyConfig);
+        let usingEdge = false;
+        if (Object.keys(middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.functions).length !== 0) {
+            usingEdge = true;
+            if (process.env.NEXT_DISABLE_NETLIFY_EDGE) {
+                failBuild((0, outdent_1.outdent) `
+          You are using Next.js experimental edge runtime, but have set NEXT_DISABLE_NETLIFY_EDGE to true. This is not supported.
+          To use edge runtime, remove the env var ${(0, chalk_1.bold) `NEXT_DISABLE_NETLIFY_EDGE`}.
+        `);
+            }
+        }
+        if (Object.keys(middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.middleware).length !== 0) {
+            usingEdge = true;
+            if (process.env.NEXT_DISABLE_NETLIFY_EDGE) {
+                console.log((0, chalk_1.redBright)((0, outdent_1.outdent) `
+            You are using Next.js Middleware without Netlify Edge Functions.
+            This is deprecated because it negatively affects performance and will disable ISR and static rendering.
+            It also disables advanced middleware features from @netlify/next
+            To get the best performance and use Netlify Edge Functions, remove the env var ${(0, chalk_1.bold) `NEXT_DISABLE_NETLIFY_EDGE`}.
+          `));
+            }
+        }
         if (experimental.images) {
             experimentalRemotePatterns = experimental.images.remotePatterns || [];
         }
@@ -87,29 +109,20 @@ const plugin = {
             nextConfig: { basePath, i18n, trailingSlash, appDir },
             buildId,
         });
-        // We call this even if we don't have edge functions enabled because we still use it for images
-        await (0, edge_1.writeEdgeFunctions)(netlifyConfig);
-        if (process.env.NEXT_USE_NETLIFY_EDGE) {
+        if (usingEdge) {
+            await (0, edge_1.writeEdgeFunctions)(netlifyConfig);
+            await (0, edge_1.enableEdgeInNextConfig)(publish);
             console.log((0, outdent_1.outdent) `
-        ✨ Deploying to ${(0, chalk_1.greenBright) `Netlify Edge Functions`} ✨
+        ✨ Deploying middleware and functions to ${(0, chalk_1.greenBright) `Netlify Edge Functions`} ✨
         This feature is in beta. Please share your feedback here: https://ntl.fyi/next-netlify-edge
       `);
-            await (0, edge_1.updateConfig)(publish);
-        }
-        const middlewareManifest = await (0, edge_1.loadMiddlewareManifest)(netlifyConfig);
-        if (!process.env.NEXT_USE_NETLIFY_EDGE && ((_a = middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.sortedMiddleware) === null || _a === void 0 ? void 0 : _a.length)) {
-            console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
-          You are using Next.js Middleware without Netlify Edge Functions.
-          This will soon be deprecated because it negatively affects performance and will disable ISR and static rendering.
-          To get the best performance and use Netlify Edge Functions, set the env var ${(0, chalk_1.bold) `NEXT_USE_NETLIFY_EDGE=true`}.
-        `));
         }
     },
     async onPostBuild({ netlifyConfig: { build: { publish }, redirects, headers, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
         await (0, cache_1.saveCache)({ cache, publish });
         if ((0, utils_1.shouldSkip)()) {
             status.show({
-                title: 'Essential Next.js plugin did not run',
+                title: 'Next Runtime did not run',
                 summary: `Next cache was stored, but all other functions were skipped because ${process.env.NETLIFY_NEXT_PLUGIN_SKIP
                     ? `NETLIFY_NEXT_PLUGIN_SKIP is set`
                     : `NEXT_PLUGIN_FORCE_RUN is set to ${process.env.NEXT_PLUGIN_FORCE_RUN}`}`,
@@ -123,8 +136,26 @@ const plugin = {
         (0, config_1.generateCustomHeaders)(nextConfig, headers);
         (0, verification_1.warnForProblematicUserRewrites)({ basePath, redirects });
         (0, verification_1.warnForRootRedirects)({ appDir });
-        await (0, files_1.unpatchNextFiles)(basePath);
     },
 };
-module.exports = plugin;
+// The types haven't been updated yet
+const nextRuntime = (_inputs, meta = {}) => {
+    var _a;
+    if (!((_a = meta === null || meta === void 0 ? void 0 : meta.events) === null || _a === void 0 ? void 0 : _a.has('onPreDev'))) {
+        return {
+            ...plugin,
+            onEnd: ({ utils }) => {
+                utils.status.show({
+                    title: 'Please upgrade to the latest version of the Netlify CLI',
+                    summary: 'To support for the latest Next.js features, please upgrade to the latest version of the Netlify CLI',
+                });
+            },
+        };
+    }
+    return {
+        ...plugin,
+        onPreDev: dev_1.onPreDev,
+    };
+};
+module.exports = nextRuntime;
 /* eslint-enable max-lines */

package/lib/templates/getHandler.js

@@ -81,6 +81,13 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
         // Next expects to be able to parse the query from the URL
         const query = new URLSearchParams(event.queryStringParameters).toString();
         event.path = query ? `${event.path}?${query}` : event.path;
+        const graphToken = event.netlifyGraphToken;
+        if (graphToken && requestMode !== 'ssr') {
+            // Prefix with underscore to help us determine the origin of the token
+            // allows us to write better error messages
+            // eslint-disable-next-line no-underscore-dangle
+            process.env._NETLIFY_GRAPH_TOKEN = graphToken;
+        }
         const { headers, ...result } = await getBridge(event).launcher(event, context);
         // Convert all headers to multiValueHeaders
         const multiValueHeaders = getMultiValueHeaders(headers);

package/manifest.yml

@@ -1 +1 @@
-name: netlify-plugin-nextjs-experimental
+name: netlify-next-runtime-experimental

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.15.0",
+  "version": "4.17.1-runtime.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -9,10 +9,12 @@
     "manifest.yml"
   ],
   "dependencies": {
-    "@netlify/functions": "^1.0.0",
-    "@netlify/ipx": "^1.2.0",
+    "@netlify/esbuild": "0.14.25",
+    "@netlify/functions": "^1.2.0",
+    "@netlify/ipx": "^1.2.2",
     "@vercel/node-bridge": "^2.1.0",
     "chalk": "^4.1.2",
+    "execa": "^5.1.1",
     "fs-extra": "^10.0.0",
     "globby": "^11.0.4",
     "moize": "^6.1.0",
@@ -22,13 +24,13 @@
     "p-limit": "^3.1.0",
     "pathe": "^0.2.0",
     "pretty-bytes": "^5.6.0",
-    "slash": "^3.0.0",
     "semver": "^7.3.5",
+    "slash": "^3.0.0",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^27.11.4",
+    "@netlify/build": "^27.14.0",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/node": "^17.0.25",
@@ -51,14 +53,13 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/netlify/netlify-plugin-nextjs.git"
+    "url": "git+https://github.com/netlify/next-runtime.git"
   },
-  "author": "",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/netlify/netlify-plugin-nextjs/issues"
+    "url": "https://github.com/netlify/next-runtime/issues"
   },
-  "homepage": "https://github.com/netlify/netlify-plugin-nextjs#readme",
+  "homepage": "https://github.com/netlify/next-runtime#readme",
   "engines": {
     "node": ">=12.0.0"
   }

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

@@ -0,0 +1,155 @@
+import type { Context } from 'https://edge.netlify.com'
+import { NextRequest, NextResponse } from 'https://esm.sh/next/server'
+import { fromFileUrl } from 'https://deno.land/std/path/mod.ts'
+import { buildResponse } from './utils.ts'
+
+export interface FetchEventResult {
+  response: Response
+  waitUntil: Promise<unknown>
+}
+
+interface I18NConfig {
+  defaultLocale: string
+  domains?: DomainLocale[]
+  localeDetection?: false
+  locales: string[]
+}
+
+interface DomainLocale {
+  defaultLocale: string
+  domain: string
+  http?: true
+  locales?: string[]
+}
+export interface NextRequestInit extends RequestInit {
+  geo?: {
+    city?: string
+    country?: string
+    region?: string
+  }
+  ip?: string
+  nextConfig?: {
+    basePath?: string
+    i18n?: I18NConfig | null
+    trailingSlash?: boolean
+  }
+}
+
+export interface RequestData {
+  geo?: {
+    city?: string
+    country?: string
+    region?: string
+    latitude?: string
+    longitude?: string
+  }
+  headers: Record<string, string>
+  ip?: string
+  method: string
+  nextConfig?: {
+    basePath?: string
+    i18n?: Record<string, unknown>
+    trailingSlash?: boolean
+  }
+  page?: {
+    name?: string
+    params?: { [key: string]: string }
+  }
+  url: string
+  body?: ReadableStream<Uint8Array>
+}
+
+export interface RequestContext {
+  request: Request
+  context: Context
+}
+
+declare global {
+  // deno-lint-ignore no-var
+  var NFRequestContextMap: Map<string, RequestContext>
+  // deno-lint-ignore no-var
+  var __dirname: string
+}
+
+globalThis.NFRequestContextMap ||= new Map()
+globalThis.__dirname = fromFileUrl(new URL('./', import.meta.url)).slice(0, -1)
+
+// Check if a file exists, given a relative path
+const exists = async (relativePath: string) => {
+  const path = fromFileUrl(new URL(relativePath, import.meta.url))
+  try {
+    await Deno.stat(path)
+    return true
+  } catch (error) {
+    if (error instanceof Deno.errors.NotFound) {
+      return false
+    }
+    throw error
+  }
+}
+
+const handler = async (req: Request, context: Context) => {
+  // Uncomment when CLI update lands
+  // if (!Deno.env.get('NETLIFY_DEV')) {
+  //   // Only run in dev
+  //   return
+  // }
+
+  let middleware
+  // Dynamic imports and FS operations aren't allowed when deployed,
+  // but that's fine because this is only ever used locally.
+  // We don't want to just try importing and use that to test,
+  // because that would also throw if there's an error in the middleware,
+  // which we would want to surface not ignore.
+  if (await exists('../../middleware.js')) {
+    // These will be user code
+    const nextMiddleware = await import('../../middleware.js')
+    middleware = nextMiddleware.middleware
+  } else {
+    //  No middleware, so we silently return
+    return
+  }
+
+  //  This is the format expected by Next.js
+  const geo: NextRequestInit['geo'] = {
+    country: context.geo.country?.code,
+    region: context.geo.subdivision?.code,
+    city: context.geo.city,
+  }
+
+  // A default request id is fine locally
+  const requestId = req.headers.get('x-nf-request-id') || 'request-id'
+
+  globalThis.NFRequestContextMap.set(requestId, {
+    request: req,
+    context,
+  })
+
+  const request: NextRequestInit = {
+    headers: Object.fromEntries(req.headers.entries()),
+    geo,
+    method: req.method,
+    ip: context.ip,
+    body: req.body || undefined,
+  }
+
+  const nextRequest: NextRequest = new NextRequest(req, request)
+
+  try {
+    const response = await middleware(nextRequest)
+    return buildResponse({
+      result: { response: response || NextResponse.next(), waitUntil: Promise.resolve() },
+      request: req,
+      context,
+    })
+  } catch (error) {
+    console.error(error)
+    return new Response(error.message, { status: 500 })
+  } finally {
+    if (requestId) {
+      globalThis.NFRequestContextMap.delete(requestId)
+    }
+  }
+}
+
+export default handler

package/src/templates/edge/runtime.ts

@@ -45,6 +45,10 @@ declare global {
 globalThis.NFRequestContextMap ||= new Map()
 
 const handler = async (req: Request, context: Context) => {
+  if (Deno.env.get('NETLIFY_DEV')) {
+    // Don't run in dev
+    return
+  }
   const url = new URL(req.url)
 
   const geo = {

package/src/templates/edge/utils.ts

@@ -123,17 +123,38 @@ export const buildResponse = async ({
   request.headers.set('x-nf-next-middleware', 'skip')
 
   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')
+
   if (rewrite) {
     const rewriteUrl = new URL(rewrite, request.url)
     const baseUrl = new URL(request.url)
+    const relativeUrl = relativizeURL(rewrite, request.url)
+
+    // 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) {
+      res.headers.set('x-nextjs-rewrite', relativeUrl)
+    }
     if (rewriteUrl.hostname !== baseUrl.hostname) {
       // 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)
     }
-    res.headers.set('x-middleware-rewrite', relativizeURL(rewrite, request.url))
+    res.headers.set('x-middleware-rewrite', relativeUrl)
+
     return addMiddlewareHeaders(context.rewrite(rewrite), res)
   }
+
+  const redirect = res.headers.get('Location')
+
+  // Data requests shouldn;t automatically redirect in the browser (they might be HTML pages): they're handled by the router
+  if (redirect && isDataReq) {
+    res.headers.delete('location')
+    res.headers.set('x-nextjs-redirect', relativizeURL(redirect, request.url))
+  }
+
   if (res.headers.get('x-middleware-next') === '1') {
     return addMiddlewareHeaders(context.next(), res)
   }