@netlify/plugin-nextjs 4.36.0 → 4.37.0

package/README.md

@@ -1,4 +1,4 @@
-![Next.js Runtime](https://github.com/netlify/next-runtime/raw/main/next-on-netlify.png)
+![Next.js Runtime](https://github.com/netlify/next-runtime/raw/main/next-js-runtime.png)
 
 # `@netlify/plugin-nextjs`
 

package/lib/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIVIDER = exports.LAMBDA_MAX_SIZE = exports.MINIMUM_REVALIDATE_SECONDS = exports.DYNAMIC_PARAMETER_REGEX = exports.OPTIONAL_CATCH_ALL_REGEX = exports.CATCH_ALL_REGEX = exports.DEFAULT_FUNCTIONS_SRC = exports.HANDLER_FUNCTION_PATH = exports.ODB_FUNCTION_PATH = exports.HIDDEN_PATHS = exports.IMAGE_FUNCTION_TITLE = exports.ODB_FUNCTION_TITLE = exports.HANDLER_FUNCTION_TITLE = exports.NEXT_PLUGIN = exports.NEXT_PLUGIN_NAME = exports.IMAGE_FUNCTION_NAME = exports.ODB_FUNCTION_NAME = exports.HANDLER_FUNCTION_NAME = void 0;
+exports.DIVIDER = exports.LAMBDA_MAX_SIZE = exports.LAMBDA_WARNING_SIZE = exports.MINIMUM_REVALIDATE_SECONDS = exports.DYNAMIC_PARAMETER_REGEX = exports.OPTIONAL_CATCH_ALL_REGEX = exports.CATCH_ALL_REGEX = exports.DEFAULT_FUNCTIONS_SRC = exports.HANDLER_FUNCTION_PATH = exports.ODB_FUNCTION_PATH = exports.HIDDEN_PATHS = exports.IMAGE_FUNCTION_TITLE = exports.ODB_FUNCTION_TITLE = exports.HANDLER_FUNCTION_TITLE = exports.NEXT_PLUGIN = exports.NEXT_PLUGIN_NAME = exports.IMAGE_FUNCTION_NAME = exports.ODB_FUNCTION_NAME = exports.HANDLER_FUNCTION_NAME = void 0;
 exports.HANDLER_FUNCTION_NAME = '___netlify-handler';
 exports.ODB_FUNCTION_NAME = '___netlify-odb-handler';
 exports.IMAGE_FUNCTION_NAME = '_ipx';
@@ -29,8 +29,10 @@ exports.CATCH_ALL_REGEX = /\/\[\.{3}(.*)](.json)?$/;
 exports.OPTIONAL_CATCH_ALL_REGEX = /\/\[{2}\.{3}(.*)]{2}(.json)?$/;
 exports.DYNAMIC_PARAMETER_REGEX = /\/\[(.*?)]/g;
 exports.MINIMUM_REVALIDATE_SECONDS = 60;
-// 50MB, which is the documented max, though the hard max seems to be higher
-exports.LAMBDA_MAX_SIZE = 1024 * 1024 * 50;
+// 50MB, which is the warning max
+exports.LAMBDA_WARNING_SIZE = 1024 * 1024 * 50;
+// 250MB, which is the hard max
+exports.LAMBDA_MAX_SIZE = 1024 * 1024 * 250;
 exports.DIVIDER = `
 ────────────────────────────────────────────────────────────────
 `;

package/lib/helpers/analysis.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractConfigFromFile = exports.validateConfigValue = exports.isEdgeConfig = void 0;
 const fs_1 = __importStar(require("fs"));
 const pathe_1 = require("pathe");
+const utils_1 = require("./utils");
 const isEdgeConfig = (config) => ['experimental-edge', 'edge'].includes(config);
 exports.isEdgeConfig = isEdgeConfig;
 const validateConfigValue = (config, apiFilePath) => {
@@ -61,29 +62,33 @@ let hasWarnedAboutNextVersion = false;
 /**
  * Uses Next's swc static analysis to extract the config values from a file.
  */
-const extractConfigFromFile = async (apiFilePath) => {
+const extractConfigFromFile = async (apiFilePath, appDir) => {
     if (!apiFilePath || !(0, fs_1.existsSync)(apiFilePath)) {
         return {};
     }
-    try {
-        if (!extractConstValue) {
-            extractConstValue = require('next/dist/build/analysis/extract-const-value');
-        }
-        if (!parseModule) {
-            // eslint-disable-next-line prefer-destructuring, @typescript-eslint/no-var-requires
-            parseModule = require('next/dist/build/analysis/parse-module').parseModule;
+    const extractConstValueModulePath = (0, utils_1.findModuleFromBase)({
+        paths: [appDir],
+        candidates: ['next/dist/build/analysis/extract-const-value'],
+    });
+    const parseModulePath = (0, utils_1.findModuleFromBase)({
+        paths: [appDir],
+        candidates: ['next/dist/build/analysis/parse-module'],
+    });
+    if (!extractConstValueModulePath || !parseModulePath) {
+        if (!hasWarnedAboutNextVersion) {
+            console.log("This version of Next.js doesn't support advanced API routes. Skipping...");
+            hasWarnedAboutNextVersion = true;
         }
+        // Old Next.js version
+        return {};
     }
-    catch (error) {
-        if (error.code === 'MODULE_NOT_FOUND') {
-            if (!hasWarnedAboutNextVersion) {
-                console.log("This version of Next.js doesn't support advanced API routes. Skipping...");
-                hasWarnedAboutNextVersion = true;
-            }
-            // Old Next.js version
-            return {};
-        }
-        throw error;
+    if (!extractConstValue && extractConstValueModulePath) {
+        // eslint-disable-next-line import/no-dynamic-require
+        extractConstValue = require(extractConstValueModulePath);
+    }
+    if (!parseModule && parseModulePath) {
+        // eslint-disable-next-line prefer-destructuring, @typescript-eslint/no-var-requires, import/no-dynamic-require
+        parseModule = require(parseModulePath).parseModule;
     }
     const { extractExportedConstValue, UnsupportedValueError } = extractConstValue;
     const fileContent = await fs_1.default.promises.readFile(apiFilePath, 'utf8');

package/lib/helpers/compiler.js

@@ -27,6 +27,7 @@ const buildMiddlewareFile = async (entryPoints, base) => {
             format: 'esm',
             target: 'esnext',
             absWorkingDir: base,
+            external: ['next/dist/compiled/@vercel/og'],
         });
     }
     catch (error) {

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

@@ -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.getDependenciesOfFile = exports.getSourceFileForPage = 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.getServerFile = exports.moveStaticPages = exports.getMiddleware = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
 const os_1 = require("os");
 const chalk_1 = require("chalk");
 const fs_extra_1 = require("fs-extra");
@@ -16,7 +16,6 @@ const constants_1 = require("../constants");
 const edge_1 = require("./edge");
 const utils_1 = require("./utils");
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
-const SOURCE_FILE_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx'];
 const isDynamicRoute = (route) => TEST_ROUTE.test(route);
 exports.isDynamicRoute = isDynamicRoute;
 const stripLocale = (rawPath, locales = []) => {
@@ -107,7 +106,6 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
         filesManifest[file] = targetPath;
         const dest = (0, pathe_1.join)(netlifyConfig.build.publish, targetPath);
         try {
-            console.log(`Moving ${source} to ${dest}`);
             await (0, fs_extra_1.move)(source, dest);
         }
         catch (error) {
@@ -279,16 +277,24 @@ const getServerFile = (root, includeBase = true) => {
     }
     return (0, utils_1.findModuleFromBase)({ candidates, paths: [root] });
 };
+exports.getServerFile = getServerFile;
+// Next.js already defines a default `pageExtensions` array in its `required-server-files.json` file
+// In case it gets `undefined`, this is a fallback
+const SOURCE_FILE_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx'];
 /**
  * Find the source file for a given page route
  */
-const getSourceFileForPage = (page, roots) => {
+const getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIONS) => {
     for (const root of roots) {
-        for (const extension of SOURCE_FILE_EXTENSIONS) {
+        for (const extension of pageExtensions) {
             const file = (0, pathe_1.join)(root, `${page}.${extension}`);
             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);
@@ -302,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;
@@ -312,6 +318,11 @@ const baseServerReplacements = [
         `checkIsManualRevalidate(req, this.renderOpts.previewProps)`,
         `checkIsManualRevalidate(process.env._REVALIDATE_SSG ? { headers: { 'x-prerender-revalidate': this.renderOpts.previewProps.previewModeId } } : req, this.renderOpts.previewProps)`,
     ],
+    // In https://github.com/vercel/next.js/pull/47803 checkIsManualRevalidate was renamed to checkIsOnDemandRevalidate
+    [
+        `checkIsOnDemandRevalidate(req, this.renderOpts.previewProps)`,
+        `checkIsOnDemandRevalidate(process.env._REVALIDATE_SSG ? { headers: { 'x-prerender-revalidate': this.renderOpts.previewProps.previewModeId } } : req, this.renderOpts.previewProps)`,
+    ],
     // ensure ISR 404 pages send the correct SWR cache headers
     [`private: isPreviewMode || is404Page && cachedData`, `private: isPreviewMode && cachedData`],
 ];
@@ -334,7 +345,7 @@ const nextServerReplacements = [
     ],
 ];
 const patchNextFiles = async (root) => {
-    const baseServerFile = getServerFile(root);
+    const baseServerFile = (0, exports.getServerFile)(root);
     console.log(`Patching ${baseServerFile}`);
     if (baseServerFile) {
         await patchFile({
@@ -342,7 +353,7 @@ const patchNextFiles = async (root) => {
             replacements: baseServerReplacements,
         });
     }
-    const nextServerFile = getServerFile(root, false);
+    const nextServerFile = (0, exports.getServerFile)(root, false);
     console.log(`Patching ${nextServerFile}`);
     if (nextServerFile) {
         await patchFile({
@@ -360,9 +371,9 @@ const unpatchFile = async (file) => {
 };
 exports.unpatchFile = unpatchFile;
 const unpatchNextFiles = async (root) => {
-    const baseServerFile = getServerFile(root);
+    const baseServerFile = (0, exports.getServerFile)(root);
     await (0, exports.unpatchFile)(baseServerFile);
-    const nextServerFile = getServerFile(root, false);
+    const nextServerFile = (0, exports.getServerFile)(root, false);
     if (nextServerFile !== baseServerFile) {
         await (0, exports.unpatchFile)(nextServerFile);
     }

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,38 +3,43 @@ 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);
     const publishDir = (0, pathe_1.relative)(functionDir, publish);
-    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,
+    const nextServerModuleAbsoluteLocation = (0, files_1.getServerFile)(appDir, false);
+    const nextServerModuleRelativeLocation = nextServerModuleAbsoluteLocation
+        ? (0, pathe_1.relative)(functionDir, nextServerModuleAbsoluteLocation)
+        : undefined;
+    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);
@@ -43,15 +48,28 @@ 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)({ isODB, publishDir, appDir: (0, pathe_1.relative)(functionDir, appDir) });
+        const handlerSource = (0, getHandler_1.getHandler)({
+            isODB,
+            publishDir,
+            appDir: (0, pathe_1.relative)(functionDir, appDir),
+            nextServerModuleRelativeLocation,
+        });
         await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
         // write main handler file (standard or ODB)
         await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), handlerSource);
@@ -133,31 +151,143 @@ 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.
  */
-const getApiRouteConfigs = async (publish, baseDir) => {
+const getApiRouteConfigs = async (publish, appDir, pageExtensions) => {
     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/'));
     // two possible places
     // Ref: https://nextjs.org/docs/advanced-features/src-directory
-    const pagesDir = (0, pathe_1.join)(baseDir, 'pages');
-    const srcPagesDir = (0, pathe_1.join)(baseDir, 'src', 'pages');
+    const pagesDir = (0, pathe_1.join)(appDir, 'pages');
+    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]);
-        return { route: apiRoute, config: await (0, analysis_1.extractConfigFromFile)(filePath), compiled: pages[apiRoute] };
+        const filePath = (0, files_1.getSourceFileForPage)(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
+        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;
 /**
  * Looks for extended API routes (background and scheduled functions) and extract the config from the source file.
  */
-const getExtendedApiRouteConfigs = async (publish, baseDir) => {
-    const settledApiRoutes = await (0, exports.getApiRouteConfigs)(publish, baseDir);
+const getExtendedApiRouteConfigs = async (publish, appDir, pageExtensions) => {
+    const settledApiRoutes = await (0, exports.getApiRouteConfigs)(publish, appDir, pageExtensions);
     // We only want to return the API routes that are background or scheduled functions
     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/matchers.js

@@ -10,7 +10,7 @@ const stripLookahead = (regex) => {
     }
     try {
         // Parse the regexp into an AST
-        const re = (0, regexp_tree_1.transform)(`/${regex}/`, {
+        const re = (0, regexp_tree_1.transform)(new RegExp(regex), {
             Assertion(path) {
                 // Remove the lookahead
                 if (path.node.kind === 'Lookahead') {
@@ -30,8 +30,12 @@ exports.stripLookahead = stripLookahead;
 // The Go regexp lib has alternative syntax for named capture groups
 const transformCaptureGroups = (regex) => regex.replace(/\(\?<\w+>/, '(');
 exports.transformCaptureGroups = transformCaptureGroups;
-const LOCALIZED_REGEX_PREFIX = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))';
-const OPTIONAL_REGEX_PREFIX = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))?';
+const LOCALIZED_REGEX_PREFIX_13_1 = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))';
+const OPTIONAL_REGEX_PREFIX_13_1 = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))?';
+const LOCALIZED_REGEX_PREFIX_13_3 = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/((?!_next\\/)[^/.]{1,}))';
+const OPTIONAL_REGEX_PREFIX_13_3 = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/((?!_next\\/)[^/.]{1,}))?';
 // Make the locale section of the matcher regex optional
-const makeLocaleOptional = (regex) => regex.replace(LOCALIZED_REGEX_PREFIX, OPTIONAL_REGEX_PREFIX);
+const makeLocaleOptional = (regex) => regex
+    .replace(LOCALIZED_REGEX_PREFIX_13_1, OPTIONAL_REGEX_PREFIX_13_1)
+    .replace(LOCALIZED_REGEX_PREFIX_13_3, OPTIONAL_REGEX_PREFIX_13_3);
 exports.makeLocaleOptional = makeLocaleOptional;

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

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRedirects = exports.generateStaticRedirects = void 0;
+exports.generateRedirects = exports.generateDynamicRewrites = exports.generateStaticRedirects = void 0;
 const chalk_1 = 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");
@@ -160,7 +164,9 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
                     withData: true,
                 }));
             }
-            else if (prerenderedDynamicRoutes[route.page].fallback === false && !is404Isr) {
+            else if (prerenderedDynamicRoutes[route.page].fallback === false &&
+                !is404Isr &&
+                !(0, destr_1.default)(process.env.LEGACY_FALLBACK_FALSE)) {
                 dynamicRewrites.push(...(0, utils_1.redirectsForNext404Route)({ route: route.page, buildId, basePath, i18n }));
             }
             else {
@@ -177,7 +183,8 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
         dynamicRewrites,
     };
 };
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, apiRoutes, }) => {
+exports.generateDynamicRewrites = generateDynamicRewrites;
+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 }));
@@ -187,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);
@@ -215,7 +222,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
         netlifyConfig.redirects.push(...(0, utils_1.redirectsForNextRoute)({ route: route.page, buildId, basePath, to: constants_1.HANDLER_FUNCTION_PATH, i18n }));
     });
     // Add rewrites for all dynamic routes (both SSR and ISR)
-    const { dynamicRewrites, dynamicRoutesThatMatchMiddleware } = generateDynamicRewrites({
+    const { dynamicRewrites, dynamicRoutesThatMatchMiddleware } = (0, exports.generateDynamicRewrites)({
         dynamicRoutes,
         prerenderedDynamicRoutes,
         middleware,

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,
         {
@@ -169,6 +169,18 @@ const findModuleFromBase = ({ paths, candidates }) => {
             // Ignore the error
         }
     }
+    // if we couldn't find a module from paths, let's try to resolve from here
+    for (const candidate of candidates) {
+        try {
+            const modulePath = require.resolve(candidate);
+            if (modulePath) {
+                return modulePath;
+            }
+        }
+        catch {
+            // Ignore the error
+        }
+    }
     return null;
 };
 exports.findModuleFromBase = findModuleFromBase;

package/lib/helpers/verification.js

@@ -102,7 +102,7 @@ const checkForRootPublish = ({ publish, failBuild, }) => {
     }
 };
 exports.checkForRootPublish = checkForRootPublish;
-const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
+const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE, warningSize = constants_1.LAMBDA_WARNING_SIZE) => {
     // Requires contacting the Netlify Support team to fully enable.
     // Enabling this without contacting them can result in failed deploys.
     if ((0, utils_1.isBundleSizeCheckDisabled)()) {
@@ -114,12 +114,13 @@ const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
         return;
     }
     const fileSize = await fs_1.promises.stat(file).then(({ size }) => size);
-    if (fileSize < maxSize) {
+    if (fileSize < warningSize) {
         return;
     }
     // We don't fail the build, because the actual hard max size is larger so it might still succeed
-    console.log((0, chalk_1.redBright)((0, outdent_1.outdent) `
-      The function zip ${(0, chalk_1.yellowBright)((0, path_1.relative)(process.cwd(), file))} size is ${(0, pretty_bytes_1.default)(fileSize)}, which is larger than the maximum supported size of ${(0, pretty_bytes_1.default)(maxSize)}.
+    console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
+      The function zip ${(0, chalk_1.blueBright)((0, path_1.relative)(process.cwd(), file))} size is ${(0, pretty_bytes_1.default)(fileSize)}, which is larger than the recommended maximum size of ${(0, pretty_bytes_1.default)(warningSize)}.
+      This will fail the build if the unzipped size is bigger than the maximum size of ${(0, pretty_bytes_1.default)(maxSize)}.
       There are a few reasons this could happen. You may have accidentally bundled a large dependency, or you might have a
       large number of pre-rendered pages included.
     `));

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");
@@ -37,13 +38,14 @@ const plugin = {
         // eslint-disable-next-line unicorn/consistent-destructuring
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
-    async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
+    // eslint-disable-next-line max-lines-per-function
+    async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, featureFlags = {}, }) {
         if ((0, utils_1.shouldSkip)()) {
             return;
         }
         const { publish } = netlifyConfig.build;
         (0, verification_1.checkNextSiteHasBuilt)({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir, experimental, routesManifest } = await (0, config_1.getNextConfig)({
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir, experimental, routesManifest, pageExtensions, } = await (0, config_1.getNextConfig)({
             publish,
             failBuild,
         });
@@ -90,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);
-        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)) {
@@ -115,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

@@ -9,9 +9,10 @@ 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');
+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 makeHandler = (conf, app, pageRoot, page) => {
+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 makeHandler = (conf, app, pageRoot, page) => {
         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,20 +39,22 @@ const makeHandler = (conf, app, pageRoot, page) => {
     // 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) => {
         if (bridge) {
             return bridge;
         }
+        const { clientContext: { custom: customContext }, } = context;
         // 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({
+        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) => {
@@ -70,13 +72,11 @@ const makeHandler = (conf, app, pageRoot, page) => {
     };
     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'];
@@ -91,22 +91,29 @@ const makeHandler = (conf, app, pageRoot, page) => {
 /**
  * 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
+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')
+  }
+
   const { Server } = require("http");
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
-  const { getMultiValueHeaders, getNextServer } = require('./handlerUtils')
+  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 = (${makeHandler.toString()})(config, "${appDir}", pageRoot, ${JSON.stringify(page)})
-  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

@@ -11,10 +11,10 @@ const path = require('path');
 const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node-bridge/bridge');
 const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, normalizePath, } = require('./handlerUtils');
-const { NetlifyNextServer } = require('./server');
+const { getNetlifyNextServer } = require('./server');
 // We return a function and then call `toString()` on it to serialise it as the launcher function
-// eslint-disable-next-line max-params, max-lines-per-function
-const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
+// eslint-disable-next-line max-lines-per-function
+const makeHandler = ({ conf, app, pageRoot, NextServer, staticManifest = [], mode = 'ssr' }) => {
     var _a;
     // Change working directory into the site root, unless using Nx, which moves the
     // dist directory and handles this itself
@@ -28,6 +28,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
         require.resolve('./pages.js');
     }
     catch { }
+    const NetlifyNextServer = getNetlifyNextServer(NextServer);
     const ONE_YEAR_IN_SECONDS = 31536000;
     (_a = process.env).NODE_ENV || (_a.NODE_ENV = 'production');
     // We don't want to write ISR files to disk in the lambda environment
@@ -59,7 +60,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
             hostname: url.hostname,
             port,
         }, {
-            revalidateToken: customContext.odb_refresh_hooks,
+            revalidateToken: customContext === null || customContext === void 0 ? void 0 : customContext.odb_refresh_hooks,
         });
         const requestHandler = nextServer.getRequestHandler();
         const server = new Server(async (req, res) => {
@@ -86,13 +87,6 @@ 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, context).launcher(event, context);
         // Convert all headers to multiValueHeaders
         const multiValueHeaders = getMultiValueHeaders(headers);
@@ -137,15 +131,20 @@ 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
+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 (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')
+  }
+
   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, getPrefetchResponse, getNextServer, normalizePath } = require('./handlerUtils')
-  const { NetlifyNextServer } = require('./server')
+  const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, normalizePath } = require('./handlerUtils')
+  const { getNetlifyNextServer } = require('./server')
+  const NextServer = require(${JSON.stringify(nextServerModuleRelativeLocation)}).default
 
   ${isODB ? `const { builder } = require("@netlify/functions")` : ''}
   const { config }  = require("${publishDir}/required-server-files.json")
@@ -156,7 +155,7 @@ const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '..
   const path = require("path");
   const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "server"));
   exports.handler = ${isODB
-    ? `builder((${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
-    : `(${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
+    ? `builder((${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, mode: 'odb' }));`
+    : `(${makeHandler.toString()})({ conf: config, app: "${appDir}", pageRoot, NextServer, staticManifest, mode: 'ssr' });`}
 `;
 exports.getHandler = getHandler;

package/lib/templates/getPageResolver.js

@@ -33,7 +33,7 @@ const getResolverForDependencies = ({ dependencies, functionDir, }) => {
     // This file is purely to allow nft to know about these pages.
     exports.resolvePages = () => {
         try {
-            ${pageFiles.join('\n        ')}
+            ${pageFiles.sort().join('\n        ')}
         } catch {}
     }
   `;

package/lib/templates/handlerUtils.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.localizeDataRoute = exports.localizeRoute = exports.unlocalizeRoute = exports.normalizeRoute = exports.netlifyApiFetch = exports.normalizePath = exports.getPrefetchResponse = exports.getNextServer = exports.augmentFsModule = exports.getMultiValueHeaders = exports.getMaxAge = exports.downloadFile = void 0;
+exports.localizeDataRoute = exports.localizeRoute = exports.unlocalizeRoute = exports.normalizeRoute = exports.netlifyApiFetch = exports.normalizePath = exports.getPrefetchResponse = exports.augmentFsModule = exports.getMultiValueHeaders = exports.getMaxAge = exports.downloadFile = void 0;
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
@@ -139,39 +139,6 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     });
 };
 exports.augmentFsModule = augmentFsModule;
-/**
- * Next.js has an annoying habit of needing deep imports, but then moving those in patch releases. This is our abstraction.
- */
-const getNextServer = () => {
-    let NextServer;
-    try {
-        // next >= 11.0.1. Yay breaking changes in patch releases!
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        NextServer = require('next/dist/server/next-server').default;
-    }
-    catch (error) {
-        if (!error.message.includes("Cannot find module 'next/dist/server/next-server'")) {
-            // A different error, so rethrow it
-            throw error;
-        }
-        // Probably an old version of next, so fall through and find it elsewhere.
-    }
-    if (!NextServer) {
-        try {
-            // next < 11.0.1
-            // eslint-disable-next-line n/no-missing-require, import/no-unresolved, @typescript-eslint/no-var-requires
-            NextServer = require('next/dist/next-server/server/next-server').default;
-        }
-        catch (error) {
-            if (!error.message.includes("Cannot find module 'next/dist/next-server/server/next-server'")) {
-                throw error;
-            }
-            throw new Error('Could not find Next.js server');
-        }
-    }
-    return NextServer;
-};
-exports.getNextServer = getNextServer;
 /**
  * Prefetch requests are used to check for middleware redirects, and shouldn't trigger SSR.
  */

package/lib/templates/server.js

@@ -1,81 +1,88 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetlifyNextServer = void 0;
+exports.getNetlifyNextServer = void 0;
 const handlerUtils_1 = require("./handlerUtils");
-const NextServer = (0, handlerUtils_1.getNextServer)();
-class NetlifyNextServer extends NextServer {
-    constructor(options, netlifyConfig) {
-        super(options);
-        this.netlifyConfig = netlifyConfig;
-        // copy the prerender manifest so it doesn't get mutated by Next.js
-        const manifest = this.getPrerenderManifest();
-        this.netlifyPrerenderManifest = {
-            ...manifest,
-            routes: { ...manifest.routes },
-            dynamicRoutes: { ...manifest.dynamicRoutes },
-        };
-    }
-    getRequestHandler() {
-        const handler = super.getRequestHandler();
-        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) {
-                await this.netlifyRevalidate(url);
-            }
-        };
-    }
-    async netlifyRevalidate(route) {
-        try {
-            // call netlify API to revalidate the path
-            const result = await (0, handlerUtils_1.netlifyApiFetch)({
-                endpoint: `sites/${process.env.SITE_ID}/refresh_on_demand_builders`,
-                payload: {
-                    paths: this.getNetlifyPathsForRoute(route),
-                    domain: this.hostname,
-                },
-                token: this.netlifyConfig.revalidateToken,
-                method: 'POST',
-            });
-            if (!result.ok) {
-                throw new Error(result.message);
-            }
+const getNetlifyNextServer = (NextServer) => {
+    class NetlifyNextServer extends NextServer {
+        constructor(options, netlifyConfig) {
+            super(options);
+            this.netlifyConfig = netlifyConfig;
+            // copy the prerender manifest so it doesn't get mutated by Next.js
+            const manifest = this.getPrerenderManifest();
+            this.netlifyPrerenderManifest = {
+                ...manifest,
+                routes: { ...manifest.routes },
+                dynamicRoutes: { ...manifest.dynamicRoutes },
+            };
         }
-        catch (error) {
-            console.log(`Error revalidating ${route}:`, error.message);
-            throw error;
+        getRequestHandler() {
+            const handler = super.getRequestHandler();
+            return async (req, res, parsedUrl) => {
+                // preserve the URL before Next.js mutates it for i18n
+                const { url, headers } = req;
+                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);
+                }
+            };
         }
-    }
-    getNetlifyPathsForRoute(route) {
-        const { i18n } = this.nextConfig;
-        const { routes, dynamicRoutes } = this.netlifyPrerenderManifest;
-        // matches static routes
-        const normalizedRoute = (0, handlerUtils_1.normalizeRoute)(i18n ? (0, handlerUtils_1.localizeRoute)(route, i18n) : route);
-        if (normalizedRoute in routes) {
-            const { dataRoute } = routes[normalizedRoute];
-            const normalizedDataRoute = i18n ? (0, handlerUtils_1.localizeDataRoute)(dataRoute, normalizedRoute) : dataRoute;
-            return [route, normalizedDataRoute];
+        async netlifyRevalidate(route) {
+            try {
+                // call netlify API to revalidate the path
+                const result = await (0, handlerUtils_1.netlifyApiFetch)({
+                    endpoint: `sites/${process.env.SITE_ID}/refresh_on_demand_builders`,
+                    payload: {
+                        paths: this.getNetlifyPathsForRoute(route),
+                        domain: this.hostname,
+                    },
+                    token: this.netlifyConfig.revalidateToken,
+                    method: 'POST',
+                });
+                if (!result.ok) {
+                    throw new Error(result.message);
+                }
+            }
+            catch (error) {
+                console.log(`Error revalidating ${route}:`, error.message);
+                throw error;
+            }
         }
-        // matches dynamic routes
-        const unlocalizedRoute = i18n ? (0, handlerUtils_1.unlocalizeRoute)(normalizedRoute, i18n) : normalizedRoute;
-        for (const dynamicRoute in dynamicRoutes) {
-            const { dataRoute, routeRegex } = dynamicRoutes[dynamicRoute];
-            const matches = unlocalizedRoute.match(routeRegex);
-            if (matches && matches.length !== 0) {
-                // remove the first match, which is the full route
-                matches.shift();
-                // replace the dynamic segments with the actual values
-                const interpolatedDataRoute = dataRoute.replace(/\[(.*?)]/g, () => matches.shift());
-                const normalizedDataRoute = i18n
-                    ? (0, handlerUtils_1.localizeDataRoute)(interpolatedDataRoute, normalizedRoute)
-                    : interpolatedDataRoute;
+        getNetlifyPathsForRoute(route) {
+            const { i18n } = this.nextConfig;
+            const { routes, dynamicRoutes } = this.netlifyPrerenderManifest;
+            // matches static routes
+            const normalizedRoute = (0, handlerUtils_1.normalizeRoute)(i18n ? (0, handlerUtils_1.localizeRoute)(route, i18n) : route);
+            if (normalizedRoute in routes) {
+                const { dataRoute } = routes[normalizedRoute];
+                const normalizedDataRoute = i18n ? (0, handlerUtils_1.localizeDataRoute)(dataRoute, normalizedRoute) : dataRoute;
                 return [route, normalizedDataRoute];
             }
+            // matches dynamic routes
+            const unlocalizedRoute = i18n ? (0, handlerUtils_1.unlocalizeRoute)(normalizedRoute, i18n) : normalizedRoute;
+            for (const dynamicRoute in dynamicRoutes) {
+                const { dataRoute, routeRegex } = dynamicRoutes[dynamicRoute];
+                const matches = unlocalizedRoute.match(routeRegex);
+                if ((matches === null || matches === void 0 ? void 0 : matches.length) > 0) {
+                    // remove the first match, which is the full route
+                    matches.shift();
+                    // replace the dynamic segments with the actual values
+                    const interpolatedDataRoute = dataRoute.replace(/\[(.*?)]/g, () => matches.shift());
+                    const normalizedDataRoute = i18n
+                        ? (0, handlerUtils_1.localizeDataRoute)(interpolatedDataRoute, normalizedRoute)
+                        : interpolatedDataRoute;
+                    return [route, normalizedDataRoute];
+                }
+            }
+            throw new Error(`not an ISR route`);
         }
-        throw new Error(`not an ISR route`);
     }
-}
-exports.NetlifyNextServer = NetlifyNextServer;
+    return NetlifyNextServer;
+};
+exports.getNetlifyNextServer = getNetlifyNextServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.36.0",
+  "version": "4.37.0",
   "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,12 +37,12 @@
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^29.9.2",
+    "@netlify/build": "^29.11.4",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",
     "@types/node": "^17.0.25",
-    "next": "^13.1.6",
+    "next": "^13.3.0",
     "npm-run-all": "^4.1.5",
     "typescript": "^4.6.3"
   },

package/src/templates/edge/shims.js

@@ -1,7 +1,11 @@
 // @ts-check
-// deno-lint-ignore-file no-var prefer-const no-unused-vars no-explicit-any
+// deno-lint-ignore-file prefer-const no-unused-vars
 import { decode as _base64Decode } from 'https://deno.land/std@0.175.0/encoding/base64.ts'
-import { AsyncLocalStorage as ALSCompat } from 'https://deno.land/std@0.175.0/node/async_hooks.ts'
+import BufferCompat from 'https://deno.land/std@0.175.0/node/buffer.ts'
+import EventsCompat from 'https://deno.land/std@0.175.0/node/events.ts'
+import AsyncHooksCompat from 'https://deno.land/std@0.175.0/node/async_hooks.ts'
+import AssertCompat from 'https://deno.land/std@0.175.0/node/assert.ts'
+import UtilCompat from 'https://deno.land/std@0.175.0/node/util.ts'
 
 /**
  * These are the shims, polyfills and other kludges to make Next.js work in standards-compliant runtime.
@@ -18,7 +22,7 @@ globalThis.EdgeRuntime = 'netlify-edge'
 let _ENTRIES = {}
 
 // Next.js expects this as a global
-globalThis.AsyncLocalStorage = ALSCompat
+globalThis.AsyncLocalStorage = AsyncHooksCompat.AsyncLocalStorage
 
 // Next.js uses this extension to the Headers API implemented by Cloudflare workerd
 if (!('getAll' in Headers.prototype)) {
@@ -48,6 +52,26 @@ const fetch /* type {typeof globalThis.fetch} */ = async (url, init) => {
   }
 }
 
+// Shim native modules that Vercel makes available
+if (typeof require === 'undefined') {
+  globalThis.require = (name) => {
+    switch (name.replace(/^node:/, '')) {
+      case 'buffer':
+        return BufferCompat
+      case 'events':
+        return EventsCompat
+      case 'async_hooks':
+        return AsyncHooksCompat
+      case 'assert':
+        return AssertCompat
+      case 'util':
+        return UtilCompat
+      default:
+        throw new ReferenceError(`Native module not found: ${name}`)
+    }
+  }
+}
+
 // Next edge runtime uses "self" as a function-scoped global-like object, but some of the older polyfills expect it to equal globalThis
 // See https://nextjs.org/docs/basic-features/supported-browsers-features#polyfills
 const self = { ...globalThis, fetch }