@netlify/plugin-nextjs 4.0.0-beta.12 → 4.0.0-beta.13

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.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,8 @@ 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.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,136 +1,22 @@
-/* eslint-disable max-lines */
-const { yellowBright } = require('chalk');
-const { readJSON, existsSync } = require('fs-extra');
-const { outdent } = require('outdent');
-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, routes: staticRoutes } = await readJSON(join(netlifyConfig.build.publish, 'prerender-manifest.json'));
-    netlifyConfig.redirects.push(...HIDDEN_PATHS.map((path) => ({
-        from: `${basePath}${path}`,
-        to: '/404.html',
-        status: 404,
-        force: true,
-    })));
-    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(...getNetlifyRoutes(dataRoute), ...getNetlifyRoutes(route));
-    });
-    dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
-        // Add redirects if fallback is "null" (aka blocking) or true/a string
-        if (fallback === false) {
-            return;
-        }
-        pageRedirects.push(...getNetlifyRoutes(route));
-        dataRedirects.push(...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(
-    // 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: HANDLER_FUNCTION_PATH,
-        status: 200,
-    }, {
-        from: `${basePath}/api/*`,
-        to: HANDLER_FUNCTION_PATH,
-        status: 200,
-    }, 
-    // Preview mode gets forced to the function, to bypess pre-rendered pages
-    {
-        from: `${basePath}/*`,
-        to: 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: process.env.EXPERIMENTAL_ODB_TTL ? ODB_FUNCTION_PATH : 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: ODB_FUNCTION_PATH,
-        status: 200,
-    })), 
-    // ...then all the other fallback pages
-    ...pageRedirects.map((redirect) => ({
-        from: `${basePath}${redirect}`,
-        to: ODB_FUNCTION_PATH,
-        status: 200,
-    })), 
-    // Everything else is handled by the regular function
-    { from: `${basePath}/*`, to: HANDLER_FUNCTION_PATH, status: 200 });
-    if (hasIsr) {
-        console.log(yellowBright(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.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 };
@@ -139,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('.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) => `!${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`);
@@ -171,4 +58,4 @@ exports.configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) =>
         });
     });
 };
-/* eslint-enable max-lines */
+exports.configureHandlerFunctions = configureHandlerFunctions;

package/lib/helpers/files.js

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */
 const { cpus } = require('os');
 const { yellowBright } = require('chalk');
-const { existsSync, readJson, move, cpSync, copy, writeJson, readFile, writeFile } = 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');
@@ -49,6 +49,9 @@ 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');
@@ -70,10 +73,14 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
         }
     });
     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);
+        filesManifest[file] = target;
+        const dest = join(netlifyConfig.build.publish, target);
         try {
             await move(source, dest);
         }
@@ -169,13 +176,22 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
         }
     }
     // 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 }) => {

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}${trailingSlash ? '/' : ''}`,
+        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}/`,
+            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/requiredServerFilesType.js

@@ -0,0 +1,8 @@
+"use strict";
+/* eslint-disable eslint-comments/disable-enable-pair, @typescript-eslint/no-empty-interface, no-use-before-define */
+/**
+ * This was generated using @see {@link https://quicktype.io/}, and using the
+ * demo's {@code demos/default/.next/required-server-files.json} file. I was
+ * unable to find any types for this file so instead this was manually generated
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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/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 { 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,7 +22,10 @@ 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 } = await getNextConfig({
+            publish,
+            failBuild,
+        });
         configureHandlerFunctions({ netlifyConfig, ignore, publish: relative(process.cwd(), publish) });
         await generateFunctions(constants, appDir);
         await generatePagesResolver({ netlifyConfig, target, constants });
@@ -38,8 +42,7 @@ module.exports = {
         await setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
         await generateRedirects({
             netlifyConfig,
-            basePath,
-            i18n,
+            nextConfig: { basePath, i18n, trailingSlash },
         });
     },
     async onPostBuild({ netlifyConfig, utils: { cache, functions, failBuild }, constants: { FUNCTIONS_DIST } }) {

package/lib/templates/getHandler.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines-per-function */
 const { promises, existsSync } = require('fs');
 const { Server } = require('http');
 const { tmpdir } = require('os');
@@ -27,11 +28,14 @@ const makeHandler = () =>
         // 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);
+        const staticFiles = new Map(staticManifest);
+        const downloadPromises = new Map();
+        const statsCache = new Map();
         // 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;
+        const statsOrig = promises.stat;
         // ...then money-patch it to see if it's requesting a CDN file
         promises.readFile = async (file, options) => {
             // We only care about page files
@@ -42,12 +46,23 @@ const makeHandler = () =>
                 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
+                    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 ((!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}`;
-                        await downloadFile(url, cacheFile);
+                        try {
+                            // Append the path to our host and we can load it like a regular page
+                            const downloadPromise = downloadFile(url, cacheFile);
+                            downloadPromises.set(url, downloadPromise);
+                            await downloadPromise;
+                        }
+                        finally {
+                            downloadPromises.delete(url);
+                        }
                     }
                     // Return the cache file
                     return readfileOrig(cacheFile, options);
@@ -55,6 +70,17 @@ const makeHandler = () =>
             }
             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.join(cacheDir, file.slice(pageRoot.length + 1));
+                if (existsSync(cacheFile)) {
+                    return statsOrig(cacheFile, options);
+                }
+            }
+            return statsOrig(file, options);
+        };
     }
     let NextServer;
     try {
@@ -163,3 +189,4 @@ exports.handler = ${isODB
     : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
 `;
 module.exports = getHandler;
+/* eslint-enable max-lines-per-function */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.0.0-beta.12",
+  "version": "4.0.0-beta.13",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -75,8 +75,8 @@
     "@babel/core": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
     "@babel/preset-typescript": "^7.16.0",
-    "@netlify/build": "^19.0.7",
-    "@netlify/eslint-config-node": "^3.3.9",
+    "@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",