@netlify/plugin-nextjs 4.0.0-beta.9 → 4.0.0-rc.0

package/lib/constants.js

@@ -1,8 +1,11 @@
-const HANDLER_FUNCTION_NAME = '___netlify-handler';
-const ODB_FUNCTION_NAME = '___netlify-odb-handler';
-const IMAGE_FUNCTION_NAME = '_ipx';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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_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';
 // These are paths in .next that shouldn't be publicly accessible
-const HIDDEN_PATHS = [
+exports.HIDDEN_PATHS = [
     '/cache/*',
     '/server/*',
     '/serverless/*',
@@ -13,9 +16,9 @@ const HIDDEN_PATHS = [
     '/react-loadable-manifest.json',
     '/BUILD_ID',
 ];
-module.exports = {
-    HIDDEN_PATHS,
-    IMAGE_FUNCTION_NAME,
-    HANDLER_FUNCTION_NAME,
-    ODB_FUNCTION_NAME,
-};
+exports.ODB_FUNCTION_PATH = `/.netlify/builders/${exports.ODB_FUNCTION_NAME}`;
+exports.HANDLER_FUNCTION_PATH = `/.netlify/functions/${exports.HANDLER_FUNCTION_NAME}`;
+exports.DEFAULT_FUNCTIONS_SRC = 'netlify/functions';
+exports.CATCH_ALL_REGEX = /\/\[\.{3}(.*)](.json)?$/;
+exports.OPTIONAL_CATCH_ALL_REGEX = /\/\[{2}\.{3}(.*)]{2}(.json)?$/;
+exports.DYNAMIC_PARAMETER_REGEX = /\/\[(.*?)]/g;

package/lib/helpers/cache.js

@@ -1,6 +1,9 @@
-const { posix: { join }, } = require('path');
-exports.restoreCache = async ({ cache, publish }) => {
-    const cacheDir = join(publish, 'cache');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveCache = exports.restoreCache = void 0;
+const path_1 = require("path");
+const restoreCache = async ({ cache, publish }) => {
+    const cacheDir = path_1.posix.join(publish, 'cache');
     if (await cache.restore(cacheDir)) {
         console.log('Next.js cache restored.');
     }
@@ -8,9 +11,10 @@ exports.restoreCache = async ({ cache, publish }) => {
         console.log('No Next.js cache to restore.');
     }
 };
-exports.saveCache = async ({ cache, publish }) => {
-    const cacheDir = join(publish, 'cache');
-    const buildManifest = join(publish, 'build-manifest.json');
+exports.restoreCache = restoreCache;
+const saveCache = async ({ cache, publish }) => {
+    const cacheDir = path_1.posix.join(publish, 'cache');
+    const buildManifest = path_1.posix.join(publish, 'build-manifest.json');
     if (await cache.save(cacheDir, { digests: [buildManifest] })) {
         console.log('Next.js cache saved.');
     }
@@ -18,3 +22,4 @@ exports.saveCache = async ({ cache, publish }) => {
         console.log('No Next.js cache to save.');
     }
 };
+exports.saveCache = saveCache;

package/lib/helpers/config.js

@@ -1,81 +1,22 @@
-// @ts-check
-const { readJSON, existsSync } = require('fs-extra');
-const { join, dirname, relative } = require('pathe');
-const slash = require('slash');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureHandlerFunctions = exports.getNextConfig = void 0;
+const fs_extra_1 = require("fs-extra");
+const pathe_1 = require("pathe");
+const slash_1 = __importDefault(require("slash"));
+const constants_1 = require("../constants");
 const defaultFailBuild = (message, { error }) => {
     throw new Error(`${message}\n${error && error.stack}`);
 };
-const { HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, HIDDEN_PATHS } = require('../constants');
-const ODB_FUNCTION_PATH = `/.netlify/builders/${ODB_FUNCTION_NAME}`;
-const HANDLER_FUNCTION_PATH = `/.netlify/functions/${HANDLER_FUNCTION_NAME}`;
-const CATCH_ALL_REGEX = /\/\[\.{3}(.*)](.json)?$/;
-const OPTIONAL_CATCH_ALL_REGEX = /\/\[{2}\.{3}(.*)]{2}(.json)?$/;
-const DYNAMIC_PARAMETER_REGEX = /\/\[(.*?)]/g;
-const getNetlifyRoutes = (nextRoute) => {
-    let 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 (OPTIONAL_CATCH_ALL_REGEX.test(nextRoute)) {
-        let netlifyRoute = nextRoute.replace(OPTIONAL_CATCH_ALL_REGEX, '$2');
-        // When optional catch-all route is at top-level, the regex on line 19 will
-        // 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);
-    }
-    // Replace catch-all, e.g., [...slug]
-    netlifyRoutes = netlifyRoutes.map((route) => route.replace(CATCH_ALL_REGEX, '/:$1/*'));
-    // Replace optional catch-all, e.g., [[...slug]]
-    netlifyRoutes = netlifyRoutes.map((route) => route.replace(OPTIONAL_CATCH_ALL_REGEX, '/*'));
-    // Replace dynamic parameters, e.g., [id]
-    netlifyRoutes = netlifyRoutes.map((route) => route.replace(DYNAMIC_PARAMETER_REGEX, '/:$1'));
-    return netlifyRoutes;
-};
-exports.generateRedirects = async ({ netlifyConfig, basePath, i18n }) => {
-    const { dynamicRoutes } = await readJSON(join(netlifyConfig.build.publish, 'prerender-manifest.json'));
-    const redirects = [];
-    netlifyConfig.redirects.push(...HIDDEN_PATHS.map((path) => ({
-        from: `${basePath}${path}`,
-        to: '/404.html',
-        status: 404,
-        force: true,
-    })));
-    const dynamicRouteEntries = Object.entries(dynamicRoutes);
-    dynamicRouteEntries.sort((a, b) => a[0].localeCompare(b[0]));
-    dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
-        // Add redirects if fallback is "null" (aka blocking) or true/a string
-        if (fallback === false) {
-            return;
-        }
-        redirects.push(...getNetlifyRoutes(route), ...getNetlifyRoutes(dataRoute));
-    });
-    if (i18n) {
-        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
-    }
-    // This is only used in prod, so dev uses `next dev` directly
-    netlifyConfig.redirects.push({ from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 }, {
-        from: `${basePath}/*`,
-        to: HANDLER_FUNCTION_PATH,
-        status: 200,
-        conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
-        force: true,
-    }, ...redirects.map((redirect) => ({
-        from: `${basePath}${redirect}`,
-        to: ODB_FUNCTION_PATH,
-        status: 200,
-    })), { from: `${basePath}/*`, to: HANDLER_FUNCTION_PATH, status: 200 });
-};
-exports.getNextConfig = async function getNextConfig({ publish, failBuild = defaultFailBuild }) {
+const getNextConfig = async function getNextConfig({ publish, failBuild = defaultFailBuild, }) {
     try {
-        const { config, appDir, ignore } = await readJSON(join(publish, 'required-server-files.json'));
+        const { config, appDir, ignore } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(publish, 'required-server-files.json'));
         if (!config) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
             return failBuild('Error loading your Next config');
         }
         return { ...config, appDir, ignore };
@@ -84,26 +25,27 @@ exports.getNextConfig = async function getNextConfig({ publish, failBuild = defa
         return failBuild('Error loading your Next config', { error });
     }
 };
+exports.getNextConfig = getNextConfig;
 const resolveModuleRoot = (moduleName) => {
     try {
-        return dirname(relative(process.cwd(), require.resolve(`${moduleName}/package.json`, { paths: [process.cwd()] })));
+        return (0, pathe_1.dirname)((0, pathe_1.relative)(process.cwd(), require.resolve(`${moduleName}/package.json`, { paths: [process.cwd()] })));
     }
     catch (error) {
         return null;
     }
 };
 const DEFAULT_EXCLUDED_MODULES = ['sharp', 'electron'];
-exports.configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) => {
+const configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) => {
     var _a;
     /* eslint-disable no-underscore-dangle */
     (_a = netlifyConfig.functions)._ipx || (_a._ipx = {});
     netlifyConfig.functions._ipx.node_bundler = 'nft';
-    [HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME].forEach((functionName) => {
+    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME].forEach((functionName) => {
         var _a, _b;
         (_a = netlifyConfig.functions)[functionName] || (_a[functionName] = { included_files: [], external_node_modules: [] });
         netlifyConfig.functions[functionName].node_bundler = 'nft';
         (_b = netlifyConfig.functions[functionName]).included_files || (_b.included_files = []);
-        netlifyConfig.functions[functionName].included_files.push(`${publish}/server/**`, `${publish}/serverless/**`, `${publish}/*.json`, `${publish}/BUILD_ID`, `${publish}/static/chunks/webpack-middleware*.js`, `!${publish}/server/**/*.js.nft.json`, ...ignore.map((path) => `!${slash(path)}`));
+        netlifyConfig.functions[functionName].included_files.push('.env', '.env.local', '.env.production', '.env.production.local', `${publish}/server/**`, `${publish}/serverless/**`, `${publish}/*.json`, `${publish}/BUILD_ID`, `${publish}/static/chunks/webpack-middleware*.js`, `!${publish}/server/**/*.js.nft.json`, ...ignore.map((path) => `!${(0, slash_1.default)(path)}`));
         const nextRoot = resolveModuleRoot('next');
         if (nextRoot) {
             netlifyConfig.functions[functionName].included_files.push(`!${nextRoot}/dist/server/lib/squoosh/**/*.wasm`, `!${nextRoot}/dist/next-server/server/lib/squoosh/**/*.wasm`, `!${nextRoot}/dist/compiled/webpack/bundle4.js`, `!${nextRoot}/dist/compiled/webpack/bundle5.js`, `!${nextRoot}/dist/compiled/terser/bundle.min.js`);
@@ -116,3 +58,4 @@ exports.configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) =>
         });
     });
 };
+exports.configureHandlerFunctions = configureHandlerFunctions;

package/lib/helpers/files.js

@@ -1,7 +1,7 @@
-//  @ts-check
+/* eslint-disable max-lines */
 const { cpus } = require('os');
 const { yellowBright } = require('chalk');
-const { existsSync, readJson, move, cpSync, copy, writeJson } = require('fs-extra');
+const { existsSync, readJson, move, copy, writeJson, readFile, writeFile, ensureDir, readFileSync, } = require('fs-extra');
 const globby = require('globby');
 const { outdent } = require('outdent');
 const pLimit = require('p-limit');
@@ -18,13 +18,40 @@ const stripLocale = (rawPath, locales = []) => {
 };
 const matchMiddleware = (middleware, filePath) => (middleware === null || middleware === void 0 ? void 0 : middleware.includes('')) ||
     (middleware === null || middleware === void 0 ? void 0 : middleware.find((middlewarePath) => filePath === middlewarePath || filePath === `${middlewarePath}.html` || filePath.startsWith(`${middlewarePath}/`)));
+const matchesRedirect = (file, redirects) => {
+    if (!Array.isArray(redirects)) {
+        return false;
+    }
+    return redirects.some((redirect) => {
+        if (!redirect.regex || redirect.internal) {
+            return false;
+        }
+        // Strips the extension from the file path
+        return new RegExp(redirect.regex).test(`/${file.slice(0, -5)}`);
+    });
+};
+const matchesRewrite = (file, rewrites) => {
+    if (Array.isArray(rewrites)) {
+        return matchesRedirect(file, rewrites);
+    }
+    if (!Array.isArray(rewrites === null || rewrites === void 0 ? void 0 : rewrites.beforeFiles)) {
+        return false;
+    }
+    return matchesRedirect(file, rewrites.beforeFiles);
+};
+exports.matchesRedirect = matchesRedirect;
+exports.matchesRewrite = matchesRewrite;
 exports.matchMiddleware = matchMiddleware;
 exports.stripLocale = stripLocale;
 exports.isDynamicRoute = isDynamicRoute;
+// eslint-disable-next-line max-lines-per-function
 exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
     console.log('Moving static page files to serve from CDN...');
     const outputDir = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
     const root = join(outputDir, 'pages');
+    const buildId = readFileSync(join(netlifyConfig.build.publish, 'BUILD_ID'), 'utf8').trim();
+    const dataDir = join('_next', 'data', buildId);
+    await ensureDir(dataDir);
     // Load the middleware manifest so we can check if a file matches it before moving
     let middleware;
     const manifestPath = join(outputDir, 'middleware-manifest.json');
@@ -34,12 +61,32 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
             middleware = Object.keys(manifest.middleware).map((path) => path.slice(1));
         }
     }
+    const prerenderManifest = await readJson(join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    const { redirects, rewrites } = await readJson(join(netlifyConfig.build.publish, 'routes-manifest.json'));
+    const isrFiles = new Set();
+    Object.entries(prerenderManifest.routes).forEach(([route, { initialRevalidateSeconds }]) => {
+        if (initialRevalidateSeconds) {
+            // Find all files used by ISR routes
+            const trimmedPath = route.slice(1);
+            isrFiles.add(`${trimmedPath}.html`);
+            isrFiles.add(`${trimmedPath}.json`);
+        }
+    });
     const files = [];
+    const filesManifest = {};
     const moveFile = async (file) => {
+        const isData = file.endsWith('.json');
         const source = join(root, file);
+        const target = isData ? join(dataDir, file) : file;
         files.push(file);
-        const dest = join(netlifyConfig.build.publish, file);
-        await move(source, dest);
+        filesManifest[file] = target;
+        const dest = join(netlifyConfig.build.publish, target);
+        try {
+            await move(source, dest);
+        }
+        catch (error) {
+            console.warn('Error moving file', source, error);
+        }
     };
     // Move all static files, except error documents and nft manifests
     const pages = await globby(['**/*.{html,json}', '!**/(500|404|*.js.nft).{html,json}'], {
@@ -48,13 +95,27 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
     });
     const matchingMiddleware = new Set();
     const matchedPages = new Set();
+    const matchedRedirects = new Set();
+    const matchedRewrites = new Set();
     // Limit concurrent file moves to number of cpus or 2 if there is only 1
     const limit = pLimit(Math.max(2, cpus().length));
     const promises = pages.map(async (rawPath) => {
         const filePath = slash(rawPath);
+        // Don't move ISR files, as they're used for the first request
+        if (isrFiles.has(filePath)) {
+            return;
+        }
         if (isDynamicRoute(filePath)) {
             return;
         }
+        if (matchesRedirect(filePath, redirects)) {
+            matchedRedirects.add(filePath);
+            return;
+        }
+        if (matchesRewrite(filePath, rewrites)) {
+            matchedRewrites.add(filePath);
+            return;
+        }
         // Middleware matches against the unlocalised path
         const unlocalizedPath = stripLocale(rawPath, i18n === null || i18n === void 0 ? void 0 : i18n.locales);
         const middlewarePath = matchMiddleware(middleware, unlocalizedPath);
@@ -70,12 +131,15 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
     console.log(`Moved ${files.length} files`);
     if (matchedPages.size !== 0) {
         console.log(yellowBright(outdent `
-        Skipped moving ${matchedPages.size} ${matchedPages.size === 1 ? 'file because it matches' : 'files because they match'} middleware, so cannot be deployed to the CDN and will be served from the origin instead. This is fine, but we're letting you know because it may not be what you expect.
+        Skipped moving ${matchedPages.size} ${matchedPages.size === 1 ? 'file because it matches' : 'files because they match'} middleware, so cannot be deployed to the CDN and will be served from the origin instead.
+        This is fine, but we're letting you know because it may not be what you expect.
       `));
         console.log(outdent `
         The following middleware matched statically-rendered pages:
 
         ${yellowBright([...matchingMiddleware].map((mid) => `- /${mid}/_middleware`).join('\n'))}
+
+        ────────────────────────────────────────────────────────────────
       `);
         // There could potentially be thousands of matching pages, so we don't want to spam the console with this
         if (matchedPages.size < 50) {
@@ -83,22 +147,112 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
           The following files matched middleware and were not moved to the CDN:
 
           ${yellowBright([...matchedPages].map((mid) => `- ${mid}`).join('\n'))}
+
+          ────────────────────────────────────────────────────────────────
+        `);
+        }
+    }
+    if (matchedRedirects.size !== 0 || matchedRewrites.size !== 0) {
+        console.log(yellowBright(outdent `
+        Skipped moving ${matchedRedirects.size + matchedRewrites.size} files because they match redirects or beforeFiles rewrites, so cannot be deployed to the CDN and will be served from the origin instead.
+      `));
+        if (matchedRedirects.size < 50 && matchedRedirects.size !== 0) {
+            console.log(outdent `
+          The following files matched redirects and were not moved to the CDN:
+
+          ${yellowBright([...matchedRedirects].map((mid) => `- ${mid}`).join('\n'))}
+
+          ────────────────────────────────────────────────────────────────
+        `);
+        }
+        if (matchedRewrites.size < 50 && matchedRewrites.size !== 0) {
+            console.log(outdent `
+          The following files matched beforeFiles rewrites and were not moved to the CDN:
+
+          ${yellowBright([...matchedRewrites].map((mid) => `- ${mid}`).join('\n'))}
+
+          ────────────────────────────────────────────────────────────────
         `);
         }
     }
     // Write the manifest for use in the serverless functions
-    await writeJson(join(netlifyConfig.build.publish, 'static-manifest.json'), files);
+    await writeJson(join(netlifyConfig.build.publish, 'static-manifest.json'), Object.entries(filesManifest));
     if (i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) {
         // Copy the default locale into the root
         const defaultLocaleDir = join(netlifyConfig.build.publish, i18n.defaultLocale);
         if (existsSync(defaultLocaleDir)) {
             await copy(defaultLocaleDir, `${netlifyConfig.build.publish}/`);
         }
+        const defaultLocaleIndex = join(netlifyConfig.build.publish, `${i18n.defaultLocale}.html`);
+        const indexHtml = join(netlifyConfig.build.publish, 'index.html');
+        if (existsSync(defaultLocaleIndex) && !existsSync(indexHtml)) {
+            try {
+                await copy(defaultLocaleIndex, indexHtml, { overwrite: false });
+                await copy(join(netlifyConfig.build.publish, `${i18n.defaultLocale}.json`), join(netlifyConfig.build.publish, 'index.json'), { overwrite: false });
+            }
+            catch { }
+        }
+    }
+};
+const patchFile = async ({ file, from, to }) => {
+    if (!existsSync(file)) {
+        return;
+    }
+    const content = await readFile(file, 'utf8');
+    if (content.includes(to)) {
+        return;
+    }
+    const newContent = content.replace(from, to);
+    await writeFile(`${file}.orig`, content);
+    await writeFile(file, newContent);
+};
+const getServerFile = (root) => {
+    let serverFile;
+    try {
+        serverFile = require.resolve('next/dist/server/next-server', { paths: [root] });
+    }
+    catch {
+        // Ignore
+    }
+    if (!serverFile) {
+        try {
+            // eslint-disable-next-line node/no-missing-require
+            serverFile = require.resolve('next/dist/next-server/server/next-server', { paths: [root] });
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return serverFile;
+};
+exports.patchNextFiles = async (root) => {
+    const serverFile = getServerFile(root);
+    console.log(`Patching ${serverFile}`);
+    if (serverFile) {
+        await patchFile({
+            file: serverFile,
+            from: `let ssgCacheKey = `,
+            to: `let ssgCacheKey = process.env._BYPASS_SSG || `,
+        });
+    }
+};
+exports.unpatchNextFiles = async (root) => {
+    const serverFile = getServerFile(root);
+    const origFile = `${serverFile}.orig`;
+    if (existsSync(origFile)) {
+        await move(origFile, serverFile, { overwrite: true });
     }
 };
-exports.movePublicFiles = async ({ appDir, publish }) => {
-    const publicDir = join(appDir, 'public');
+exports.movePublicFiles = async ({ appDir, outdir, publish }) => {
+    // `outdir` is a config property added when using Next.js with Nx. It's typically
+    // a relative path outside of the appDir, e.g. '../../dist/apps/<app-name>', and
+    // the parent directory of the .next directory.
+    // If it exists, copy the files from the public folder there in order to include
+    // any files that were generated during the build. Otherwise, copy the public
+    // directory from the original app directory.
+    const publicDir = outdir ? join(appDir, outdir, 'public') : join(appDir, 'public');
     if (existsSync(publicDir)) {
         await copy(publicDir, `${publish}/`);
     }
 };
+/* eslint-enable max-lines */

package/lib/helpers/functions.js

@@ -1,56 +1,61 @@
-const { copyFile, ensureDir, writeFile, writeJSON } = require('fs-extra');
-const { join, relative } = require('pathe');
-const { HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, IMAGE_FUNCTION_NAME } = require('../constants');
-const getHandler = require('../templates/getHandler');
-const { getPageResolver } = require('../templates/getPageResolver');
-const DEFAULT_FUNCTIONS_SRC = 'netlify/functions';
-exports.generateFunctions = async ({ FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
+const fs_extra_1 = require("fs-extra");
+const pathe_1 = require("pathe");
+const constants_1 = require("../constants");
+const getHandler_1 = require("../templates/getHandler");
+const getPageResolver_1 = require("../templates/getPageResolver");
+const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
     const functionsDir = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
     const bridgeFile = require.resolve('@vercel/node/dist/bridge');
-    const functionDir = join(process.cwd(), functionsDir, HANDLER_FUNCTION_NAME);
-    const publishDir = relative(functionDir, join(process.cwd(), PUBLISH_DIR));
+    const functionDir = (0, pathe_1.join)(process.cwd(), functionsDir, constants_1.HANDLER_FUNCTION_NAME);
+    const publishDir = (0, pathe_1.relative)(functionDir, (0, pathe_1.join)(process.cwd(), PUBLISH_DIR));
     const writeHandler = async (func, isODB) => {
-        const handlerSource = await getHandler({ isODB, publishDir, appDir: relative(functionDir, appDir) });
-        await ensureDir(join(functionsDir, func));
-        await writeFile(join(functionsDir, func, `${func}.js`), handlerSource);
-        await copyFile(bridgeFile, join(functionsDir, func, 'bridge.js'));
+        const handlerSource = await (0, getHandler_1.getHandler)({ isODB, publishDir, appDir: (0, pathe_1.relative)(functionDir, appDir) });
+        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, func));
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, func, `${func}.js`), handlerSource);
+        await (0, fs_extra_1.copyFile)(bridgeFile, (0, pathe_1.join)(functionsDir, func, 'bridge.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, func, 'handlerUtils.js'));
     };
-    await writeHandler(HANDLER_FUNCTION_NAME, false);
-    await writeHandler(ODB_FUNCTION_NAME, true);
+    await writeHandler(constants_1.HANDLER_FUNCTION_NAME, false);
+    await writeHandler(constants_1.ODB_FUNCTION_NAME, true);
 };
+exports.generateFunctions = generateFunctions;
 /**
  * Writes a file in each function directory that contains references to every page entrypoint.
  * This is just so that the nft bundler knows about them. We'll eventually do this better.
  */
-exports.generatePagesResolver = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC }, netlifyConfig, target, }) => {
+const generatePagesResolver = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC }, netlifyConfig, target, }) => {
     const functionsPath = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
-    const jsSource = await getPageResolver({
+    const jsSource = await (0, getPageResolver_1.getPageResolver)({
         netlifyConfig,
         target,
     });
-    await writeFile(join(functionsPath, ODB_FUNCTION_NAME, 'pages.js'), jsSource);
-    await writeFile(join(functionsPath, HANDLER_FUNCTION_NAME, 'pages.js'), jsSource);
+    await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsPath, constants_1.ODB_FUNCTION_NAME, 'pages.js'), jsSource);
+    await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsPath, constants_1.HANDLER_FUNCTION_NAME, 'pages.js'), jsSource);
 };
+exports.generatePagesResolver = generatePagesResolver;
 // Move our next/image function into the correct functions directory
-exports.setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC }, imageconfig = {}, netlifyConfig, basePath, }) => {
+const setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC }, imageconfig = {}, netlifyConfig, basePath, }) => {
     const functionsPath = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
-    const functionName = `${IMAGE_FUNCTION_NAME}.js`;
-    const functionDirectory = join(functionsPath, IMAGE_FUNCTION_NAME);
-    await ensureDir(functionDirectory);
-    await writeJSON(join(functionDirectory, 'imageconfig.json'), {
+    const functionName = `${constants_1.IMAGE_FUNCTION_NAME}.js`;
+    const functionDirectory = (0, pathe_1.join)(functionsPath, constants_1.IMAGE_FUNCTION_NAME);
+    await (0, fs_extra_1.ensureDir)(functionDirectory);
+    await (0, fs_extra_1.writeJSON)((0, pathe_1.join)(functionDirectory, 'imageconfig.json'), {
         ...imageconfig,
-        basePath: [basePath, IMAGE_FUNCTION_NAME].join('/'),
+        basePath: [basePath, constants_1.IMAGE_FUNCTION_NAME].join('/'),
     });
-    await copyFile(join(__dirname, '..', 'templates', 'ipx.js'), join(functionDirectory, functionName));
+    await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'ipx.js'), (0, pathe_1.join)(functionDirectory, functionName));
     const imagePath = imageconfig.path || '/_next/image';
     netlifyConfig.redirects.push({
         from: `${imagePath}*`,
         query: { url: ':url', w: ':width', q: ':quality' },
-        to: `${basePath}/${IMAGE_FUNCTION_NAME}/w_:width,q_:quality/:url`,
+        to: `${basePath}/${constants_1.IMAGE_FUNCTION_NAME}/w_:width,q_:quality/:url`,
         status: 301,
     }, {
-        from: `${basePath}/${IMAGE_FUNCTION_NAME}/*`,
-        to: `/.netlify/builders/${IMAGE_FUNCTION_NAME}`,
+        from: `${basePath}/${constants_1.IMAGE_FUNCTION_NAME}/*`,
+        to: `/.netlify/builders/${constants_1.IMAGE_FUNCTION_NAME}`,
         status: 200,
     });
     if (basePath) {
@@ -62,3 +67,4 @@ exports.setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCT
         });
     }
 };
+exports.setupImageFunction = setupImageFunction;

package/lib/helpers/redirects.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRedirects = void 0;
+const chalk_1 = require("chalk");
+const fs_extra_1 = require("fs-extra");
+const outdent_1 = require("outdent");
+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 }, }) => {
+    const { dynamicRoutes, routes: staticRoutes } = await (0, fs_extra_1.readJSON)((0, 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 = [];
+    let hasIsr = false;
+    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);
+        }
+        hasIsr = true;
+        isrRedirects.push(...(0, utils_1.netlifyRoutesForNextRoute)(dataRoute), ...(0, 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(...(0, utils_1.netlifyRoutesForNextRoute)(route));
+        dataRedirects.push(...(0, utils_1.netlifyRoutesForNextRoute)(dataRoute));
+    });
+    if (i18n) {
+        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
+    }
+    // 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 bypess pre-rendered pages
+    {
+        from: `${basePath}/*`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore The conditions type is incorrect
+        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: process.env.EXPERIMENTAL_ODB_TTL ? constants_1.ODB_FUNCTION_PATH : constants_1.HANDLER_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 });
+    if (hasIsr) {
+        console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
+        You have some pages that use ISR (pages that use getStaticProps with revalidate set), which is not currently fully-supported by this plugin. Be aware that results may be unreliable.
+      `));
+    }
+};
+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

@@ -18,7 +18,8 @@ exports.verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuil
     }
 };
 exports.checkForOldFunctions = async ({ functions }) => {
-    const oldFunctions = (await functions.list()).filter(({ name }) => name.startsWith('next_'));
+    const allOldFunctions = await functions.list();
+    const oldFunctions = allOldFunctions.filter(({ name }) => name.startsWith('next_'));
     if (oldFunctions.length !== 0) {
         console.log(yellowBright(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_".

package/lib/index.js

@@ -1,9 +1,10 @@
 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 { getNextConfig, configureHandlerFunctions } = require('./helpers/config');
+const { moveStaticPages, movePublicFiles, patchNextFiles, unpatchNextFiles } = require('./helpers/files');
 const { generateFunctions, setupImageFunction, generatePagesResolver } = require('./helpers/functions');
+const { generateRedirects } = require('./helpers/redirects');
 const { verifyNetlifyBuildVersion, checkNextSiteHasBuilt, checkForRootPublish, logBetaMessage, checkZipSize, checkForOldFunctions, } = require('./helpers/verification');
 /** @type import("@netlify/build").NetlifyPlugin */
 module.exports = {
@@ -21,11 +22,17 @@ module.exports = {
     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 });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = 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 });
+        await movePublicFiles({ appDir, outdir, publish });
+        if (process.env.EXPERIMENTAL_ODB_TTL) {
+            await 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'");
         }
@@ -35,14 +42,15 @@ module.exports = {
         await setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
         await generateRedirects({
             netlifyConfig,
-            basePath,
-            i18n,
+            nextConfig: { basePath, i18n, trailingSlash },
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions }, constants: { FUNCTIONS_DIST } }) {
+    async onPostBuild({ netlifyConfig, utils: { cache, functions, failBuild }, constants: { FUNCTIONS_DIST } }) {
         await saveCache({ cache, publish: netlifyConfig.build.publish });
         await checkForOldFunctions({ functions });
         await checkZipSize(join(FUNCTIONS_DIST, `${ODB_FUNCTION_NAME}.zip`));
+        const { basePath } = await getNextConfig({ publish: netlifyConfig.build.publish, failBuild });
+        await unpatchNextFiles(basePath);
     },
     onEnd() {
         logBetaMessage();

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,7 +45,8 @@ 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;
         // Next expects to be able to parse the query from the URL
@@ -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' && process.env.EXPERIMENTAL_ODB_TTL) {
+                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 */

package/lib/templates/getPageResolver.js

@@ -1,19 +1,27 @@
-const { posix: { resolve, join, relative }, } = require('path');
-const { outdent } = require('outdent');
-const slash = require('slash');
-const glob = require('tiny-glob');
-const { HANDLER_FUNCTION_NAME } = require('../constants');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageResolver = void 0;
+const path_1 = require("path");
+const outdent_1 = require("outdent");
+const slash_1 = __importDefault(require("slash"));
+const tiny_glob_1 = __importDefault(require("tiny-glob"));
+const constants_1 = require("../constants");
 // Generate a file full of require.resolve() calls for all the pages in the
 // build. This is used by the nft bundler to find all the pages.
-exports.getPageResolver = async ({ netlifyConfig, target }) => {
-    const functionDir = resolve(join('.netlify', 'functions', HANDLER_FUNCTION_NAME));
-    const root = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless', 'pages');
-    const pages = await glob('**/*.js', {
+const getPageResolver = async ({ netlifyConfig, target }) => {
+    const functionDir = path_1.posix.resolve(path_1.posix.join('.netlify', 'functions', constants_1.HANDLER_FUNCTION_NAME));
+    const root = path_1.posix.join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless', 'pages');
+    const pages = await (0, tiny_glob_1.default)('**/*.js', {
         cwd: root,
         dot: true,
     });
-    const pageFiles = pages.map((page) => `require.resolve('${relative(functionDir, join(root, slash(page)))}')`).sort();
-    return outdent `
+    const pageFiles = pages
+        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, (0, slash_1.default)(page)))}')`)
+        .sort();
+    return (0, outdent_1.outdent) `
     // This file is purely to allow nft to know about these pages. It should be temporary.
     exports.resolvePages = () => {
         try {
@@ -22,3 +30,4 @@ exports.getPageResolver = async ({ netlifyConfig, target }) => {
     }
   `;
 };
+exports.getPageResolver = getPageResolver;

package/lib/templates/handlerUtils.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextServer = exports.augmentFsModule = exports.getMultiValueHeaders = exports.getMaxAge = exports.downloadFile = void 0;
+const fs_1 = require("fs");
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const util_1 = require("util");
+const streamPipeline = (0, util_1.promisify)(stream_1.pipeline);
+const downloadFile = async (url, destination) => {
+    console.log(`Downloading ${url} to ${destination}`);
+    const httpx = url.startsWith('https') ? https_1.default : http_1.default;
+    await new Promise((resolve, reject) => {
+        const req = httpx.get(url, { timeout: 10000 }, (response) => {
+            if (response.statusCode < 200 || response.statusCode > 299) {
+                reject(new Error(`Failed to download ${url}: ${response.statusCode} ${response.statusMessage || ''}`));
+                return;
+            }
+            const fileStream = (0, fs_1.createWriteStream)(destination);
+            streamPipeline(response, fileStream)
+                .then(resolve)
+                .catch((error) => {
+                console.log(`Error downloading ${url}`, error);
+                reject(error);
+            });
+        });
+        req.on('error', (error) => {
+            console.log(`Error downloading ${url}`, error);
+            reject(error);
+        });
+    });
+};
+exports.downloadFile = downloadFile;
+const getMaxAge = (header) => {
+    const parts = header.split(',');
+    let maxAge;
+    for (const part of parts) {
+        const [key, value] = part.split('=');
+        if ((key === null || key === void 0 ? void 0 : key.trim()) === 's-maxage') {
+            maxAge = value === null || value === void 0 ? void 0 : value.trim();
+        }
+    }
+    if (maxAge) {
+        const result = Number.parseInt(maxAge);
+        return Number.isNaN(result) ? 0 : result;
+    }
+    return 0;
+};
+exports.getMaxAge = getMaxAge;
+const getMultiValueHeaders = (headers) => {
+    const multiValueHeaders = {};
+    for (const key of Object.keys(headers)) {
+        const header = headers[key];
+        if (Array.isArray(header)) {
+            multiValueHeaders[key] = header;
+        }
+        else {
+            multiValueHeaders[key] = [header];
+        }
+    }
+    return multiValueHeaders;
+};
+exports.getMultiValueHeaders = getMultiValueHeaders;
+const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
+    // Only do this if we have some static files moved to the CDN
+    if (staticManifest.length === 0) {
+        return;
+    }
+    // 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 Map(staticManifest);
+    const downloadPromises = new Map();
+    // Yes, you can cache stuff locally in a Lambda
+    const cacheDir = path_1.default.join((0, os_1.tmpdir)(), 'next-static-cache');
+    // Grab the real fs.promises.readFile...
+    const readfileOrig = promises.readFile;
+    const statsOrig = promises.stat;
+    // ...then money-patch it to see if it's requesting a CDN file
+    promises.readFile = (async (file, options) => {
+        const base = getBase();
+        // 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) && !(0, fs_1.existsSync)(file)) {
+                // This name is safe to use, because it's one that was already created by Next
+                const cacheFile = path_1.default.join(cacheDir, filePath);
+                const url = `${base}/${staticFiles.get(filePath)}`;
+                // If it's already downloading we can wait for it to finish
+                if (downloadPromises.has(url)) {
+                    await downloadPromises.get(url);
+                }
+                // Have we already cached it? We download every time if running locally to avoid staleness
+                if ((!(0, fs_1.existsSync)(cacheFile) || process.env.NETLIFY_DEV) && base) {
+                    await promises.mkdir(path_1.default.dirname(cacheFile), { recursive: true });
+                    try {
+                        // Append the path to our host and we can load it like a regular page
+                        const downloadPromise = (0, exports.downloadFile)(url, cacheFile);
+                        downloadPromises.set(url, downloadPromise);
+                        await downloadPromise;
+                    }
+                    finally {
+                        downloadPromises.delete(url);
+                    }
+                }
+                // Return the cache file
+                return readfileOrig(cacheFile, options);
+            }
+        }
+        return readfileOrig(file, options);
+    });
+    promises.stat = (async (file, options) => {
+        // We only care about page files
+        if (file.startsWith(pageRoot)) {
+            // We only want the part after `pages/`
+            const cacheFile = path_1.default.join(cacheDir, file.slice(pageRoot.length + 1));
+            if ((0, fs_1.existsSync)(cacheFile)) {
+                return statsOrig(cacheFile, options);
+            }
+        }
+        return statsOrig(file, options);
+    });
+};
+exports.augmentFsModule = augmentFsModule;
+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
+    }
+    if (!NextServer) {
+        try {
+            // next < 11.0.1
+            // eslint-disable-next-line node/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;

package/lib/templates/ipx.js

@@ -1,8 +1,12 @@
-const { createIPXHandler } = require('@netlify/ipx');
-// Injected at build time
-// eslint-disable-next-line import/no-unresolved, node/no-missing-require
-const { basePath, domains } = require('./imageconfig.json');
-exports.handler = createIPXHandler({
-    basePath,
-    domains,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+/* eslint-disable node/no-missing-import, import/no-unresolved, @typescript-eslint/ban-ts-comment  */
+const ipx_1 = require("@netlify/ipx");
+// @ts-ignore Injected at build time
+const imageconfig_json_1 = require("./imageconfig.json");
+exports.handler = (0, ipx_1.createIPXHandler)({
+    basePath: imageconfig_json_1.basePath,
+    domains: imageconfig_json_1.domains,
 });
+/* eslint-enable node/no-missing-import, import/no-unresolved, @typescript-eslint/ban-ts-comment  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.0.0-beta.9",
+  "version": "4.0.0-rc.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -8,10 +8,10 @@
     "manifest.yml"
   ],
   "scripts": {
-    "build:demo": "next build demo",
+    "build:demo": "next build demos/default",
     "cy:open": "cypress open --config-file cypress/config/all.json",
-    "cy:run": "cypress run --config-file ../cypress/config/ci.json",
-    "dev:demo": "next dev demo",
+    "cy:run": "cypress run --config-file ../../cypress/config/ci.json",
+    "dev:demo": "next dev demos/default",
     "format": "run-s format:check-fix:*",
     "format:ci": "run-s format:check:*",
     "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
@@ -26,6 +26,8 @@
     "publish:test": "npm test",
     "test": "run-s build build:demo test:jest",
     "test:jest": "jest",
+    "test:jest:update": "jest --updateSnapshot",
+    "test:update": "run-s build build:demo test:jest:update",
     "prepare": "npm run build",
     "clean": "rimraf lib",
     "build": "tsc",
@@ -52,7 +54,7 @@
   },
   "homepage": "https://github.com/netlify/netlify-plugin-nextjs#readme",
   "dependencies": {
-    "@netlify/functions": "^0.9.0",
+    "@netlify/functions": "^0.10.0",
     "@netlify/ipx": "^0.0.7",
     "@vercel/node": "^1.11.2-canary.4",
     "chalk": "^4.1.2",
@@ -72,16 +74,17 @@
   "devDependencies": {
     "@babel/core": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
-    "@netlify/build": "^18.25.1",
-    "@netlify/eslint-config-node": "^3.3.7",
+    "@babel/preset-typescript": "^7.16.0",
+    "@netlify/build": "^20.0.4",
+    "@netlify/eslint-config-node": "^3.3.11",
     "@testing-library/cypress": "^8.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.0.2",
     "@types/mocha": "^9.0.0",
     "babel-jest": "^27.2.5",
     "cpy": "^8.1.2",
-    "cypress": "^8.5.0",
-    "eslint-config-next": "^11.0.0",
+    "cypress": "^9.0.0",
+    "eslint-config-next": "^12.0.0",
     "husky": "^4.3.0",
     "jest": "^27.0.0",
     "netlify-plugin-cypress": "^2.2.0",