@netlify/plugin-nextjs 3.9.1 → 4.0.0-beta.3

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, see [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,31 @@
   </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.
-
-### For existing Next.js sites
-
-### UI Installation
 
-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.
+## Installing the beta
 
-### Manual installation
-
-1\. Create a `netlify.toml` in the root of your project. Your file should include the plugins section below:
 
+- 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:
 ```toml
 [build]
-  command = "npm run build"
-  publish = "out"
+publish = ".next"
 
 [[plugins]]
-  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`.
-
-```
-npm install --save @netlify/plugin-nextjs
+package = "@netlify/plugin-nextjs"
 ```
 
-or
-
-```
-yarn add @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. 
 
-Read more about [file-based plugin installation](https://docs.netlify.com/configure-builds/build-plugins/#file-based-installation) in our docs.
+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.
 
-## Docs
+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. 
 
-- [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 are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`. 
 
-## 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,115 @@
+// @ts-check
+const { readJSON } = require('fs-extra');
+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 } = await readJSON(join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    const redirects = [];
+    netlifyConfig.redirects.push(...HIDDEN_PATHS.map((path) => ({
+        from: `${basePath}${path}`,
+        to: '/404.html',
+        status: 404,
+        force: true,
+    })));
+    const dynamicRouteEntries = Object.entries(dynamicRoutes);
+    dynamicRouteEntries.sort((a, b) => a[0].localeCompare(b[0]));
+    dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
+        // Add redirects if fallback is "null" (aka blocking) or true/a string
+        if (fallback === false) {
+            return;
+        }
+        redirects.push(...getNetlifyRoutes(route), ...getNetlifyRoutes(dataRoute));
+    });
+    if (i18n) {
+        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
+    }
+    // This is only used in prod, so dev uses `next dev` directly
+    netlifyConfig.redirects.push({ from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 }, {
+        from: `${basePath}/*`,
+        to: HANDLER_FUNCTION_PATH,
+        status: 200,
+        force: true,
+        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 }) {
+    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;
+    }
+};
+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(`${publish}/server/**`, `${publish}/serverless/**`, `${publish}/*.json`, `${publish}/BUILD_ID`, ...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`);
+        }
+        const sharpRoot = resolveModuleRoot('sharp');
+        if (sharpRoot) {
+            netlifyConfig.functions[functionName].included_files.push(`!${sharpRoot}/**/*`);
+        }
+    });
+};

package/lib/helpers/files.js

@@ -0,0 +1,48 @@
+//  @ts-check
+const { existsSync, readJson, move, cpSync, copy, writeJson } = require('fs-extra');
+const pLimit = require('p-limit');
+const { join } = require('pathe');
+const TEST_ROUTE = /\/\[[^/]+?](?=\/|$)/;
+const isDynamicRoute = (route) => TEST_ROUTE.test(route);
+exports.moveStaticPages = async ({ netlifyConfig, target, i18n, failBuild }) => {
+    const root = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
+    const pagesManifestPath = join(root, 'pages-manifest.json');
+    if (!existsSync(pagesManifestPath)) {
+        failBuild(`Could not find pages manifest at ${pagesManifestPath}`);
+    }
+    const files = [];
+    const moveFile = async (file) => {
+        const source = join(root, file);
+        // Trim the initial "pages"
+        const filePath = file.slice(6);
+        files.push(filePath);
+        const dest = join(netlifyConfig.build.publish, filePath);
+        await move(source, dest);
+    };
+    const pagesManifest = await readJson(pagesManifestPath);
+    // Arbitrary limit of 10 concurrent file moves
+    const limit = pLimit(10);
+    const promises = Object.entries(pagesManifest).map(async ([route, filePath]) => {
+        if (isDynamicRoute(route) ||
+            !(filePath.endsWith('.html') || filePath.endsWith('.json')) ||
+            filePath.endsWith('/404.html') ||
+            filePath.endsWith('/500.html')) {
+            return;
+        }
+        return limit(moveFile, filePath);
+    });
+    await Promise.all(promises);
+    console.log(`Moved ${files.length} page files`);
+    // 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
+        await copy(join(netlifyConfig.build.publish, i18n.defaultLocale), `${netlifyConfig.build.publish}/`);
+    }
+};
+exports.movePublicFiles = async ({ appDir, publish }) => {
+    const publicDir = join(appDir, 'public');
+    if (existsSync(publicDir)) {
+        await copy(publicDir, `${publish}/`);
+    }
+};

package/lib/helpers/functions.js

@@ -0,0 +1,64 @@
+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 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,
+        });
+    }
+};

package/lib/helpers/verification.js

@@ -0,0 +1,79 @@
+const { existsSync, promises } = require('fs');
+const path = require('path');
+const { relative } = require('path');
+const { yellowBright, greenBright, blueBright, redBright } = require('chalk');
+const { async: StreamZip } = require('node-stream-zip');
+const outdent = require('outdent');
+const prettyBytes = require('pretty-bytes');
+const { satisfies } = require('semver');
+// This is when nft support was added
+const REQUIRED_BUILD_VERSION = '>=18.16.0';
+exports.verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild }) => {
+    // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
+    if (IS_LOCAL && !satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
+        return failBuild(outdent `
+      This version of the Essential Next.js plugin requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
+      You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"
+    `);
+    }
+};
+exports.checkNextSiteHasBuilt = ({ publish, failBuild }) => {
+    if (!existsSync(path.join(publish, 'BUILD_ID'))) {
+        return failBuild(outdent `
+      The directory "${path.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory. 
+      In most cases it should be set to the site's ".next" directory path, unless you have chosen a custom "distDir" in your Next config. 
+      If you are using "next export" then the Essential Next.js plugin should be removed. See https://ntl.fyi/remove-plugin for details.
+      `);
+    }
+    if (existsSync(path.join(publish, 'export-detail.json'))) {
+        failBuild(outdent `
+      Detected that "next export" was run, but site is incorrectly publishing the ".next" directory.
+      This plugin is not needed for "next export" so should be removed, and publish directory set to "out".
+      See https://ntl.fyi/remove-plugin for more details on how to remove this plugin.`);
+    }
+};
+exports.checkForRootPublish = ({ publish, failBuild }) => {
+    if (path.resolve(publish) === path.resolve('.')) {
+        failBuild(outdent `
+      Your publish directory is pointing to the base directory of your site. This is not supported for Next.js sites, and is probably a mistake. 
+      In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config, or the Next site is in a subdirectory.`);
+    }
+};
+// 50MB, which is the documented max, though the hard max seems to be higher
+const LAMBDA_MAX_SIZE = 1024 * 1024 * 50;
+exports.checkZipSize = async (file, maxSize = LAMBDA_MAX_SIZE) => {
+    if (!existsSync(file)) {
+        console.warn(`Could not check zip size because ${file} does not exist`);
+        return;
+    }
+    const size = await promises.stat(file).then(({ size }) => size);
+    if (size < maxSize) {
+        return;
+    }
+    // We don't fail the build, because the actual hard max size is larger so it might still succeed
+    console.log(redBright(outdent `
+
+    The function zip ${yellowBright(relative(process.cwd(), file))} size is ${prettyBytes(size)}, which is larger than the maximum supported size of ${prettyBytes(maxSize)}.
+    There are a few reasons this could happen. You may have accidentally bundled a large dependency, or you might have a
+    large number of pre-rendered pages included.
+  
+    `));
+    const zip = new StreamZip({ file });
+    console.log(`Contains ${await zip.entriesCount} files`);
+    const sortedFiles = Object.values(await zip.entries()).sort((a, b) => b.size - a.size);
+    const largest = {};
+    for (let i = 0; i < 10 && i < sortedFiles.length; i++) {
+        largest[`${i + 1}`] = {
+            File: sortedFiles[i].name,
+            'Compressed Size': prettyBytes(sortedFiles[i].compressedSize),
+            'Uncompressed Size': prettyBytes(sortedFiles[i].size),
+        };
+    }
+    console.log(yellowBright `\n\nThese are the largest files in the zip:`);
+    console.table(largest);
+    console.log(greenBright `\n\nFor more information on fixing this, see ${blueBright `https://ntl.fyi/large-next-functions`}`);
+};
+exports.logBetaMessage = () => console.log(greenBright(outdent `
+        Thank you for trying the Essential Next.js beta plugin. 
+        Please share feedback (both good and bad) at ${blueBright `https://ntl.fyi/next-beta-feedback`}
+      `));

package/lib/index.js

@@ -0,0 +1,47 @@
+// @ts-check
+const { join, relative } = require('path');
+const { copy, existsSync } = require('fs-extra');
+const { ODB_FUNCTION_NAME } = require('./constants');
+const { restoreCache, saveCache } = require('./helpers/cache');
+const { getNextConfig, configureHandlerFunctions, generateRedirects } = require('./helpers/config');
+const { moveStaticPages, movePublicFiles } = require('./helpers/files');
+const { generateFunctions, setupImageFunction, generatePagesResolver } = require('./helpers/functions');
+const { verifyNetlifyBuildVersion, checkNextSiteHasBuilt, checkForRootPublish, logBetaMessage, checkZipSize, } = require('./helpers/verification');
+module.exports = {
+    async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
+        var _a;
+        logBetaMessage();
+        const { publish } = netlifyConfig.build;
+        checkForRootPublish({ publish, failBuild });
+        verifyNetlifyBuildVersion({ failBuild, ...constants });
+        await restoreCache({ cache, publish });
+        (_a = netlifyConfig.build).environment || (_a.environment = {});
+        // eslint-disable-next-line unicorn/consistent-destructuring
+        netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
+    },
+    async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
+        const { publish } = netlifyConfig.build;
+        checkNextSiteHasBuilt({ publish, failBuild });
+        const { appDir, basePath, i18n, images, target, ignore } = await getNextConfig({ publish, failBuild });
+        configureHandlerFunctions({ netlifyConfig, ignore, publish: relative(process.cwd(), publish) });
+        await generateFunctions(constants, appDir);
+        await generatePagesResolver({ netlifyConfig, target, constants });
+        await movePublicFiles({ appDir, publish });
+        if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES) {
+            await moveStaticPages({ target, failBuild, netlifyConfig, i18n });
+        }
+        await setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
+        await generateRedirects({
+            netlifyConfig,
+            basePath,
+            i18n,
+        });
+    },
+    async onPostBuild({ netlifyConfig, utils: { cache }, constants }) {
+        await saveCache({ cache, publish: netlifyConfig.build.publish });
+        await checkZipSize(join(process.cwd(), constants.FUNCTIONS_DIST, `${ODB_FUNCTION_NAME}.zip`));
+    },
+    onEnd() {
+        logBetaMessage();
+    },
+};

package/lib/templates/getHandler.js

@@ -0,0 +1,164 @@
+const { promises, createWriteStream, existsSync } = require('fs');
+const { Server } = require('http');
+const { tmpdir } = require('os');
+const path = require('path');
+const { promisify } = require('util');
+const streamPipeline = promisify(require('stream').pipeline);
+const { Bridge } = require('@vercel/node/dist/bridge');
+const fetch = require('node-fetch');
+const makeHandler = () => 
+// We return a function and then call `toString()` on it to serialise it as the launcher function
+(conf, app, pageRoot, staticManifest = []) => {
+    // This is just so nft knows about the page entrypoints. It's not actually used
+    try {
+        // eslint-disable-next-line node/no-missing-require
+        require.resolve('./pages.js');
+    }
+    catch { }
+    // Set during the request as it needs the host header. Hoisted so we can define the function once
+    let base;
+    // Only do this if we have some static files moved to the CDN
+    if (staticManifest.length !== 0) {
+        // These are static page files that have been removed from the function bundle
+        // In most cases these are served from the CDN, but for rewrites Next may try to read them
+        // from disk. We need to intercept these and load them from the CDN instead
+        // Sadly the only way to do this is to monkey-patch fs.promises. Yeah, I know.
+        const staticFiles = new Set(staticManifest);
+        // Yes, you can cache stuff locally in a Lambda
+        const cacheDir = path.join(tmpdir(), 'next-static-cache');
+        // Grab the real fs.promises.readFile...
+        const readfileOrig = promises.readFile;
+        // ...then money-patch it to see if it's requesting a CDN file
+        promises.readFile = async (file, options) => {
+            // We only care about page files
+            if (file.startsWith(pageRoot)) {
+                // We only want the part after `pages/`
+                const filePath = file.slice(pageRoot.length + 1);
+                // Is it in the CDN and not local?
+                if (staticFiles.has(filePath) && !existsSync(file)) {
+                    // This name is safe to use, because it's one that was already created by Next
+                    const cacheFile = path.join(cacheDir, filePath);
+                    // Have we already cached it? We ignore the cache if running locally to avoid staleness
+                    if ((!existsSync(cacheFile) || process.env.NETLIFY_DEV) && base) {
+                        await promises.mkdir(path.dirname(cacheFile), { recursive: true });
+                        // Append the path to our host and we can load it like a regular page
+                        const url = `${base}/${filePath}`;
+                        console.log(`Downloading ${url} to ${cacheFile}`);
+                        const response = await fetch(url);
+                        if (!response.ok) {
+                            // Next catches this and returns it as a not found file
+                            throw new Error(`Failed to fetch ${url}`);
+                        }
+                        // Stream it to disk
+                        await streamPipeline(response.body, createWriteStream(cacheFile));
+                    }
+                    // Return the cache file
+                    return readfileOrig(cacheFile, options);
+                }
+            }
+            return readfileOrig(file, options);
+        };
+    }
+    let NextServer;
+    try {
+        // next >= 11.0.1. Yay breaking changes in patch releases!
+        NextServer = require('next/dist/server/next-server').default;
+    }
+    catch (error) {
+        if (!error.message.includes("Cannot find module 'next/dist/server/next-server'")) {
+            // A different error, so rethrow it
+            throw error;
+        }
+        // Probably an old version of next
+    }
+    if (!NextServer) {
+        try {
+            // next < 11.0.1
+            // eslint-disable-next-line node/no-missing-require, import/no-unresolved
+            NextServer = require('next/dist/next-server/server/next-server').default;
+        }
+        catch (error) {
+            if (!error.message.includes("Cannot find module 'next/dist/next-server/server/next-server'")) {
+                throw error;
+            }
+            throw new Error('Could not find Next.js server');
+        }
+    }
+    const nextServer = new NextServer({
+        conf,
+        dir: path.resolve(__dirname, app),
+        customServer: false,
+    });
+    const requestHandler = nextServer.getRequestHandler();
+    const server = new Server(async (req, res) => {
+        try {
+            await requestHandler(req, res);
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error('server function error');
+        }
+    });
+    const bridge = new Bridge(server);
+    bridge.listen();
+    return async (event, context) => {
+        var _a, _b, _c, _d;
+        // Next expects to be able to parse the query from the URL
+        const query = new URLSearchParams(event.queryStringParameters).toString();
+        event.path = query ? `${event.path}?${query}` : event.path;
+        // Only needed if we're intercepting static files
+        if (staticManifest.length !== 0) {
+            const { host } = event.headers;
+            const protocol = event.headers['x-forwarded-proto'] || 'http';
+            base = `${protocol}://${host}`;
+        }
+        const { headers, ...result } = await bridge.launcher(event, context);
+        /** @type import("@netlify/functions").HandlerResponse */
+        // Convert all headers to multiValueHeaders
+        const multiValueHeaders = {};
+        for (const key of Object.keys(headers)) {
+            if (Array.isArray(headers[key])) {
+                multiValueHeaders[key] = headers[key];
+            }
+            else {
+                multiValueHeaders[key] = [headers[key]];
+            }
+        }
+        if ((_b = (_a = multiValueHeaders['set-cookie']) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('__prerender_bypass')) {
+            delete multiValueHeaders.etag;
+            multiValueHeaders['cache-control'] = ['no-cache'];
+        }
+        // Sending SWR headers causes undefined behaviour with the Netlify CDN
+        if ((_d = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.includes('stale-while-revalidate')) {
+            multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
+        }
+        return {
+            ...result,
+            multiValueHeaders,
+            isBase64Encoded: result.encoding === 'base64',
+        };
+    };
+};
+const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => `
+const { Server } = require("http");
+const { tmpdir } = require('os')
+const { promises, createWriteStream, existsSync } = require("fs");
+const { promisify } = require('util')
+const streamPipeline = promisify(require('stream').pipeline)
+// We copy the file here rather than requiring from the node module
+const { Bridge } = require("./bridge");
+const fetch = require('node-fetch')
+
+const { builder } = require("@netlify/functions");
+const { config }  = require("${publishDir}/required-server-files.json")
+let staticManifest 
+try {
+  staticManifest = require("${publishDir}/static-manifest.json")
+} catch {}
+const path = require("path");
+const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
+exports.handler = ${isODB
+    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest));`
+    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest);`}
+`;
+module.exports = getHandler;