@netlify/plugin-nextjs 4.16.0 → 4.17.1-api-routes.0

package/lib/helpers/analysis.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConfigFromFile = exports.validateConfigValue = void 0;
+const fs_1 = __importDefault(require("fs"));
+const extract_const_value_1 = require("next/dist/build/analysis/extract-const-value");
+const parse_module_1 = require("next/dist/build/analysis/parse-module");
+const pathe_1 = require("pathe");
+const validateConfigValue = (config, apiFilePath) => {
+    if (config.type === 'experimental-scheduled') {
+        if (!config.schedule) {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: schedule is required when type is "experimental-scheduled"`);
+            return false;
+        }
+        if (config.runtime === 'experimental-edge') {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: edge runtime is not supported for scheduled functions`);
+            return false;
+        }
+        return true;
+    }
+    if (!config.type || config.type === 'experimental-background') {
+        if (config.schedule) {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: schedule is not allowed unless type is "experimental-scheduled"`);
+            return false;
+        }
+        if (config.type && config.runtime === 'experimental-edge') {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: edge runtime is not supported for background functions`);
+            return false;
+        }
+        return true;
+    }
+    console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: type ${config.type} is not supported`);
+    return false;
+};
+exports.validateConfigValue = validateConfigValue;
+/**
+ * Uses Next's swc static analysis to extract the config values from a file.
+ */
+const extractConfigFromFile = async (apiFilePath) => {
+    const fileContent = await fs_1.default.promises.readFile(apiFilePath, 'utf8');
+    // No need to parse if there's no "config"
+    if (!fileContent.includes('config')) {
+        return {};
+    }
+    const ast = await (0, parse_module_1.parseModule)(apiFilePath, fileContent);
+    let config;
+    try {
+        config = (0, extract_const_value_1.extractExportedConstValue)(ast, 'config');
+    }
+    catch (error) {
+        if (error instanceof extract_const_value_1.UnsupportedValueError) {
+            console.warn(`Unsupported config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}`);
+        }
+        return {};
+    }
+    if ((0, exports.validateConfigValue)(config, apiFilePath)) {
+        return config;
+    }
+    throw new Error(`Unsupported config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}`);
+};
+exports.extractConfigFromFile = extractConfigFromFile;

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/config.js

@@ -64,7 +64,7 @@ const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [] }
     /* eslint-disable no-underscore-dangle */
     (_a = netlifyConfig.functions)._ipx || (_a._ipx = {});
     netlifyConfig.functions._ipx.node_bundler = 'nft';
-    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME].forEach((functionName) => {
+    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME, '_api_*'].forEach((functionName) => {
         var _a, _b;
         (_a = netlifyConfig.functions)[functionName] || (_a[functionName] = { included_files: [], external_node_modules: [] });
         netlifyConfig.functions[functionName].node_bundler = 'nft';

package/lib/helpers/dev.js

@@ -0,0 +1,37 @@
+"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 }) => {
+    var _a;
+    const base = (_a = netlifyConfig.build.base) !== null && _a !== void 0 ? _a : process.cwd();
+    // Need to patch the files, because build might not have been run
+    await (0, files_1.patchNextFiles)(base);
+    //  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)(base, 'middleware.ts')) && !(0, fs_extra_1.existsSync)((0, path_1.resolve)(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 common = [`--bundle`, `--outdir=${(0, path_1.resolve)('.netlify')}`, `--format=esm`, `--target=esnext`, '--watch'];
+    // TypeScript
+    (0, execa_1.default)(`esbuild`, [...common, (0, path_1.resolve)(base, 'middleware.ts')], { all: true }).all.pipe(process.stdout);
+    // JavaScript
+    (0, execa_1.default)(`esbuild`, [...common, (0, path_1.resolve)(base, 'middleware.js')], { all: true }).all.pipe(process.stdout);
+    // 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.js', target: 'index.js' });
+    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

@@ -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.movePublicFiles = exports.unpatchNextFiles = exports.unpatchFile = exports.patchNextFiles = exports.moveStaticPages = exports.getMiddleware = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
+exports.movePublicFiles = exports.unpatchNextFiles = exports.unpatchFile = exports.patchNextFiles = exports.getDependenciesOfFile = exports.getSourceFileForPage = exports.moveStaticPages = exports.getMiddleware = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
 /* eslint-disable max-lines */
 const os_1 = require("os");
 const chalk_1 = require("chalk");
@@ -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');
@@ -270,25 +270,49 @@ const getServerFile = (root, includeBase = true) => {
     }
     return (0, utils_1.findModuleFromBase)({ candidates, paths: [root] });
 };
+/**
+ * Find the source file for a given page route
+ */
+const getSourceFileForPage = (page, root) => {
+    for (const extension of ['ts', 'js']) {
+        const file = (0, pathe_1.join)(root, `${page}.${extension}`);
+        if ((0, fs_extra_1.existsSync)(file)) {
+            return file;
+        }
+    }
+};
+exports.getSourceFileForPage = getSourceFileForPage;
+/**
+ * Reads the node file trace file for a given file, and resolves the dependencies
+ */
+const getDependenciesOfFile = async (file) => {
+    const nft = `${file}.nft.json`;
+    if (!(0, fs_extra_1.existsSync)(nft)) {
+        return [];
+    }
+    const dependencies = await (0, fs_extra_1.readJson)(nft, 'utf8');
+    return dependencies.files.map((dep) => (0, pathe_1.resolve)(file, dep));
+};
+exports.getDependenciesOfFile = getDependenciesOfFile;
 const baseServerReplacements = [
     [`let ssgCacheKey = `, `let ssgCacheKey = process.env._BYPASS_SSG || `],
 ];
 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/functions.js

@@ -3,23 +3,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
+exports.getApiRouteConfigs = exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
 const node_bridge_1 = __importDefault(require("@vercel/node-bridge"));
 const fs_extra_1 = require("fs-extra");
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
+const getApiHandler_1 = require("../templates/getApiHandler");
 const getHandler_1 = require("../templates/getHandler");
 const getPageResolver_1 = require("../templates/getPageResolver");
-const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
-    const functionsDir = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
-    const functionDir = (0, pathe_1.join)(process.cwd(), functionsDir, constants_1.HANDLER_FUNCTION_NAME);
-    const publishDir = (0, pathe_1.relative)(functionDir, (0, pathe_1.resolve)(PUBLISH_DIR));
-    const writeHandler = async (func, isODB) => {
+const analysis_1 = require("./analysis");
+const files_1 = require("./files");
+const utils_1 = require("./utils");
+const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir, apiRoutes) => {
+    const publish = (0, pathe_1.resolve)(PUBLISH_DIR);
+    const functionsDir = (0, pathe_1.resolve)(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC);
+    console.log({ functionsDir });
+    const functionDir = (0, pathe_1.join)(functionsDir, constants_1.HANDLER_FUNCTION_NAME);
+    const publishDir = (0, pathe_1.relative)(functionDir, publish);
+    for (const { route, config, compiled } of apiRoutes) {
+        const apiHandlerSource = await (0, getApiHandler_1.getApiHandler)({
+            page: route,
+            config,
+        });
+        const functionName = (0, utils_1.getFunctionNameForPage)(route, config.type === 'experimental-background');
+        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), apiHandlerSource);
+        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, functionName, 'bridge.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, functionName, 'handlerUtils.js'));
+        const resolverSource = await (0, getPageResolver_1.getSinglePageResolver)({
+            functionsDir,
+            sourceFile: (0, pathe_1.join)(publish, 'server', compiled),
+        });
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, 'pages.js'), resolverSource);
+    }
+    const writeHandler = async (functionName, isODB) => {
         const handlerSource = await (0, getHandler_1.getHandler)({ isODB, publishDir, appDir: (0, pathe_1.relative)(functionDir, appDir) });
-        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, func));
-        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, func, `${func}.js`), handlerSource);
-        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, func, 'bridge.js'));
-        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, func, 'handlerUtils.js'));
+        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), handlerSource);
+        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, functionName, 'bridge.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, functionName, 'handlerUtils.js'));
     };
     await writeHandler(constants_1.HANDLER_FUNCTION_NAME, false);
     await writeHandler(constants_1.ODB_FUNCTION_NAME, true);
@@ -76,3 +98,16 @@ const setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIO
     }
 };
 exports.setupImageFunction = setupImageFunction;
+/**
+ * Look for API routes, and extract the config from the source file.
+ */
+const getApiRouteConfigs = async (publish, baseDir) => {
+    const pages = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(publish, 'server', 'pages-manifest.json'));
+    const apiRoutes = Object.keys(pages).filter((page) => page.startsWith('/api/'));
+    const pagesDir = (0, pathe_1.join)(baseDir, 'pages');
+    return Promise.all(apiRoutes.map(async (apiRoute) => {
+        const filePath = (0, files_1.getSourceFileForPage)(apiRoute, pagesDir);
+        return { route: apiRoute, config: await (0, analysis_1.extractConfigFromFile)(filePath), compiled: pages[apiRoute] };
+    }));
+};
+exports.getApiRouteConfigs = getApiRouteConfigs;

package/lib/helpers/redirects.js

@@ -146,7 +146,7 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
         dynamicRewrites,
     };
 };
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, }) => {
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, apiRoutes, }) => {
     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) => ({
@@ -161,7 +161,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     // This is only used in prod, so dev uses `next dev` directly
     netlifyConfig.redirects.push(
     // API routes always need to be served from the regular function
-    ...(0, utils_1.getApiRewrites)(basePath), 
+    ...(0, utils_1.getApiRewrites)(basePath, apiRoutes), 
     // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
     ...(await (0, utils_1.getPreviewRewrites)({ basePath, appDir })));
     const middleware = await (0, files_1.getMiddleware)(netlifyConfig.build.publish);

package/lib/helpers/utils.js

@@ -3,10 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = exports.getFunctionNameForPage = void 0;
 const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
+const RESERVED_FILENAME = /[^\w_-]/g;
+/**
+ * Given a Next route, generates a valid Netlify function name.
+ * If "background" is true then the function name will have `-background`
+ * appended to it, meaning that it is executed as a background function.
+ */
+const getFunctionNameForPage = (page, background = false) => `${page
+    .replace(constants_1.CATCH_ALL_REGEX, '_$1-SPLAT')
+    .replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '-SPLAT')
+    .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '_$1-PARAM')
+    .replace(RESERVED_FILENAME, '_')}-${background ? 'background' : 'handler'}`;
+exports.getFunctionNameForPage = getFunctionNameForPage;
 const toNetlifyRoute = (nextRoute) => {
     const netlifyRoutes = [nextRoute];
     // If the route is an optional catch-all route, we need to add a second
@@ -77,18 +89,33 @@ const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status
     force,
 }));
 exports.redirectsForNextRouteWithData = redirectsForNextRouteWithData;
-const getApiRewrites = (basePath) => [
-    {
-        from: `${basePath}/api`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    },
-    {
-        from: `${basePath}/api/*`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    },
-];
+const getApiRewrites = (basePath, apiRoutes) => {
+    const apiRewrites = apiRoutes.map((apiRoute) => {
+        const [from] = (0, exports.toNetlifyRoute)(`${basePath}${apiRoute.route}`);
+        // Scheduled functions can't be invoked directly, so we 404 them.
+        if (apiRoute.config.type === 'experimental-scheduled') {
+            return { from, to: '/404.html', status: 404 };
+        }
+        return {
+            from,
+            to: `/.netlify/functions/${(0, exports.getFunctionNameForPage)(apiRoute.route, apiRoute.config.type === 'experimental-background')}`,
+            status: 200,
+        };
+    });
+    return [
+        ...apiRewrites,
+        {
+            from: `${basePath}/api`,
+            to: constants_1.HANDLER_FUNCTION_PATH,
+            status: 200,
+        },
+        {
+            from: `${basePath}/api/*`,
+            to: constants_1.HANDLER_FUNCTION_PATH,
+            status: 200,
+        },
+    ];
+};
 exports.getApiRewrites = getApiRewrites;
 const getPreviewRewrites = async ({ basePath, appDir }) => {
     const publicFiles = await (0, globby_1.default)('**/*', { cwd: (0, pathe_1.join)(appDir, 'public') });
@@ -136,7 +163,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 ((middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.functions) && Object.keys(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 ((middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.middleware) && Object.keys(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 || [];
         }
@@ -63,10 +85,11 @@ const plugin = {
         }
         const buildId = (0, fs_extra_1.readFileSync)((0, path_1.join)(publish, 'BUILD_ID'), 'utf8').trim();
         await (0, config_1.configureHandlerFunctions)({ netlifyConfig, ignore, publish: (0, path_1.relative)(process.cwd(), publish) });
-        await (0, functions_1.generateFunctions)(constants, appDir);
+        const apiRoutes = await (0, functions_1.getApiRouteConfigs)(publish, appDir);
+        await (0, functions_1.generateFunctions)(constants, appDir, apiRoutes);
         await (0, functions_1.generatePagesResolver)({ target, constants });
         await (0, files_1.movePublicFiles)({ appDir, outdir, publish });
-        await (0, files_1.patchNextFiles)(basePath);
+        await (0, files_1.patchNextFiles)(appDir);
         if (!process.env.SERVE_STATIC_FILES_FROM_ORIGIN) {
             await (0, files_1.moveStaticPages)({ target, netlifyConfig, i18n, basePath });
         }
@@ -86,30 +109,22 @@ const plugin = {
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
             buildId,
+            apiRoutes,
         });
-        // 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}`}`,
@@ -125,5 +140,24 @@ const plugin = {
         (0, verification_1.warnForRootRedirects)({ appDir });
     },
 };
-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/getApiHandler.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiHandler = void 0;
+// Aliasing like this means the editor may be able to syntax-highlight the string
+const outdent_1 = require("outdent");
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { Server } = require('http');
+const path = require('path');
+// eslint-disable-next-line n/prefer-global/url, n/prefer-global/url-search-params
+const { URLSearchParams, URL } = require('url');
+const { Bridge } = require('@vercel/node-bridge/bridge');
+const { getMultiValueHeaders, getNextServer } = require('./handlerUtils');
+// We return a function and then call `toString()` on it to serialise it as the launcher function
+const makeHandler = (conf, app, pageRoot, page) => {
+    var _a;
+    // Change working directory into the site root, unless using Nx, which moves the
+    // dist directory and handles this itself
+    const dir = path.resolve(__dirname, app);
+    if (pageRoot.startsWith(dir)) {
+        process.chdir(dir);
+    }
+    // This is just so nft knows about the page entrypoints. It's not actually used
+    try {
+        // eslint-disable-next-line n/no-missing-require
+        require.resolve('./pages.js');
+    }
+    catch { }
+    // React assumes you want development mode if NODE_ENV is unset.
+    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+    ;
+    (_a = process.env).NODE_ENV || (_a.NODE_ENV = 'production');
+    // We don't want to write ISR files to disk in the lambda environment
+    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';
+    for (const [key, value] of Object.entries(conf.env)) {
+        process.env[key] = String(value);
+    }
+    // We memoize this because it can be shared between requests, but don't instantiate it until
+    // the first request because we need the host and port.
+    let bridge;
+    const getBridge = (event) => {
+        if (bridge) {
+            return bridge;
+        }
+        // Scheduled functions don't have a URL, but we need to give one so Next knows the route to serve
+        const url = event.rawUrl ? new URL(event.rawUrl) : new URL(path, process.env.URL || 'http://n');
+        const port = Number.parseInt(url.port) || 80;
+        const NextServer = getNextServer();
+        const nextServer = new NextServer({
+            // We know we're just an API route, so can enable minimal mode
+            minimalMode: true,
+            conf,
+            dir,
+            customServer: false,
+            hostname: url.hostname,
+            port,
+        });
+        const requestHandler = nextServer.getRequestHandler();
+        const server = new Server(async (req, res) => {
+            try {
+                await requestHandler(req, res);
+            }
+            catch (error) {
+                console.error(error);
+                throw new Error('Error handling request. See function logs for details.');
+            }
+        });
+        bridge = new Bridge(server);
+        bridge.listen();
+        return bridge;
+    };
+    return async function handler(event, context) {
+        // Ensure that paths are encoded - but don't double-encode them
+        event.path = event.rawUrl ? new URL(event.rawUrl).pathname : page;
+        // 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;
+        // We know the page
+        event.headers['x-matched-path'] = page;
+        const { headers, ...result } = await getBridge(event).launcher(event, context);
+        // Convert all headers to multiValueHeaders
+        const multiValueHeaders = getMultiValueHeaders(headers);
+        multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
+        console.log(`[${event.httpMethod}] ${event.path} (API)`);
+        return {
+            ...result,
+            multiValueHeaders,
+            isBase64Encoded: result.encoding === 'base64',
+        };
+    };
+};
+/**
+ * Handlers for API routes are simpler than page routes, but they each have a separate one
+ */
+const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '../../..', }) => 
+// This is a string, but if you have the right editor plugin it should format as js
+(0, outdent_1.outdent /* javascript */) `
+  const { Server } = require("http");
+  // We copy the file here rather than requiring from the node module
+  const { Bridge } = require("./bridge");
+  const { getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
+
+  ${config.type === 'experimental-scheduled' ? `const { schedule } = require("@netlify/functions")` : ''}
+
+
+  const { config }  = require("${publishDir}/required-server-files.json")
+  let staticManifest
+  const path = require("path");
+  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "serverless", "pages"));
+  const handler = (${makeHandler.toString()})(config, "${appDir}", pageRoot, ${JSON.stringify(page)})
+  exports.handler = ${config.type === 'experimental-scheduled' ? `schedule(${JSON.stringify(config.schedule)}, handler);` : 'handler'}
+`;
+exports.getApiHandler = getApiHandler;

package/lib/templates/getHandler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHandler = void 0;
+// Aliasing like this means the editor may be able to syntax-highlight the string
 const outdent_1 = require("outdent");
 /* eslint-disable @typescript-eslint/no-var-requires */
 const { promises } = require('fs');
@@ -119,14 +120,14 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
 };
 const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => 
 // This is a string, but if you have the right editor plugin it should format as js
-(0, outdent_1.outdent) `
+(0, outdent_1.outdent /* javascript */) `
   const { Server } = require("http");
   const { promises } = require("fs");
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
   const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
 
-  const { builder } = require("@netlify/functions");
+  ${isODB ? `const { builder } = require("@netlify/functions")` : ''}
   const { config }  = require("${publishDir}/required-server-files.json")
   let staticManifest
   try {

package/lib/templates/getPageResolver.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageResolver = void 0;
+exports.getSinglePageResolver = exports.getPageResolver = void 0;
 const path_1 = require("path");
 const outdent_1 = require("outdent");
+const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
 const tiny_glob_1 = __importDefault(require("tiny-glob"));
 const constants_1 = require("../constants");
+const files_1 = require("../helpers/files");
 // Generate a file full of require.resolve() calls for all the pages in the
 // build. This is used by the nft bundler to find all the pages.
 const getPageResolver = async ({ publish, target }) => {
@@ -31,3 +33,22 @@ const getPageResolver = async ({ publish, target }) => {
   `;
 };
 exports.getPageResolver = getPageResolver;
+/**
+ * API routes only need the dependencies for a single entrypoint, so we use the
+ * NFT trace file to get the dependencies.
+ */
+const getSinglePageResolver = async ({ functionsDir, sourceFile, }) => {
+    const dependencies = await (0, files_1.getDependenciesOfFile)(sourceFile);
+    // We don't need the actual name, just the relative path.
+    const functionDir = (0, pathe_1.resolve)(functionsDir, 'functionName');
+    const pageFiles = [sourceFile, ...dependencies]
+        .map((file) => `require.resolve('${(0, pathe_1.relative)(functionDir, file)}')`)
+        .sort();
+    return (0, outdent_1.outdent /* javascript */) `
+    // This file is purely to allow nft to know about these pages. 
+      try {
+          ${pageFiles.join('\n        ')}
+      } catch {}
+  `;
+};
+exports.getSinglePageResolver = getSinglePageResolver;

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.16.0",
+  "version": "4.17.1-api-routes.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -9,10 +9,12 @@
     "manifest.yml"
   ],
   "dependencies": {
-    "@netlify/functions": "^1.1.0",
-    "@netlify/ipx": "^1.2.1",
+    "@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.15.6",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/node": "^17.0.25",
@@ -61,4 +63,4 @@
   "engines": {
     "node": ">=12.0.0"
   }
-}
+}

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

@@ -0,0 +1,89 @@
+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'
+
+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) => {
+  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
+  }
+}
+let idx = 0
+
+const handler = async (req, 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')) {
+    // We need to cache-bust the import because otherwise it will claim it
+    // doesn't exist if the user creates it after the server starts
+    const nextMiddleware = await import(`../../middleware.js#${idx++}`)
+    middleware = nextMiddleware.middleware
+  } else {
+    //  No middleware, so we silently return
+    return
+  }
+
+  //  This is the format expected by Next.js
+  const 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 = {
+    headers: Object.fromEntries(req.headers.entries()),
+    geo,
+    method: req.method,
+    ip: context.ip,
+    body: req.body || undefined,
+  }
+
+  const 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)
   }