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

package/README.md

@@ -2,8 +2,8 @@
 
 # Essential Next.js Build Plugin (beta)
 
-
-:warning: This is the beta version of the Essential Next.js plugin. For the stable version, see [Essential Next.js plugin v3](https://github.com/netlify/netlify-plugin-nextjs/tree/v3#readme) :warning:
+:warning: This is the beta version of the Essential Next.js plugin. For the stable version, refer to
+[Essential Next.js plugin v3](https://github.com/netlify/netlify-plugin-nextjs/tree/v3#readme) :warning:
 
 <p align="center">
   <a aria-label="npm version" href="https://www.npmjs.com/package/@netlify/plugin-nextjs">
@@ -16,16 +16,19 @@
 
 ## What's new in this version
 
-Version 4 is a complete rewrite of the Essential Next.js plugin. For full details of everything that's new, see [the v4 release notes](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/release-notes/v4.md)
+Version 4 is a complete rewrite of the Essential Next.js plugin. For full details of everything that's new, check out
+[the v4 release notes](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/release-notes/v4.md)
 
 ## Installing the beta
 
-
 - Install the module:
+
 ```shell
 npm install -D @netlify/plugin-nextjs@beta
 ```
-- Change the `publish` directory to `.next`  and add the plugin to `netlify.toml` if not already installed:
+
+- Change the `publish` directory to `.next` and add the plugin to `netlify.toml` if not already installed:
+
 ```toml
 [build]
 publish = ".next"
@@ -34,14 +37,27 @@ publish = ".next"
 package = "@netlify/plugin-nextjs"
 ```
 
-If you previously set `target: "serverless"` or a custom `distDir` in your `next.config.js`, or set `node_bundler` or `external_node_modules` in your `netlify.toml` these are no longer needed and can be removed. 
+If you previously set a custom `distDir` in your `next.config.js`, or set `node_bundler` or `external_node_modules` in
+your `netlify.toml` these are no longer needed and can be removed.
+
+The `serverless` and `experimental-serverless-trace` targets are deprecated in Next 12, and all builds with this plugin
+will now use the default `server` target. If you previously set the target in your `next.config.js`, you should remove
+it.
+
+If you are using a monorepo you will need to change `publish` to point to the full path to the built `.next` directory,
+which may be in a subdirectory. If you have changed your `distDir` then it will need to match that.
 
-The `serverless` and `experimental-serverless-trace` targets are deprecated in Next 12, and all builds with this plugin will now use the default `server` target.
+If you are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`.
 
-If you are using a monorepo you will need to change `publish` to point to the full path to the built `.next` directory, which may be in a subdirectory. If you have changed your `distDir` then it will need to match that. 
+If you currently use redirects or rewrites on your site, see
+[the Rewrites and Redirects guide](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/redirects-rewrites.md)
+for information on changes to how they are handled in this version.
 
-If you are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`. 
+If you want to use Next 12's beta Middleware feature, this will mostly work as expected but please
+[read the docs on some caveats and workarounds](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/middleware.md)
+that are currently needed.
 
 ## Beta feedback
 
-Please share any thoughts, feedback or questions about the beta [in our discussion](https://github.com/netlify/netlify-plugin-nextjs/discussions/706).
+Please share any thoughts, feedback or questions about the beta
+[in our discussion](https://github.com/netlify/netlify-plugin-nextjs/discussions/706).

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,92 +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 });
-    }
-    const staticManifest = join(netlifyConfig.build.publish, 'static-manifest.json');
-    if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES && existsSync(staticManifest)) {
-        // Static page files need to have a forced redirect for preview mode. Otherwise it's non-forced
-        const staticFiles = await readJSON(staticManifest);
-        netlifyConfig.redirects.push(...staticFiles.map((file) => ({
-            from: `${basePath}/${file}`,
-            to: HANDLER_FUNCTION_PATH,
-            status: 200,
-            force: true,
-            conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
-        })));
-    }
-    // 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'] },
-    }, ...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 };
@@ -95,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`);
@@ -127,3 +58,4 @@ exports.configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) =>
         });
     });
 };
+exports.configureHandlerFunctions = configureHandlerFunctions;

package/lib/helpers/files.js

@@ -1,51 +1,258 @@
-//  @ts-check
+/* eslint-disable max-lines */
 const { cpus } = require('os');
-const { existsSync, readJson, move, cpSync, copy, writeJson } = require('fs-extra');
+const { yellowBright } = require('chalk');
+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');
 const { join } = require('pathe');
 const slash = require('slash');
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
 const isDynamicRoute = (route) => TEST_ROUTE.test(route);
-exports.moveStaticPages = async ({ netlifyConfig, target, i18n, failBuild }) => {
+const stripLocale = (rawPath, locales = []) => {
+    const [locale, ...segments] = rawPath.split('/');
+    if (locales.includes(locale)) {
+        return segments.join('/');
+    }
+    return rawPath;
+};
+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 root = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless', 'pages');
+    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');
+    if (existsSync(manifestPath)) {
+        const manifest = await readJson(manifestPath);
+        if (manifest === null || manifest === void 0 ? void 0 : manifest.middleware) {
+            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}'], {
         cwd: root,
         dot: true,
     });
+    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);
+        // If a file matches middleware it can't be offloaded to the CDN, and needs to stay at the origin to be served by next/server
+        if (middlewarePath) {
+            matchingMiddleware.add(middlewarePath);
+            matchedPages.add(rawPath);
+            return;
+        }
         return limit(moveFile, filePath);
     });
     await Promise.all(promises);
     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.
+      `));
+        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) {
+            console.log(outdent `
+          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;