@netlify/plugin-nextjs 4.0.0-beta.8 → 4.0.0-rc.2

package/lib/helpers/redirects.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRedirects = void 0;
+const fs_extra_1 = require("fs-extra");
+const globby_1 = __importDefault(require("globby"));
+const pathe_1 = require("pathe");
+const constants_1 = require("../constants");
+const utils_1 = require("./utils");
+const generateLocaleRedirects = ({ i18n, basePath, trailingSlash, }) => {
+    const redirects = [];
+    // If the cookie is set, we need to redirect at the origin
+    redirects.push({
+        from: `${basePath}/`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+        force: true,
+        conditions: {
+            Cookie: ['NEXT_LOCALE'],
+        },
+    });
+    i18n.locales.forEach((locale) => {
+        if (locale === i18n.defaultLocale) {
+            return;
+        }
+        redirects.push({
+            from: `${basePath}/`,
+            to: `${basePath}/${locale}${trailingSlash ? '/' : ''}`,
+            status: 301,
+            conditions: {
+                Language: [locale],
+            },
+            force: true,
+        });
+    });
+    return redirects;
+};
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, }) => {
+    const { dynamicRoutes, routes: staticRoutes } = await fs_extra_1.readJSON(pathe_1.join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    netlifyConfig.redirects.push(...constants_1.HIDDEN_PATHS.map((path) => ({
+        from: `${basePath}${path}`,
+        to: '/404.html',
+        status: 404,
+        force: true,
+    })));
+    if (i18n && i18n.localeDetection !== false) {
+        netlifyConfig.redirects.push(...generateLocaleRedirects({ i18n, basePath, trailingSlash }));
+    }
+    const dataRedirects = [];
+    const pageRedirects = [];
+    const isrRedirects = [];
+    const dynamicRouteEntries = Object.entries(dynamicRoutes);
+    const staticRouteEntries = Object.entries(staticRoutes);
+    staticRouteEntries.forEach(([route, { dataRoute, initialRevalidateSeconds }]) => {
+        // Only look for revalidate as we need to rewrite these to SSR rather than ODB
+        if (initialRevalidateSeconds === false) {
+            // These can be ignored, as they're static files handled by the CDN
+            return;
+        }
+        if ((i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) && route.startsWith(`/${i18n.defaultLocale}/`)) {
+            route = route.slice(i18n.defaultLocale.length + 1);
+        }
+        isrRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute), ...utils_1.netlifyRoutesForNextRoute(route));
+    });
+    dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
+        // Add redirects if fallback is "null" (aka blocking) or true/a string
+        if (fallback === false) {
+            return;
+        }
+        pageRedirects.push(...utils_1.netlifyRoutesForNextRoute(route));
+        dataRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute));
+    });
+    if (i18n) {
+        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
+    }
+    const publicFiles = await globby_1.default('**/*', { cwd: pathe_1.join(appDir, 'public') });
+    // This is only used in prod, so dev uses `next dev` directly
+    netlifyConfig.redirects.push(
+    // Static files are in `static`
+    { from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 }, 
+    // API routes always need to be served from the regular function
+    {
+        from: `${basePath}/api`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    }, {
+        from: `${basePath}/api/*`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    }, 
+    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
+    ...publicFiles.map((file) => ({
+        from: `${basePath}/${file}`,
+        // This is a no-op, but we do it to stop it matching the following rule
+        to: `${basePath}/${file}`,
+        conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+        status: 200,
+    })), {
+        from: `${basePath}/*`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+        conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+        force: true,
+    }, 
+    // ISR redirects are handled by the regular function. Forced to avoid pre-rendered pages
+    ...isrRedirects.map((redirect) => ({
+        from: `${basePath}${redirect}`,
+        to: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+        force: true,
+    })), 
+    // These are pages with fallback set, which need an ODB
+    // Data redirects go first, to avoid conflict with splat redirects
+    ...dataRedirects.map((redirect) => ({
+        from: `${basePath}${redirect}`,
+        to: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+    })), 
+    // ...then all the other fallback pages
+    ...pageRedirects.map((redirect) => ({
+        from: `${basePath}${redirect}`,
+        to: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+    })), 
+    // Everything else is handled by the regular function
+    { from: `${basePath}/*`, to: constants_1.HANDLER_FUNCTION_PATH, status: 200 });
+};
+exports.generateRedirects = generateRedirects;

package/lib/helpers/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.netlifyRoutesForNextRoute = void 0;
+const constants_1 = require("../constants");
+const netlifyRoutesForNextRoute = (nextRoute) => {
+    const netlifyRoutes = [nextRoute];
+    // If the route is an optional catch-all route, we need to add a second
+    // Netlify route for the base path (when no parameters are present).
+    // The file ending must be present!
+    if (constants_1.OPTIONAL_CATCH_ALL_REGEX.test(nextRoute)) {
+        let netlifyRoute = nextRoute.replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '$2');
+        // create an empty string, but actually needs to be a forward slash
+        if (netlifyRoute === '') {
+            netlifyRoute = '/';
+        }
+        // When optional catch-all route is at top-level, the regex on line 19 will
+        // create an incorrect route for the data route. For example, it creates
+        // /_next/data/%BUILDID%.json, but NextJS looks for
+        // /_next/data/%BUILDID%/index.json
+        netlifyRoute = netlifyRoute.replace(/(\/_next\/data\/[^/]+).json/, '$1/index.json');
+        // Add second route to the front of the array
+        netlifyRoutes.unshift(netlifyRoute);
+    }
+    return netlifyRoutes.map((route) => route
+        // Replace catch-all, e.g., [...slug]
+        .replace(constants_1.CATCH_ALL_REGEX, '/:$1/*')
+        // Replace optional catch-all, e.g., [[...slug]]
+        .replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '/*')
+        // Replace dynamic parameters, e.g., [id]
+        .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
+};
+exports.netlifyRoutesForNextRoute = netlifyRoutesForNextRoute;

package/lib/helpers/verification.js

@@ -1,93 +1,123 @@
-const { existsSync, promises } = require('fs');
-const path = require('path');
-const { relative } = require('path');
-const { yellowBright, greenBright, blueBright, redBright, reset } = require('chalk');
-const { async: StreamZip } = require('node-stream-zip');
-const outdent = require('outdent');
-const prettyBytes = require('pretty-bytes');
-const { satisfies } = require('semver');
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBetaMessage = exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+const fs_1 = require("fs");
+const path_1 = __importStar(require("path"));
+const chalk_1 = require("chalk");
+const node_stream_zip_1 = require("node-stream-zip");
+const outdent_1 = require("outdent");
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const semver_1 = require("semver");
+const constants_1 = require("../constants");
 // This is when nft support was added
 const REQUIRED_BUILD_VERSION = '>=18.16.0';
-exports.verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild }) => {
+const verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild, }) => {
     // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
-    if (IS_LOCAL && !satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
-        return failBuild(outdent `
+    if (IS_LOCAL && !semver_1.satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
+        return failBuild(outdent_1.outdent `
       This version of the Essential Next.js plugin requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
       You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"
     `);
     }
 };
-exports.checkForOldFunctions = async ({ functions }) => {
-    const oldFunctions = (await functions.list()).filter(({ name }) => name.startsWith('next_'));
+exports.verifyNetlifyBuildVersion = verifyNetlifyBuildVersion;
+const checkForOldFunctions = async ({ functions }) => {
+    const allOldFunctions = await functions.list();
+    const oldFunctions = allOldFunctions.filter(({ name }) => name.startsWith('next_'));
     if (oldFunctions.length !== 0) {
-        console.log(yellowBright(outdent `
+        console.log(chalk_1.yellowBright(outdent_1.outdent `
         We have found the following functions in your site that seem to be left over from the old Next.js plugin (v3). We have guessed this because the name starts with "next_".
 
-        ${reset(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
+        ${chalk_1.reset(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
 
         If they were created by the old plugin, these functions are likely to cause errors so should be removed. You can do this by deleting the following directories:
 
-        ${reset(oldFunctions.map(({ mainFile }) => `- ${path.relative(process.cwd(), path.dirname(mainFile))}`).join('\n'))}
+        ${chalk_1.reset(oldFunctions.map(({ mainFile }) => `- ${path_1.default.relative(process.cwd(), path_1.default.dirname(mainFile))}`).join('\n'))}
       `));
     }
 };
-exports.checkNextSiteHasBuilt = ({ publish, failBuild }) => {
-    if (!existsSync(path.join(publish, 'BUILD_ID'))) {
-        return failBuild(outdent `
-      The directory "${path.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory. 
+exports.checkForOldFunctions = checkForOldFunctions;
+const checkNextSiteHasBuilt = ({ publish, failBuild, }) => {
+    if (!fs_1.existsSync(path_1.default.join(publish, 'BUILD_ID'))) {
+        return failBuild(outdent_1.outdent `
+      The directory "${path_1.default.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory. 
       In most cases it should be set to the site's ".next" directory path, unless you have chosen a custom "distDir" in your Next config. 
       If you are using "next export" then the Essential Next.js plugin should be removed. See https://ntl.fyi/remove-plugin for details.
     `);
     }
-    if (existsSync(path.join(publish, 'export-detail.json'))) {
-        failBuild(outdent `
+    if (fs_1.existsSync(path_1.default.join(publish, 'export-detail.json'))) {
+        failBuild(outdent_1.outdent `
       Detected that "next export" was run, but site is incorrectly publishing the ".next" directory.
       This plugin is not needed for "next export" so should be removed, and publish directory set to "out".
       See https://ntl.fyi/remove-plugin for more details on how to remove this plugin.
     `);
     }
 };
-exports.checkForRootPublish = ({ publish, failBuild }) => {
-    if (path.resolve(publish) === path.resolve('.')) {
-        failBuild(outdent `
+exports.checkNextSiteHasBuilt = checkNextSiteHasBuilt;
+const checkForRootPublish = ({ publish, failBuild, }) => {
+    if (path_1.default.resolve(publish) === path_1.default.resolve('.')) {
+        failBuild(outdent_1.outdent `
       Your publish directory is pointing to the base directory of your site. This is not supported for Next.js sites, and is probably a mistake. 
       In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config, or the Next site is in a subdirectory.
     `);
     }
 };
-// 50MB, which is the documented max, though the hard max seems to be higher
-const LAMBDA_MAX_SIZE = 1024 * 1024 * 50;
-exports.checkZipSize = async (file, maxSize = LAMBDA_MAX_SIZE) => {
-    if (!existsSync(file)) {
+exports.checkForRootPublish = checkForRootPublish;
+const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
+    if (!fs_1.existsSync(file)) {
         console.warn(`Could not check zip size because ${file} does not exist`);
         return;
     }
-    const size = await promises.stat(file).then(({ size }) => size);
-    if (size < maxSize) {
+    const fileSize = await fs_1.promises.stat(file).then(({ size }) => size);
+    if (fileSize < maxSize) {
         return;
     }
     // We don't fail the build, because the actual hard max size is larger so it might still succeed
-    console.log(redBright(outdent `
-      The function zip ${yellowBright(relative(process.cwd(), file))} size is ${prettyBytes(size)}, which is larger than the maximum supported size of ${prettyBytes(maxSize)}.
+    console.log(chalk_1.redBright(outdent_1.outdent `
+      The function zip ${chalk_1.yellowBright(path_1.relative(process.cwd(), file))} size is ${pretty_bytes_1.default(fileSize)}, which is larger than the maximum supported size of ${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.
     `));
-    const zip = new StreamZip({ file });
+    const zip = new node_stream_zip_1.async({ file });
     console.log(`Contains ${await zip.entriesCount} files`);
     const sortedFiles = Object.values(await zip.entries()).sort((a, b) => b.size - a.size);
     const largest = {};
     for (let i = 0; i < 10 && i < sortedFiles.length; i++) {
         largest[`${i + 1}`] = {
             File: sortedFiles[i].name,
-            'Compressed Size': prettyBytes(sortedFiles[i].compressedSize),
-            'Uncompressed Size': prettyBytes(sortedFiles[i].size),
+            'Compressed Size': pretty_bytes_1.default(sortedFiles[i].compressedSize),
+            'Uncompressed Size': pretty_bytes_1.default(sortedFiles[i].size),
         };
     }
-    console.log(yellowBright `\n\nThese are the largest files in the zip:`);
+    console.log(chalk_1.yellowBright `\n\nThese are the largest files in the zip:`);
     console.table(largest);
-    console.log(greenBright `\n\nFor more information on fixing this, see ${blueBright `https://ntl.fyi/large-next-functions`}`);
+    console.log(chalk_1.greenBright `\n\nFor more information on fixing this, see ${chalk_1.blueBright `https://ntl.fyi/large-next-functions`}`);
 };
-exports.logBetaMessage = () => console.log(greenBright(outdent `
+exports.checkZipSize = checkZipSize;
+const logBetaMessage = () => console.log(chalk_1.greenBright(outdent_1.outdent `
         Thank you for trying the Essential Next.js beta plugin. 
-        Please share feedback (both good and bad) at ${blueBright `https://ntl.fyi/next-beta-feedback`}
+        Please share feedback (both good and bad) at ${chalk_1.blueBright `https://ntl.fyi/next-beta-feedback`}
       `));
+exports.logBetaMessage = logBetaMessage;

package/lib/index.js

@@ -1,50 +1,60 @@
-const { join, relative } = require('path');
-const { ODB_FUNCTION_NAME } = require('./constants');
-const { restoreCache, saveCache } = require('./helpers/cache');
-const { getNextConfig, configureHandlerFunctions, generateRedirects } = require('./helpers/config');
-const { moveStaticPages, movePublicFiles } = require('./helpers/files');
-const { generateFunctions, setupImageFunction, generatePagesResolver } = require('./helpers/functions');
-const { verifyNetlifyBuildVersion, checkNextSiteHasBuilt, checkForRootPublish, logBetaMessage, checkZipSize, checkForOldFunctions, } = require('./helpers/verification');
-/** @type import("@netlify/build").NetlifyPlugin */
-module.exports = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const cache_1 = require("./helpers/cache");
+const config_1 = require("./helpers/config");
+const files_1 = require("./helpers/files");
+const functions_1 = require("./helpers/functions");
+const redirects_1 = require("./helpers/redirects");
+const verification_1 = require("./helpers/verification");
+const plugin = {
     async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
         var _a;
-        logBetaMessage();
+        verification_1.logBetaMessage();
         const { publish } = netlifyConfig.build;
-        checkForRootPublish({ publish, failBuild });
-        verifyNetlifyBuildVersion({ failBuild, ...constants });
-        await restoreCache({ cache, publish });
+        verification_1.checkForRootPublish({ publish, failBuild });
+        verification_1.verifyNetlifyBuildVersion({ failBuild, ...constants });
+        await cache_1.restoreCache({ cache, publish });
         (_a = netlifyConfig.build).environment || (_a.environment = {});
         // eslint-disable-next-line unicorn/consistent-destructuring
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
         const { publish } = netlifyConfig.build;
-        checkNextSiteHasBuilt({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore } = await getNextConfig({ publish, failBuild });
-        configureHandlerFunctions({ netlifyConfig, ignore, publish: relative(process.cwd(), publish) });
-        await generateFunctions(constants, appDir);
-        await generatePagesResolver({ netlifyConfig, target, constants });
-        await movePublicFiles({ appDir, publish });
+        verification_1.checkNextSiteHasBuilt({ publish, failBuild });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await config_1.getNextConfig({
+            publish,
+            failBuild,
+        });
+        config_1.configureHandlerFunctions({ netlifyConfig, ignore, publish: path_1.relative(process.cwd(), publish) });
+        await functions_1.generateFunctions(constants, appDir);
+        await functions_1.generatePagesResolver({ target, constants });
+        await files_1.movePublicFiles({ appDir, outdir, publish });
+        if (process.env.EXPERIMENTAL_ODB_TTL) {
+            await files_1.patchNextFiles(basePath);
+        }
         if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES) {
             console.log("The flag 'EXPERIMENTAL_MOVE_STATIC_PAGES' is no longer required, as it is now the default. To disable this behavior, set the env var 'SERVE_STATIC_FILES_FROM_ORIGIN' to 'true'");
         }
         if (!process.env.SERVE_STATIC_FILES_FROM_ORIGIN) {
-            await moveStaticPages({ target, failBuild, netlifyConfig, i18n });
+            await files_1.moveStaticPages({ target, netlifyConfig, i18n });
         }
-        await setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
-        await generateRedirects({
+        await functions_1.setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
+        await redirects_1.generateRedirects({
             netlifyConfig,
-            basePath,
-            i18n,
+            nextConfig: { basePath, i18n, trailingSlash, appDir },
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions }, constants: { FUNCTIONS_DIST } }) {
-        await saveCache({ cache, publish: netlifyConfig.build.publish });
-        await checkForOldFunctions({ functions });
-        await checkZipSize(join(FUNCTIONS_DIST, `${ODB_FUNCTION_NAME}.zip`));
+    async onPostBuild({ netlifyConfig, utils: { cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
+        await cache_1.saveCache({ cache, publish: netlifyConfig.build.publish });
+        await verification_1.checkForOldFunctions({ functions });
+        await verification_1.checkZipSize(path_1.join(FUNCTIONS_DIST, `${constants_1.ODB_FUNCTION_NAME}.zip`));
+        const { basePath } = await config_1.getNextConfig({ publish: netlifyConfig.build.publish, failBuild });
+        await files_1.unpatchNextFiles(basePath);
     },
     onEnd() {
-        logBetaMessage();
+        verification_1.logBetaMessage();
     },
 };
+module.exports = plugin;

package/lib/templates/getHandler.js

@@ -1,89 +1,32 @@
-const { promises, createWriteStream, existsSync } = require('fs');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHandler = void 0;
+const { promises } = require('fs');
 const { Server } = require('http');
-const { tmpdir } = require('os');
 const path = require('path');
-const { promisify } = require('util');
-const streamPipeline = promisify(require('stream').pipeline);
+// eslint-disable-next-line node/prefer-global/url, node/prefer-global/url-search-params
+const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node/dist/bridge');
-const fetch = require('node-fetch');
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils');
 const makeHandler = () => 
 // We return a function and then call `toString()` on it to serialise it as the launcher function
-(conf, app, pageRoot, staticManifest = []) => {
+// eslint-disable-next-line max-params
+(conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
     // This is just so nft knows about the page entrypoints. It's not actually used
     try {
         // eslint-disable-next-line node/no-missing-require
         require.resolve('./pages.js');
     }
     catch { }
+    // eslint-disable-next-line no-underscore-dangle
+    process.env._BYPASS_SSG = 'true';
+    const ONE_YEAR_IN_SECONDS = 31536000;
+    // We don't want to write ISR files to disk in the lambda environment
+    conf.experimental.isrFlushToDisk = false;
     // Set during the request as it needs the host header. Hoisted so we can define the function once
     let base;
-    // Only do this if we have some static files moved to the CDN
-    if (staticManifest.length !== 0) {
-        // These are static page files that have been removed from the function bundle
-        // In most cases these are served from the CDN, but for rewrites Next may try to read them
-        // from disk. We need to intercept these and load them from the CDN instead
-        // Sadly the only way to do this is to monkey-patch fs.promises. Yeah, I know.
-        const staticFiles = new Set(staticManifest);
-        // Yes, you can cache stuff locally in a Lambda
-        const cacheDir = path.join(tmpdir(), 'next-static-cache');
-        // Grab the real fs.promises.readFile...
-        const readfileOrig = promises.readFile;
-        // ...then money-patch it to see if it's requesting a CDN file
-        promises.readFile = async (file, options) => {
-            // We only care about page files
-            if (file.startsWith(pageRoot)) {
-                // We only want the part after `pages/`
-                const filePath = file.slice(pageRoot.length + 1);
-                // Is it in the CDN and not local?
-                if (staticFiles.has(filePath) && !existsSync(file)) {
-                    // This name is safe to use, because it's one that was already created by Next
-                    const cacheFile = path.join(cacheDir, filePath);
-                    // Have we already cached it? We ignore the cache if running locally to avoid staleness
-                    if ((!existsSync(cacheFile) || process.env.NETLIFY_DEV) && base) {
-                        await promises.mkdir(path.dirname(cacheFile), { recursive: true });
-                        // Append the path to our host and we can load it like a regular page
-                        const url = `${base}/${filePath}`;
-                        console.log(`Downloading ${url} to ${cacheFile}`);
-                        const response = await fetch(url);
-                        if (!response.ok) {
-                            // Next catches this and returns it as a not found file
-                            throw new Error(`Failed to fetch ${url}`);
-                        }
-                        // Stream it to disk
-                        await streamPipeline(response.body, createWriteStream(cacheFile));
-                    }
-                    // Return the cache file
-                    return readfileOrig(cacheFile, options);
-                }
-            }
-            return readfileOrig(file, options);
-        };
-    }
-    let NextServer;
-    try {
-        // next >= 11.0.1. Yay breaking changes in patch releases!
-        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
-    }
-    if (!NextServer) {
-        try {
-            // next < 11.0.1
-            // eslint-disable-next-line node/no-missing-require, import/no-unresolved
-            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');
-        }
-    }
+    augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
+    const NextServer = getNextServer();
     const nextServer = new NextServer({
         conf,
         dir: path.resolve(__dirname, app),
@@ -102,9 +45,10 @@ const makeHandler = () =>
     const bridge = new Bridge(server);
     bridge.listen();
     return async (event, context) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
+        let requestMode = mode;
         // Ensure that paths are encoded - but don't double-encode them
-        event.path = new URL(event.path, event.rawUrl).pathname;
+        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;
@@ -115,25 +59,27 @@ const makeHandler = () =>
             base = `${protocol}://${host}`;
         }
         const { headers, ...result } = await bridge.launcher(event, context);
-        /** @type import("@netlify/functions").HandlerResponse */
         // Convert all headers to multiValueHeaders
-        const multiValueHeaders = {};
-        for (const key of Object.keys(headers)) {
-            if (Array.isArray(headers[key])) {
-                multiValueHeaders[key] = headers[key];
-            }
-            else {
-                multiValueHeaders[key] = [headers[key]];
-            }
-        }
+        const multiValueHeaders = getMultiValueHeaders(headers);
         if ((_b = (_a = multiValueHeaders['set-cookie']) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('__prerender_bypass')) {
             delete multiValueHeaders.etag;
             multiValueHeaders['cache-control'] = ['no-cache'];
         }
         // Sending SWR headers causes undefined behaviour with the Netlify CDN
-        if ((_d = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.includes('stale-while-revalidate')) {
+        const cacheHeader = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0];
+        if (cacheHeader === null || cacheHeader === void 0 ? void 0 : cacheHeader.includes('stale-while-revalidate')) {
+            if (requestMode === 'odb') {
+                requestMode = 'isr';
+                const ttl = getMaxAge(cacheHeader);
+                // Long-expiry TTL is basically no TTL
+                if (ttl > 0 && ttl < ONE_YEAR_IN_SECONDS) {
+                    result.ttl = ttl;
+                }
+                multiValueHeaders['x-rendered-at'] = [new Date().toISOString()];
+            }
             multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
         }
+        multiValueHeaders['x-render-mode'] = [requestMode];
         return {
             ...result,
             multiValueHeaders,
@@ -143,13 +89,10 @@ const makeHandler = () =>
 };
 const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => `
 const { Server } = require("http");
-const { tmpdir } = require('os')
-const { promises, createWriteStream, existsSync } = require("fs");
-const { promisify } = require('util')
-const streamPipeline = promisify(require('stream').pipeline)
+const { promises } = require("fs");
 // We copy the file here rather than requiring from the node module
 const { Bridge } = require("./bridge");
-const fetch = require('node-fetch')
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
 
 const { builder } = require("@netlify/functions");
 const { config }  = require("${publishDir}/required-server-files.json")
@@ -160,7 +103,8 @@ try {
 const path = require("path");
 const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
 exports.handler = ${isODB
-    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest));`
-    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest);`}
+    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
+    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
 `;
-module.exports = getHandler;
+exports.getHandler = getHandler;
+/* eslint-enable @typescript-eslint/no-var-requires */