@netlify/plugin-nextjs 4.36.1 → 4.37.1

package/lib/helpers/config.js

@@ -9,6 +9,7 @@ const fs_extra_1 = require("fs-extra");
 const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
 const constants_1 = require("../constants");
+const flags_1 = require("./flags");
 const utils_1 = require("./utils");
 const ROUTES_MANIFEST_FILE = 'routes-manifest.json';
 const defaultFailBuild = (message, { error }) => {
@@ -64,8 +65,8 @@ const hasManuallyAddedModule = ({ netlifyConfig, moduleName, }) =>
 Object.values(netlifyConfig.functions).some(({ included_files = [] }) => included_files.some((inc) => inc.includes(`node_modules/${moduleName}`)));
 exports.hasManuallyAddedModule = hasManuallyAddedModule;
 /* eslint-enable camelcase */
-const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [], }) => {
-    var _a;
+const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [], apiLambdas, featureFlags, }) => {
+    var _a, _b, _c;
     const config = await (0, exports.getRequiredServerFiles)(publish);
     const files = config.files || [];
     const cssFilesToInclude = files.filter((f) => f.startsWith(`${publish}/static/css/`));
@@ -75,7 +76,7 @@ const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [],
     }
     // If the user has manually added the module to included_files, then don't exclude it
     const excludedModules = DEFAULT_EXCLUDED_MODULES.filter((moduleName) => !(0, exports.hasManuallyAddedModule)({ netlifyConfig, moduleName }));
-    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME, '_api_*'].forEach((functionName) => {
+    const configureFunction = (functionName) => {
         var _a, _b;
         (_a = netlifyConfig.functions)[functionName] || (_a[functionName] = { included_files: [], external_node_modules: [] });
         netlifyConfig.functions[functionName].node_bundler = 'nft';
@@ -91,7 +92,21 @@ const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [],
                 netlifyConfig.functions[functionName].included_files.push(`!${moduleRoot}/**/*`);
             }
         });
-    });
+    };
+    configureFunction(constants_1.HANDLER_FUNCTION_NAME);
+    configureFunction(constants_1.ODB_FUNCTION_NAME);
+    if ((0, flags_1.splitApiRoutes)(featureFlags)) {
+        for (const apiLambda of apiLambdas) {
+            const { functionName, includedFiles } = apiLambda;
+            (_b = netlifyConfig.functions)[functionName] || (_b[functionName] = { included_files: [] });
+            netlifyConfig.functions[functionName].node_bundler = 'none';
+            (_c = netlifyConfig.functions[functionName]).included_files || (_c.included_files = []);
+            netlifyConfig.functions[functionName].included_files.push(...includedFiles);
+        }
+    }
+    else {
+        configureFunction('_api_*');
+    }
 };
 exports.configureHandlerFunctions = configureHandlerFunctions;
 const buildHeader = (buildHeaderParams) => {

package/lib/helpers/files.js

@@ -291,6 +291,10 @@ const getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIO
             if ((0, fs_extra_1.existsSync)(file)) {
                 return file;
             }
+            const fileAtFolderIndex = (0, pathe_1.join)(root, page, `index.${extension}`);
+            if ((0, fs_extra_1.existsSync)(fileAtFolderIndex)) {
+                return fileAtFolderIndex;
+            }
         }
     }
     console.log('Could not find source file for page', page);
@@ -304,7 +308,7 @@ const getDependenciesOfFile = async (file) => {
     if (!(0, fs_extra_1.existsSync)(nft)) {
         return [];
     }
-    const dependencies = await (0, fs_extra_1.readJson)(nft, 'utf8');
+    const dependencies = (await (0, fs_extra_1.readJson)(nft, 'utf8'));
     return dependencies.files.map((dep) => (0, pathe_1.resolve)((0, pathe_1.dirname)(file), dep));
 };
 exports.getDependenciesOfFile = getDependenciesOfFile;

package/lib/helpers/flags.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitApiRoutes = void 0;
+const destr_1 = __importDefault(require("destr"));
+/**
+ * If this flag is enabled, we generate individual Lambda functions for API Routes.
+ * They're packed together in 50mb chunks to avoid hitting the Lambda size limit.
+ *
+ * To prevent bundling times from rising,
+ * we use the "none" bundling strategy where we fully rely on Next.js' `.nft.json` files.
+ * This should to a significant speedup, but is still experimental.
+ *
+ * If disabled, we bundle all API Routes into a single function.
+ * This is can lead to large bundle sizes.
+ *
+ * Disabled by default. Can be overriden using the NEXT_SPLIT_API_ROUTES env var.
+ */
+const splitApiRoutes = (featureFlags) => { var _a, _b; return (_b = (_a = (0, destr_1.default)(process.env.NEXT_SPLIT_API_ROUTES)) !== null && _a !== void 0 ? _a : featureFlags.next_split_api_routes) !== null && _b !== void 0 ? _b : false; };
+exports.splitApiRoutes = splitApiRoutes;

package/lib/helpers/functions.js

@@ -3,22 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnOnApiRoutes = exports.getExtendedApiRouteConfigs = exports.getApiRouteConfigs = exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
+exports.warnOnApiRoutes = exports.packSingleFunction = exports.getExtendedApiRouteConfigs = exports.getApiRouteConfigs = exports.getAPILambdas = exports.getAPIPRouteCommonDependencies = exports.traceNPMPackage = exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
 const node_bridge_1 = __importDefault(require("@vercel/node-bridge"));
 const chalk_1 = __importDefault(require("chalk"));
 const destr_1 = __importDefault(require("destr"));
 const fs_extra_1 = require("fs-extra");
 const outdent_1 = require("outdent");
 const pathe_1 = require("pathe");
+const tiny_glob_1 = __importDefault(require("tiny-glob"));
 const constants_1 = require("../constants");
 const getApiHandler_1 = require("../templates/getApiHandler");
 const getHandler_1 = require("../templates/getHandler");
 const getPageResolver_1 = require("../templates/getPageResolver");
 const analysis_1 = require("./analysis");
+const config_1 = require("./config");
 const files_1 = require("./files");
 const functionsMetaData_1 = require("./functionsMetaData");
+const pack_1 = require("./pack");
 const utils_1 = require("./utils");
-const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir, apiRoutes) => {
+const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir, apiLambdas) => {
     const publish = (0, pathe_1.resolve)(PUBLISH_DIR);
     const functionsDir = (0, pathe_1.resolve)(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC);
     const functionDir = (0, pathe_1.join)(functionsDir, constants_1.HANDLER_FUNCTION_NAME);
@@ -27,19 +30,16 @@ const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS
     const nextServerModuleRelativeLocation = nextServerModuleAbsoluteLocation
         ? (0, pathe_1.relative)(functionDir, nextServerModuleAbsoluteLocation)
         : undefined;
-    for (const { route, config, compiled } of apiRoutes) {
-        // Don't write a lambda if the runtime is edge
-        if ((0, analysis_1.isEdgeConfig)(config.runtime)) {
-            continue;
-        }
-        const apiHandlerSource = await (0, getApiHandler_1.getApiHandler)({
-            page: route,
-            config,
+    for (const apiLambda of apiLambdas) {
+        const { functionName, routes, type, includedFiles } = apiLambda;
+        const apiHandlerSource = (0, getApiHandler_1.getApiHandler)({
+            // most api lambdas serve multiple routes, but scheduled functions need to be in separate lambdas.
+            // so routes[0] is safe to access.
+            schedule: type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? routes[0].config.schedule : undefined,
             publishDir,
             appDir: (0, pathe_1.relative)(functionDir, appDir),
             nextServerModuleRelativeLocation,
         });
-        const functionName = (0, utils_1.getFunctionNameForPage)(route, config.type === "experimental-background" /* ApiRouteType.BACKGROUND */);
         await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
         // write main API handler file
         await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), apiHandlerSource);
@@ -48,15 +48,23 @@ const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS
         await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'server.js'), (0, pathe_1.join)(functionsDir, functionName, 'server.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 resolveSourceFile = (file) => (0, pathe_1.join)(publish, 'server', file);
+        // TODO: this should be unneeded once we use the `none` bundler everywhere
         const resolverSource = await (0, getPageResolver_1.getResolverForSourceFiles)({
             functionsDir,
             // These extra pages are always included by Next.js
-            sourceFiles: [compiled, 'pages/_app.js', 'pages/_document.js', 'pages/_error.js'].map(resolveSourceFile),
+            sourceFiles: [
+                ...routes.map((route) => route.compiled),
+                'pages/_app.js',
+                'pages/_document.js',
+                'pages/_error.js',
+            ].map(resolveSourceFile),
         });
         await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, 'pages.js'), resolverSource);
+        const nfInternalFiles = await (0, tiny_glob_1.default)((0, pathe_1.join)(functionsDir, functionName, '**'));
+        includedFiles.push(...nfInternalFiles);
     }
     const writeHandler = async (functionName, functionTitle, isODB) => {
-        const handlerSource = await (0, getHandler_1.getHandler)({
+        const handlerSource = (0, getHandler_1.getHandler)({
             isODB,
             publishDir,
             appDir: (0, pathe_1.relative)(functionDir, appDir),
@@ -143,6 +151,99 @@ const setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIO
     }
 };
 exports.setupImageFunction = setupImageFunction;
+const traceRequiredServerFiles = async (publish) => {
+    const { files, relativeAppDir, config: { experimental: { outputFileTracingRoot }, }, } = await (0, config_1.getRequiredServerFiles)(publish);
+    const appDirRoot = (0, pathe_1.join)(outputFileTracingRoot, relativeAppDir);
+    const absoluteFiles = files.map((file) => (0, pathe_1.join)(appDirRoot, file));
+    absoluteFiles.push((0, pathe_1.join)(publish, 'required-server-files.json'));
+    return absoluteFiles;
+};
+const traceNextServer = async (publish) => {
+    const nextServerDeps = await (0, files_1.getDependenciesOfFile)((0, pathe_1.join)(publish, 'next-server.js'));
+    // during testing, i've seen `next-server` contain only one line.
+    // this is a sanity check to make sure we're getting all the deps.
+    if (nextServerDeps.length < 10) {
+        console.error(nextServerDeps);
+        throw new Error("next-server.js.nft.json didn't contain all dependencies.");
+    }
+    const filtered = nextServerDeps.filter((f) => {
+        // NFT detects a bunch of large development files that we don't need.
+        if (f.endsWith('.development.js'))
+            return false;
+        // not needed for API Routes!
+        if (f.endsWith('node_modules/sass/sass.dart.js'))
+            return false;
+        return true;
+    });
+    return filtered;
+};
+const traceNPMPackage = async (packageName, publish) => {
+    try {
+        return await (0, tiny_glob_1.default)((0, pathe_1.join)((0, pathe_1.dirname)(require.resolve(packageName, { paths: [publish] })), '**', '*'), {
+            absolute: true,
+        });
+    }
+    catch (error) {
+        if (process.env.NODE_ENV === 'test') {
+            return [];
+        }
+        throw error;
+    }
+};
+exports.traceNPMPackage = traceNPMPackage;
+const getAPIPRouteCommonDependencies = async (publish) => {
+    const deps = await Promise.all([
+        traceRequiredServerFiles(publish),
+        traceNextServer(publish),
+        // used by our own bridge.js
+        (0, exports.traceNPMPackage)('follow-redirects', publish),
+    ]);
+    return deps.flat(1);
+};
+exports.getAPIPRouteCommonDependencies = getAPIPRouteCommonDependencies;
+const sum = (arr) => arr.reduce((v, current) => v + current, 0);
+// TODO: cache results
+const getBundleWeight = async (patterns) => {
+    const sizes = await Promise.all(patterns.flatMap(async (pattern) => {
+        const files = await (0, tiny_glob_1.default)(pattern);
+        return Promise.all(files.map(async (file) => {
+            const fStat = await (0, fs_extra_1.stat)(file);
+            if (fStat.isFile()) {
+                return fStat.size;
+            }
+            return 0;
+        }));
+    }));
+    return sum(sizes.flat(1));
+};
+const MB = 1024 * 1024;
+const getAPILambdas = async (publish, baseDir, pageExtensions) => {
+    const commonDependencies = await (0, exports.getAPIPRouteCommonDependencies)(publish);
+    const threshold = 50 * MB - (await getBundleWeight(commonDependencies));
+    const apiRoutes = await (0, exports.getApiRouteConfigs)(publish, baseDir, pageExtensions);
+    const packFunctions = async (routes, type) => {
+        const weighedRoutes = await Promise.all(routes.map(async (route) => ({ value: route, weight: await getBundleWeight(route.includedFiles) })));
+        const bins = (0, pack_1.pack)(weighedRoutes, threshold);
+        return bins.map((bin, index) => ({
+            functionName: bin.length === 1 ? bin[0].functionName : `api-${index}`,
+            routes: bin,
+            includedFiles: [...commonDependencies, ...routes.flatMap((route) => route.includedFiles)],
+            type,
+        }));
+    };
+    const standardFunctions = apiRoutes.filter((route) => !(0, analysis_1.isEdgeConfig)(route.config.runtime) &&
+        route.config.type !== "experimental-background" /* ApiRouteType.BACKGROUND */ &&
+        route.config.type !== "experimental-scheduled" /* ApiRouteType.SCHEDULED */);
+    const scheduledFunctions = apiRoutes.filter((route) => route.config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */);
+    const backgroundFunctions = apiRoutes.filter((route) => route.config.type === "experimental-background" /* ApiRouteType.BACKGROUND */);
+    const scheduledLambdas = scheduledFunctions.map(exports.packSingleFunction);
+    const [standardLambdas, backgroundLambdas] = await Promise.all([
+        packFunctions(standardFunctions),
+        packFunctions(backgroundFunctions, "experimental-background" /* ApiRouteType.BACKGROUND */),
+    ]);
+    return [...standardLambdas, ...backgroundLambdas, ...scheduledLambdas];
+};
+exports.getAPILambdas = getAPILambdas;
 /**
  * Look for API routes, and extract the config from the source file.
  */
@@ -155,7 +256,19 @@ const getApiRouteConfigs = async (publish, appDir, pageExtensions) => {
     const srcPagesDir = (0, pathe_1.join)(appDir, 'src', 'pages');
     return await Promise.all(apiRoutes.map(async (apiRoute) => {
         const filePath = (0, files_1.getSourceFileForPage)(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
-        return { route: apiRoute, config: await (0, analysis_1.extractConfigFromFile)(filePath, appDir), compiled: pages[apiRoute] };
+        const config = await (0, analysis_1.extractConfigFromFile)(filePath, appDir);
+        const functionName = (0, utils_1.getFunctionNameForPage)(apiRoute, config.type === "experimental-background" /* ApiRouteType.BACKGROUND */);
+        const compiled = pages[apiRoute];
+        const compiledPath = (0, pathe_1.join)(publish, 'server', compiled);
+        const routeDependencies = await (0, files_1.getDependenciesOfFile)(compiledPath);
+        const includedFiles = [compiledPath, ...routeDependencies];
+        return {
+            functionName,
+            route: apiRoute,
+            config,
+            compiled,
+            includedFiles,
+        };
     }));
 };
 exports.getApiRouteConfigs = getApiRouteConfigs;
@@ -168,6 +281,13 @@ const getExtendedApiRouteConfigs = async (publish, appDir, pageExtensions) => {
     return settledApiRoutes.filter((apiRoute) => apiRoute.config.type !== undefined);
 };
 exports.getExtendedApiRouteConfigs = getExtendedApiRouteConfigs;
+const packSingleFunction = (func) => ({
+    functionName: func.functionName,
+    includedFiles: func.includedFiles,
+    routes: [func],
+    type: func.config.type,
+});
+exports.packSingleFunction = packSingleFunction;
 /**
  * Warn the user of the caveats if they're using background or scheduled API routes
  */

package/lib/helpers/pack.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pack = void 0;
+/**
+ * Naïve linear packing algorithm.
+ * Takes items with weights, and packs them into boxes of a given threshold.
+ * If an item weight exceeds the threshold, it is put into a box of its own.
+ *
+ * We're using this to combine many API Routes into fewer Lambda functions.
+ *
+ * This does not compute an optimal solution.
+ * For that, we'd take the full dependency graph into account
+ * and try to pack routes with intersecting dependencies together.
+ * But since most of the lambda bundle consists of node_modules,
+ * that probably won't help much.
+ * In the future, we might think about using some graph-based analysis here!
+ * Too complicated for now.
+ */
+const pack = (items, threshold) => {
+    const result = [];
+    let currentBox = [];
+    let currentWeight = 0;
+    const sortedDescending = items.sort((a, b) => b.weight - a.weight);
+    for (const item of sortedDescending) {
+        const fitsInCurrentBox = currentWeight + item.weight <= threshold;
+        if (fitsInCurrentBox) {
+            currentBox.push(item.value);
+            currentWeight += item.weight;
+        }
+        else {
+            if (currentBox.length !== 0)
+                result.push(currentBox);
+            currentBox = [item.value];
+            currentWeight = item.weight;
+        }
+    }
+    if (currentBox.length !== 0)
+        result.push(currentBox);
+    return result;
+};
+exports.pack = pack;

package/lib/helpers/redirects.js

@@ -184,7 +184,7 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
     };
 };
 exports.generateDynamicRewrites = generateDynamicRewrites;
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, apiRoutes, }) => {
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, apiLambdas, }) => {
     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(...generateHiddenPathRedirects({ basePath }));
@@ -194,7 +194,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, apiRoutes), 
+    ...(0, utils_1.getApiRewrites)(basePath, apiLambdas), 
     // 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

@@ -105,8 +105,8 @@ const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status
     force,
 }));
 exports.redirectsForNextRouteWithData = redirectsForNextRouteWithData;
-const getApiRewrites = (basePath, apiRoutes) => {
-    const apiRewrites = apiRoutes.map((apiRoute) => {
+const getApiRewrites = (basePath, apiLambdas) => {
+    const apiRewrites = apiLambdas.flatMap((lambda) => lambda.routes.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" /* ApiRouteType.SCHEDULED */) {
@@ -114,10 +114,10 @@ const getApiRewrites = (basePath, apiRoutes) => {
         }
         return {
             from,
-            to: `/.netlify/functions/${(0, exports.getFunctionNameForPage)(apiRoute.route, apiRoute.config.type === "experimental-background" /* ApiRouteType.BACKGROUND */)}`,
+            to: `/.netlify/functions/${lambda.functionName}`,
             status: 200,
         };
-    });
+    }));
     return [
         ...apiRewrites,
         {

package/lib/index.js

@@ -14,6 +14,7 @@ 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 flags_1 = require("./helpers/flags");
 const functions_1 = require("./helpers/functions");
 const redirects_1 = require("./helpers/redirects");
 const utils_1 = require("./helpers/utils");
@@ -38,7 +39,7 @@ const plugin = {
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     // eslint-disable-next-line max-lines-per-function
-    async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
+    async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, featureFlags = {}, }) {
         if ((0, utils_1.shouldSkip)()) {
             return;
         }
@@ -91,10 +92,18 @@ 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) });
-        const apiRoutes = await (0, functions_1.getExtendedApiRouteConfigs)(publish, appDir, pageExtensions);
-        await (0, functions_1.generateFunctions)(constants, appDir, apiRoutes);
+        const apiLambdas = (0, flags_1.splitApiRoutes)(featureFlags)
+            ? await (0, functions_1.getAPILambdas)(publish, appDir, pageExtensions)
+            : await (0, functions_1.getExtendedApiRouteConfigs)(publish, appDir, pageExtensions).then((extendedRoutes) => extendedRoutes.map(functions_1.packSingleFunction));
+        await (0, functions_1.generateFunctions)(constants, appDir, apiLambdas);
         await (0, functions_1.generatePagesResolver)(constants);
+        await (0, config_1.configureHandlerFunctions)({
+            netlifyConfig,
+            ignore,
+            publish: (0, path_1.relative)(process.cwd(), publish),
+            apiLambdas,
+            featureFlags,
+        });
         await (0, files_1.movePublicFiles)({ appDir, outdir, publish, basePath });
         await (0, files_1.patchNextFiles)(appDir);
         if (!(0, destr_1.default)(process.env.SERVE_STATIC_FILES_FROM_ORIGIN)) {
@@ -116,7 +125,7 @@ const plugin = {
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
             buildId,
-            apiRoutes,
+            apiLambdas,
         });
         await (0, edge_1.writeEdgeFunctions)({ netlifyConfig, routesManifest });
     },

package/lib/templates/getApiHandler.js

@@ -10,8 +10,9 @@ const path = require('path');
 const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node-bridge/bridge');
 const { getMultiValueHeaders } = require('./handlerUtils');
+const { getNetlifyNextServer } = require('./server');
 // We return a function and then call `toString()` on it to serialise it as the launcher function
-const makeApiHandler = ({ conf, app, pageRoot, page, NextServer }) => {
+const makeApiHandler = ({ conf, app, pageRoot, NextServer }) => {
     var _a;
     // Change working directory into the site root, unless using Nx, which moves the
     // dist directory and handles this itself
@@ -25,8 +26,7 @@ const makeApiHandler = ({ conf, app, pageRoot, page, NextServer }) => {
         require.resolve('./pages.js');
     }
     catch { }
-    // React assumes you want development mode if NODE_ENV is unset.
-    ;
+    const NetlifyNextServer = getNetlifyNextServer(NextServer);
     (_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;
@@ -39,19 +39,23 @@ const makeApiHandler = ({ conf, app, pageRoot, page, NextServer }) => {
     // 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) => {
+    const getBridge = (event, context) => {
+        var _a;
         if (bridge) {
             return bridge;
         }
+        const customContext = (_a = context.clientContext) === null || _a === void 0 ? void 0 : _a.custom;
         // 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 = new NextServer({
+        const nextServer = new NetlifyNextServer({
             conf,
             dir,
             customServer: false,
             hostname: url.hostname,
             port,
+        }, {
+            revalidateToken: customContext === null || customContext === void 0 ? void 0 : customContext.odb_refresh_hooks,
         });
         const requestHandler = nextServer.getRequestHandler();
         const server = new Server(async (req, res) => {
@@ -69,13 +73,11 @@ const makeApiHandler = ({ conf, app, pageRoot, page, NextServer }) => {
     };
     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;
+        event.path = new URL(event.rawUrl).pathname;
         // 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);
+        const { headers, ...result } = await getBridge(event, context).launcher(event, context);
         // Convert all headers to multiValueHeaders
         const multiValueHeaders = getMultiValueHeaders(headers);
         multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
@@ -90,9 +92,10 @@ const makeApiHandler = ({ conf, app, pageRoot, page, NextServer }) => {
 /**
  * Handlers for API routes are simpler than page routes, but they each have a separate one
  */
-const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '../../..', nextServerModuleRelativeLocation, }) => 
-// This is a string, but if you have the right editor plugin it should format as js
+const getApiHandler = ({ schedule, publishDir = '../../../.next', appDir = '../../..', nextServerModuleRelativeLocation, }) => 
+// This is a string, but if you have the right editor plugin it should format as js (e.g. bierner.comment-tagged-templates in VS Code)
 (0, outdent_1.outdent /* javascript */) `
+  process.env.NODE_ENV = 'production';
   if (!${JSON.stringify(nextServerModuleRelativeLocation)}) {
     throw new Error('Could not find Next.js server')
   }
@@ -101,16 +104,17 @@ const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
   const { getMultiValueHeaders } = require('./handlerUtils')
+  const { getNetlifyNextServer } = require('./server')
   const NextServer = require(${JSON.stringify(nextServerModuleRelativeLocation)}).default
 
-  ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `const { schedule } = require("@netlify/functions")` : ''}
+  ${schedule ? `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}", "server"));
-  const handler = (${makeApiHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, page:${JSON.stringify(page)}, NextServer})
-  exports.handler = ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `schedule(${JSON.stringify(config.schedule)}, handler);` : 'handler'}
+  const handler = (${makeApiHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer })
+  exports.handler = ${schedule ? `schedule(${JSON.stringify(schedule)}, handler);` : 'handler'}
 `;
 exports.getApiHandler = getApiHandler;

package/lib/templates/getHandler.js

@@ -132,7 +132,7 @@ const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mod
     };
 };
 const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..', nextServerModuleRelativeLocation, }) => 
-// This is a string, but if you have the right editor plugin it should format as js
+// This is a string, but if you have the right editor plugin it should format as js (e.g. bierner.comment-tagged-templates in VS Code)
 (0, outdent_1.outdent /* javascript */) `
   if (!${JSON.stringify(nextServerModuleRelativeLocation)}) {
     throw new Error('Could not find Next.js server')

package/lib/templates/server.js

@@ -20,11 +20,16 @@ const getNetlifyNextServer = (NextServer) => {
             return async (req, res, parsedUrl) => {
                 // preserve the URL before Next.js mutates it for i18n
                 const { url, headers } = req;
-                // handle the original res.revalidate() request
-                await handler(req, res, parsedUrl);
-                // handle on-demand revalidation by purging the ODB cache
-                if (res.statusCode === 200 && headers['x-prerender-revalidate'] && this.netlifyConfig.revalidateToken) {
+                if (headers['x-prerender-revalidate'] && this.netlifyConfig.revalidateToken) {
+                    // handle on-demand revalidation by purging the ODB cache
                     await this.netlifyRevalidate(url);
+                    res = res;
+                    res.statusCode = 200;
+                    res.setHeader('x-nextjs-cache', 'REVALIDATED');
+                    res.send();
+                }
+                else {
+                    return handler(req, res, parsedUrl);
                 }
             };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.36.1",
+  "version": "4.37.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [
@@ -12,7 +12,7 @@
   ],
   "dependencies": {
     "@netlify/esbuild": "0.14.39",
-    "@netlify/functions": "^1.4.0",
+    "@netlify/functions": "^1.6.0",
     "@netlify/ipx": "^1.4.0",
     "@vercel/node-bridge": "^2.1.0",
     "chalk": "^4.1.2",
@@ -37,7 +37,7 @@
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^29.11.1",
+    "@netlify/build": "^29.11.5",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",

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

@@ -1,7 +1,7 @@
 import { NextRequest } from 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/request.js'
 import { NextResponse } from 'https://esm.sh/v91/next@12.2.5/deno/dist/server/web/spec-extension/response.js'
 import { fromFileUrl } from 'https://deno.land/std@0.151.0/path/mod.ts'
-import { buildResponse } from '../edge-shared/utils.ts'
+import { buildResponse, isFunction } from '../edge-shared/utils.ts'
 
 globalThis.NFRequestContextMap ||= new Map()
 globalThis.__dirname = fromFileUrl(new URL('./', import.meta.url)).slice(0, -1)
@@ -36,7 +36,17 @@ const handler = async (req, context) => {
     // 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
+
+    // The middleware file can export a named `middleware` export or a `default` export
+    middleware = isFunction(nextMiddleware.middleware)
+      ? nextMiddleware.middleware
+      : isFunction(nextMiddleware.default)
+      ? nextMiddleware.default
+      : undefined
+
+    if (!middleware) {
+      throw new Error('The middleware must export a `middleware` or a `default` function')
+    }
   } catch (importError) {
     if (importError.code === 'ERR_MODULE_NOT_FOUND' && importError.message.includes(`middleware.js`)) {
       //  No middleware, so we silently return

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

@@ -305,3 +305,5 @@ export const redirectTrailingSlash = (url: URL, trailingSlash: boolean): Respons
     return Response.redirect(url, 308)
   }
 }
+
+export const isFunction = (f: unknown) => Boolean(f) && typeof f === 'function'