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

package/README.md

@@ -1,6 +1,9 @@
 ![Next.js on Netlify Build Plugin](next-on-netlify.png)
 
-# Essential Next.js Build Plugin
+# Essential Next.js Build Plugin (beta)
+
+: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">
@@ -11,72 +14,50 @@
   </a>
 </p>
 
-This build plugin is a utility for supporting Next.js on Netlify. To enable server-side rendering and other framework-specific features in your Next.js application on Netlify, you will need to install this plugin for your app.
-
-## Table of Contents
-
-- [Installation and Configuration](#installation-and-configuration)
-- [Docs](#docs)
-- [Credits](#credits)
-
-## Installation and Configuration
-
-### For new Next.js sites
-
-As of v3.0.0, all new sites deployed to Netlify with Next.js will automatically install this plugin for a seamless experience deploying Next.js on Netlify!
-
-This means that you don't have to do anything — just build and deploy your site to Netlify as usual and we'll handle the rest.
-
-You're able to [remove the plugin](https://docs.netlify.com/configure-builds/build-plugins/#remove-a-plugin) at any time by visiting the **Plugins** tab for your site in the Netlify UI.
+## What's new in this version
 
-### For existing Next.js sites
+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)
 
-### UI Installation
+## Installing the beta
 
-If your Next.js project was already deployed to Netlify pre-3.0.0, use the Netlify UI to [install the Essential Next.js Build Plugin](http://app.netlify.com/plugins/@netlify/plugin-nextjs/install) in a few clicks.
+- Install the module:
 
-### Manual installation
+```shell
+npm install -D @netlify/plugin-nextjs@beta
+```
 
-1\. Create a `netlify.toml` in the root of your project. Your file should include the plugins section below:
+- Change the `publish` directory to `.next` and add the plugin to `netlify.toml` if not already installed:
 
 ```toml
 [build]
-  command = "npm run build"
-  publish = "out"
+publish = ".next"
 
 [[plugins]]
-  package = "@netlify/plugin-nextjs"
+package = "@netlify/plugin-nextjs"
 ```
 
-Note: the plugin does not run for statically exported Next.js sites (aka sites that use `next export`). To use the plugin, you should use the `[build]` config in the .toml snippet above. Be sure to exclude `next export` from your build script. 
-The plugin will attempt to detect if the site uses static export or Storybook, and will not run for either. If you want to disable the auto-detection, you can set the `NEXT_PLUGIN_FORCE_RUN` environment variable to `true` or `false`. 
-Setting it to `true` or `1` will mean the plugin always runs, and setting it to `false` or `0` will mean it never runs. If unset, auto-detection will be used. This variable should be set in the Netlify UI or in the `netlify.toml` file.
-
-2\. From your project's base directory, use `npm`, `yarn`, or any other Node.js package manager to add this plugin to `dependencies` in `package.json`.
+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.
 
-```
-npm install --save @netlify/plugin-nextjs
-```
+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.
 
-or
-
-```
-yarn add @netlify/plugin-nextjs
-```
+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.
 
-Read more about [file-based plugin installation](https://docs.netlify.com/configure-builds/build-plugins/#file-based-installation) in our docs.
+If you are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`.
 
-## Docs
+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.
 
-- [CLI Usage](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/cli-usage.md)
-- [Custom Netlify Functions](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/custom-functions.md)
-- [Image Handling](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/image-handling.md)
-- [Monorepos and Nx](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/monorepos.md)
-- [Custom Netlify Redirects](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/custom-redirects.md)
-- [Local Files in Runtime](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/local-files-in-runtime.md)
-- [FAQ](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/faq.md)
-- [Caveats](https://github.com/netlify/netlify-plugin-nextjs/tree/main/docs/caveats.md)
+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.
 
-## Credits
+## Beta feedback
 
-This package extends the project [next-on-netlify](https://github.com/netlify/next-on-netlify), authored originally by [Finn Woelm](https://github.com/finnwoelm).
+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

@@ -0,0 +1,21 @@
+const HANDLER_FUNCTION_NAME = '___netlify-handler';
+const ODB_FUNCTION_NAME = '___netlify-odb-handler';
+const IMAGE_FUNCTION_NAME = '_ipx';
+// These are paths in .next that shouldn't be publicly accessible
+const HIDDEN_PATHS = [
+    '/cache/*',
+    '/server/*',
+    '/serverless/*',
+    '/traces',
+    '/routes-manifest.json',
+    '/build-manifest.json',
+    '/prerender-manifest.json',
+    '/react-loadable-manifest.json',
+    '/BUILD_ID',
+];
+module.exports = {
+    HIDDEN_PATHS,
+    IMAGE_FUNCTION_NAME,
+    HANDLER_FUNCTION_NAME,
+    ODB_FUNCTION_NAME,
+};

package/lib/helpers/cache.js

@@ -0,0 +1,20 @@
+const { posix: { join }, } = require('path');
+exports.restoreCache = async ({ cache, publish }) => {
+    const cacheDir = join(publish, 'cache');
+    if (await cache.restore(cacheDir)) {
+        console.log('Next.js cache restored.');
+    }
+    else {
+        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');
+    if (await cache.save(cacheDir, { digests: [buildManifest] })) {
+        console.log('Next.js cache saved.');
+    }
+    else {
+        console.log('No Next.js cache to save.');
+    }
+};

package/lib/helpers/config.js

@@ -0,0 +1,174 @@
+/* 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');
+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 }) {
+    try {
+        const { config, appDir, ignore } = await readJSON(join(publish, 'required-server-files.json'));
+        if (!config) {
+            return failBuild('Error loading your Next config');
+        }
+        return { ...config, appDir, ignore };
+    }
+    catch (error) {
+        return failBuild('Error loading your Next config', { error });
+    }
+};
+const resolveModuleRoot = (moduleName) => {
+    try {
+        return dirname(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 = [] }) => {
+    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) => {
+        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)}`));
+        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`);
+        }
+        DEFAULT_EXCLUDED_MODULES.forEach((moduleName) => {
+            const moduleRoot = resolveModuleRoot(moduleName);
+            if (moduleRoot) {
+                netlifyConfig.functions[functionName].included_files.push(`!${moduleRoot}/**/*`);
+            }
+        });
+    });
+};
+/* eslint-enable max-lines */

package/lib/helpers/files.js

@@ -0,0 +1,236 @@
+/* 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 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);
+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 outputDir = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
+    const root = join(outputDir, 'pages');
+    // 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 moveFile = async (file) => {
+        const source = join(root, file);
+        files.push(file);
+        const dest = join(netlifyConfig.build.publish, file);
+        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);
+    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 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');
+    if (existsSync(publicDir)) {
+        await copy(publicDir, `${publish}/`);
+    }
+};
+/* eslint-enable max-lines */

package/lib/helpers/functions.js

@@ -0,0 +1,65 @@
+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) => {
+    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 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'));
+        await copyFile(join(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), join(functionsDir, func, 'handlerUtils.js'));
+    };
+    await writeHandler(HANDLER_FUNCTION_NAME, false);
+    await writeHandler(ODB_FUNCTION_NAME, true);
+};
+/**
+ * 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 functionsPath = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
+    const jsSource = await getPageResolver({
+        netlifyConfig,
+        target,
+    });
+    await writeFile(join(functionsPath, ODB_FUNCTION_NAME, 'pages.js'), jsSource);
+    await writeFile(join(functionsPath, HANDLER_FUNCTION_NAME, 'pages.js'), jsSource);
+};
+// 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 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'), {
+        ...imageconfig,
+        basePath: [basePath, IMAGE_FUNCTION_NAME].join('/'),
+    });
+    await copyFile(join(__dirname, '..', 'templates', 'ipx.js'), 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`,
+        status: 301,
+    }, {
+        from: `${basePath}/${IMAGE_FUNCTION_NAME}/*`,
+        to: `/.netlify/builders/${IMAGE_FUNCTION_NAME}`,
+        status: 200,
+    });
+    if (basePath) {
+        // next/image generates image static URLs that still point at the site root
+        netlifyConfig.redirects.push({
+            from: '/_next/static/image/*',
+            to: '/static/image/:splat',
+            status: 200,
+        });
+    }
+};