@netlify/plugin-nextjs 4.0.0 → 4.1.3

package/README.md

@@ -76,6 +76,15 @@ If you are using Nx, then you will need to point `publish` to the folder inside
 The Essential Next.js plugin now fully supports ISR on Netlify. For more details see
 [the ISR docs](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/isr.md).
 
+## Use with `next export`
+
+If you are using `next export` to generate a static site, you do not need most of the functionality of this plugin and
+you can remove it. Alternatively you can
+[set the environment variable](https://docs.netlify.com/configure-builds/environment-variables/)
+`NETLIFY_NEXT_PLUGIN_SKIP` to `true` and the plugin will handle caching but won't generate any functions for SSR
+support. See [`demos/next-export`](https://github.com/netlify/netlify-plugin-nextjs/tree/main/demos/next-export) for an
+example.
+
 ## Feedback
 
 If you think you have found a bug in the plugin,

package/lib/helpers/config.js

@@ -30,7 +30,7 @@ const resolveModuleRoot = (moduleName) => {
     try {
         return pathe_1.dirname(pathe_1.relative(process.cwd(), require.resolve(`${moduleName}/package.json`, { paths: [process.cwd()] })));
     }
-    catch (error) {
+    catch {
         return null;
     }
 };

package/lib/helpers/files.js

@@ -75,7 +75,7 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, }) => {
     Object.entries(prerenderManifest.routes).forEach(([route, { initialRevalidateSeconds }]) => {
         if (initialRevalidateSeconds) {
             // Find all files used by ISR routes
-            const trimmedPath = route.slice(1);
+            const trimmedPath = route === '/' ? 'index' : route.slice(1);
             isrFiles.add(`${trimmedPath}.html`);
             isrFiles.add(`${trimmedPath}.json`);
             if (initialRevalidateSeconds < constants_1.MINIMUM_REVALIDATE_SECONDS) {

package/lib/helpers/redirects.js

@@ -1,11 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRedirects = void 0;
+exports.generateRedirects = exports.generateStaticRedirects = void 0;
 const fs_extra_1 = require("fs-extra");
-const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
 const utils_1 = require("./utils");
@@ -37,8 +33,17 @@ const generateLocaleRedirects = ({ i18n, basePath, trailingSlash, }) => {
     });
     return redirects;
 };
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, }) => {
-    const { dynamicRoutes, routes: staticRoutes } = await fs_extra_1.readJSON(pathe_1.join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+const generateStaticRedirects = ({ netlifyConfig, nextConfig: { i18n, basePath }, }) => {
+    // Static files are in `static`
+    netlifyConfig.redirects.push({ from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 });
+    if (i18n) {
+        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
+    }
+};
+exports.generateStaticRedirects = generateStaticRedirects;
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, }) => {
+    const { dynamicRoutes: prerenderedDynamicRoutes, routes: prerenderedStaticRoutes } = await fs_extra_1.readJSON(pathe_1.join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    const { dynamicRoutes, staticRoutes } = await fs_extra_1.readJSON(pathe_1.join(netlifyConfig.build.publish, 'routes-manifest.json'));
     netlifyConfig.redirects.push(...constants_1.HIDDEN_PATHS.map((path) => ({
         from: `${basePath}${path}`,
         to: '/404.html',
@@ -48,83 +53,71 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     if (i18n && i18n.localeDetection !== false) {
         netlifyConfig.redirects.push(...generateLocaleRedirects({ i18n, basePath, trailingSlash }));
     }
-    const dataRedirects = [];
-    const pageRedirects = [];
-    const isrRedirects = [];
-    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
+    // This is only used in prod, so dev uses `next dev` directly
+    netlifyConfig.redirects.push(
+    // API routes always need to be served from the regular function
+    ...utils_1.getApiRewrites(basePath), 
+    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
+    ...(await utils_1.getPreviewRewrites({ basePath, appDir })));
+    const staticRouteEntries = Object.entries(prerenderedStaticRoutes);
+    const staticRoutePaths = new Set();
+    // First add all static ISR routes
+    staticRouteEntries.forEach(([route, { initialRevalidateSeconds }]) => {
+        if (utils_1.isApiRoute(route)) {
+            return;
+        }
+        staticRoutePaths.add(route);
         if (initialRevalidateSeconds === false) {
             // These can be ignored, as they're static files handled by the CDN
             return;
         }
+        // The default locale is served from the root, not the localised path
         if ((i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) && route.startsWith(`/${i18n.defaultLocale}/`)) {
             route = route.slice(i18n.defaultLocale.length + 1);
+            staticRoutePaths.add(route);
+            netlifyConfig.redirects.push(...utils_1.redirectsForNextRouteWithData({
+                route,
+                dataRoute: utils_1.routeToDataRoute(route, buildId, i18n.defaultLocale),
+                basePath,
+                to: constants_1.ODB_FUNCTION_PATH,
+                force: true,
+            }));
+        }
+        else {
+            // ISR routes use the ODB handler
+            netlifyConfig.redirects.push(
+            // No i18n, because the route is already localized
+            ...utils_1.redirectsForNextRoute({ route, basePath, to: constants_1.ODB_FUNCTION_PATH, force: true, buildId, i18n: null }));
         }
-        isrRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute), ...utils_1.netlifyRoutesForNextRoute(route));
     });
-    dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
-        // Add redirects if fallback is "null" (aka blocking) or true/a string
-        if (fallback === false) {
+    // Add rewrites for all static SSR routes. This is Next 12+
+    staticRoutes === null || staticRoutes === void 0 ? void 0 : staticRoutes.forEach((route) => {
+        if (staticRoutePaths.has(route.page) || utils_1.isApiRoute(route.page)) {
+            // Prerendered static routes are either handled by the CDN or are ISR
             return;
         }
-        pageRedirects.push(...utils_1.netlifyRoutesForNextRoute(route));
-        dataRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute));
+        netlifyConfig.redirects.push(...utils_1.redirectsForNextRoute({ route: route.page, buildId, basePath, to: constants_1.HANDLER_FUNCTION_PATH, i18n }));
     });
-    if (i18n) {
-        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
-    }
-    const publicFiles = await globby_1.default('**/*', { cwd: pathe_1.join(appDir, 'public') });
-    // This is only used in prod, so dev uses `next dev` directly
-    netlifyConfig.redirects.push(
-    // Static files are in `static`
-    { from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 }, 
-    // API routes always need to be served from the regular function
-    {
-        from: `${basePath}/api`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    }, {
-        from: `${basePath}/api/*`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    }, 
-    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
-    ...publicFiles.map((file) => ({
-        from: `${basePath}/${file}`,
-        // This is a no-op, but we do it to stop it matching the following rule
-        to: `${basePath}/${file}`,
-        conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
-        status: 200,
-    })), {
+    // Add rewrites for all dynamic routes (both SSR and ISR)
+    dynamicRoutes.forEach((route) => {
+        if (utils_1.isApiRoute(route.page)) {
+            return;
+        }
+        if (route.page in prerenderedDynamicRoutes) {
+            const { fallback } = prerenderedDynamicRoutes[route.page];
+            const { to, status } = utils_1.targetForFallback(fallback);
+            netlifyConfig.redirects.push(...utils_1.redirectsForNextRoute({ buildId, route: route.page, basePath, to, status, i18n }));
+        }
+        else {
+            // If the route isn't prerendered, it's SSR
+            netlifyConfig.redirects.push(...utils_1.redirectsForNextRoute({ route: route.page, buildId, basePath, to: constants_1.HANDLER_FUNCTION_PATH, i18n }));
+        }
+    });
+    // Final fallback
+    netlifyConfig.redirects.push({
         from: `${basePath}/*`,
         to: constants_1.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: constants_1.ODB_FUNCTION_PATH,
-        status: 200,
-        force: true,
-    })), 
-    // These are pages with fallback set, which need an ODB
-    // Data redirects go first, to avoid conflict with splat redirects
-    ...dataRedirects.map((redirect) => ({
-        from: `${basePath}${redirect}`,
-        to: constants_1.ODB_FUNCTION_PATH,
-        status: 200,
-    })), 
-    // ...then all the other fallback pages
-    ...pageRedirects.map((redirect) => ({
-        from: `${basePath}${redirect}`,
-        to: constants_1.ODB_FUNCTION_PATH,
-        status: 200,
-    })), 
-    // Everything else is handled by the regular function
-    { from: `${basePath}/*`, to: constants_1.HANDLER_FUNCTION_PATH, status: 200 });
+    });
 };
 exports.generateRedirects = generateRedirects;

package/lib/helpers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/helpers/utils.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.netlifyRoutesForNextRoute = void 0;
+exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.targetForFallback = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = void 0;
+const globby_1 = __importDefault(require("globby"));
+const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
-const netlifyRoutesForNextRoute = (nextRoute) => {
+const toNetlifyRoute = (nextRoute) => {
     const netlifyRoutes = [nextRoute];
     // If the route is an optional catch-all route, we need to add a second
     // Netlify route for the base path (when no parameters are present).
@@ -29,4 +34,95 @@ const netlifyRoutesForNextRoute = (nextRoute) => {
         // Replace dynamic parameters, e.g., [id]
         .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
 };
-exports.netlifyRoutesForNextRoute = netlifyRoutesForNextRoute;
+exports.toNetlifyRoute = toNetlifyRoute;
+const netlifyRoutesForNextRouteWithData = ({ route, dataRoute }) => [
+    ...exports.toNetlifyRoute(dataRoute),
+    ...exports.toNetlifyRoute(route),
+];
+exports.netlifyRoutesForNextRouteWithData = netlifyRoutesForNextRouteWithData;
+const routeToDataRoute = (route, buildId, locale) => `/_next/data/${buildId}${locale ? `/${locale}` : ''}${route === '/' ? '/index' : route}.json`;
+exports.routeToDataRoute = routeToDataRoute;
+const netlifyRoutesForNextRoute = (route, buildId, i18n) => {
+    var _a;
+    if (!((_a = i18n === null || i18n === void 0 ? void 0 : i18n.locales) === null || _a === void 0 ? void 0 : _a.length)) {
+        return exports.netlifyRoutesForNextRouteWithData({ route, dataRoute: exports.routeToDataRoute(route, buildId) });
+    }
+    const { locales, defaultLocale } = i18n;
+    const routes = [];
+    locales.forEach((locale) => {
+        // Data route is always localized
+        const dataRoute = exports.routeToDataRoute(route, buildId, locale);
+        routes.push(
+        // Default locale is served from root, not localized
+        ...exports.netlifyRoutesForNextRouteWithData({
+            route: locale === defaultLocale ? route : `/${locale}${route}`,
+            dataRoute,
+        }));
+    });
+    return routes;
+};
+const isApiRoute = (route) => route.startsWith('/api/') || route === '/api';
+exports.isApiRoute = isApiRoute;
+const targetForFallback = (fallback) => {
+    if (fallback === null || fallback === false) {
+        // fallback = null mean "blocking", which uses ODB. For fallback=false then anything prerendered should 404.
+        // However i18n pages may not have been prerendered, so we still need to hit the origin
+        return { to: constants_1.ODB_FUNCTION_PATH, status: 200 };
+    }
+    // fallback = true is also ODB
+    return { to: constants_1.ODB_FUNCTION_PATH, status: 200 };
+};
+exports.targetForFallback = targetForFallback;
+const redirectsForNextRoute = ({ route, buildId, basePath, to, i18n, status = 200, force = false, }) => netlifyRoutesForNextRoute(route, buildId, i18n).map((redirect) => ({
+    from: `${basePath}${redirect}`,
+    to,
+    status,
+    force,
+}));
+exports.redirectsForNextRoute = redirectsForNextRoute;
+const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status = 200, force = false, }) => exports.netlifyRoutesForNextRouteWithData({ route, dataRoute }).map((redirect) => ({
+    from: `${basePath}${redirect}`,
+    to,
+    status,
+    force,
+}));
+exports.redirectsForNextRouteWithData = redirectsForNextRouteWithData;
+const getApiRewrites = (basePath) => [
+    {
+        from: `${basePath}/api`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    },
+    {
+        from: `${basePath}/api/*`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    },
+];
+exports.getApiRewrites = getApiRewrites;
+const getPreviewRewrites = async ({ basePath, appDir }) => {
+    const publicFiles = await globby_1.default('**/*', { cwd: pathe_1.join(appDir, 'public') });
+    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
+    return [
+        ...publicFiles.map((file) => ({
+            from: `${basePath}/${file}`,
+            // This is a no-op, but we do it to stop it matching the following rule
+            to: `${basePath}/${file}`,
+            conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+            status: 200,
+        })),
+        {
+            from: `${basePath}/*`,
+            to: constants_1.HANDLER_FUNCTION_PATH,
+            status: 200,
+            conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+            force: true,
+        },
+    ];
+};
+exports.getPreviewRewrites = getPreviewRewrites;
+const shouldSkip = () => process.env.NEXT_PLUGIN_FORCE_RUN === 'false' ||
+    process.env.NEXT_PLUGIN_FORCE_RUN === '0' ||
+    process.env.NETLIFY_NEXT_PLUGIN_SKIP === 'true' ||
+    process.env.NETLIFY_NEXT_PLUGIN_SKIP === '1';
+exports.shouldSkip = shouldSkip;

package/lib/helpers/verification.js

@@ -22,7 +22,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+exports.warnForProblematicUserRewrites = exports.getProblematicUserRewrites = exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+/* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = __importStar(require("path"));
 const chalk_1 = require("chalk");
@@ -67,14 +68,13 @@ const checkNextSiteHasBuilt = ({ publish, failBuild, }) => {
         return failBuild(outdent_1.outdent `
       The directory "${path_1.default.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.
       ${outWarning}
-      If you are using "next export" then the Essential Next.js plugin should be removed. See https://ntl.fyi/remove-plugin for details.
+      If you are using "next export" then you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
     }
     if (fs_1.existsSync(path_1.default.join(publish, 'export-detail.json'))) {
         failBuild(outdent_1.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.
+      The publish directory should be set to "out", and you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
     }
 };
@@ -119,3 +119,38 @@ const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
     console.log(chalk_1.greenBright `\n\nFor more information on fixing this, see ${chalk_1.blueBright `https://ntl.fyi/large-next-functions`}`);
 };
 exports.checkZipSize = checkZipSize;
+const getProblematicUserRewrites = ({ redirects, basePath, }) => {
+    const userRewrites = [];
+    for (const redirect of redirects) {
+        // This is the first of the plugin-generated redirects so we can stop checking
+        if (redirect.from === `${basePath}/_next/static/*` && redirect.to === `/static/:splat` && redirect.status === 200) {
+            break;
+        }
+        if (
+        // Redirects are fine
+        (redirect.status === 200 || redirect.status === 404) &&
+            // Rewriting to a function is also fine
+            !redirect.to.startsWith('/.netlify/') &&
+            // ...so is proxying
+            !redirect.to.startsWith('http')) {
+            userRewrites.push(redirect);
+        }
+    }
+    return userRewrites;
+};
+exports.getProblematicUserRewrites = getProblematicUserRewrites;
+const warnForProblematicUserRewrites = ({ redirects, basePath, }) => {
+    const userRewrites = exports.getProblematicUserRewrites({ redirects, basePath });
+    if (userRewrites.length === 0) {
+        return;
+    }
+    console.log(chalk_1.yellowBright(outdent_1.outdent `
+      You have the following Netlify rewrite${userRewrites.length === 1 ? '' : 's'} that might cause conflicts with the Next.js plugin:
+
+      ${chalk_1.reset(userRewrites.map(({ from, to, status }) => `- ${from} ${to} ${status}`).join('\n'))}
+
+      For more information, see https://ntl.fyi/next-rewrites
+    `));
+};
+exports.warnForProblematicUserRewrites = warnForProblematicUserRewrites;
+/* eslint-enable max-lines */

package/lib/index.js

@@ -1,17 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
 const constants_1 = require("./constants");
 const cache_1 = require("./helpers/cache");
 const config_1 = require("./helpers/config");
 const files_1 = require("./helpers/files");
 const functions_1 = require("./helpers/functions");
 const redirects_1 = require("./helpers/redirects");
+const utils_1 = require("./helpers/utils");
 const verification_1 = require("./helpers/verification");
 const plugin = {
     async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
         var _a;
         const { publish } = netlifyConfig.build;
+        if (utils_1.shouldSkip()) {
+            await cache_1.restoreCache({ cache, publish });
+            console.log('Not running Essential Next.js plugin');
+            if (fs_extra_1.existsSync(path_1.join(constants.INTERNAL_FUNCTIONS_SRC, constants_1.HANDLER_FUNCTION_NAME))) {
+                console.log(`Please ensure you remove any generated functions from ${constants.INTERNAL_FUNCTIONS_SRC}`);
+            }
+            return;
+        }
         verification_1.checkForRootPublish({ publish, failBuild });
         verification_1.verifyNetlifyBuildVersion({ failBuild, ...constants });
         await cache_1.restoreCache({ cache, publish });
@@ -20,36 +30,53 @@ const plugin = {
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
+        if (utils_1.shouldSkip()) {
+            return;
+        }
         const { publish } = netlifyConfig.build;
         verification_1.checkNextSiteHasBuilt({ publish, failBuild });
         const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await config_1.getNextConfig({
             publish,
             failBuild,
         });
+        const buildId = fs_extra_1.readFileSync(path_1.join(publish, 'BUILD_ID'), 'utf8').trim();
         config_1.configureHandlerFunctions({ netlifyConfig, ignore, publish: path_1.relative(process.cwd(), publish) });
         await functions_1.generateFunctions(constants, appDir);
         await functions_1.generatePagesResolver({ target, constants });
         await files_1.movePublicFiles({ appDir, outdir, publish });
-        if (process.env.EXPERIMENTAL_ODB_TTL) {
-            await files_1.patchNextFiles(basePath);
-        }
+        await files_1.patchNextFiles(basePath);
         if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES) {
             console.log("The flag 'EXPERIMENTAL_MOVE_STATIC_PAGES' is no longer required, as it is now the default. To disable this behavior, set the env var 'SERVE_STATIC_FILES_FROM_ORIGIN' to 'true'");
         }
         if (!process.env.SERVE_STATIC_FILES_FROM_ORIGIN) {
             await files_1.moveStaticPages({ target, netlifyConfig, i18n });
         }
+        await redirects_1.generateStaticRedirects({
+            netlifyConfig,
+            nextConfig: { basePath, i18n },
+        });
         await functions_1.setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
         await redirects_1.generateRedirects({
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
+            buildId,
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
-        await cache_1.saveCache({ cache, publish: netlifyConfig.build.publish });
+    async onPostBuild({ netlifyConfig: { build: { publish }, redirects, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
+        await cache_1.saveCache({ cache, publish });
+        if (utils_1.shouldSkip()) {
+            status.show({
+                title: 'Essential Next.js plugin did not run',
+                summary: `Next cache was stored, but all other functions were skipped because ${process.env.NETLIFY_NEXT_PLUGIN_SKIP
+                    ? `NETLIFY_NEXT_PLUGIN_SKIP is set`
+                    : `NEXT_PLUGIN_FORCE_RUN is set to ${process.env.NEXT_PLUGIN_FORCE_RUN}`}`,
+            });
+            return;
+        }
         await verification_1.checkForOldFunctions({ functions });
         await verification_1.checkZipSize(path_1.join(FUNCTIONS_DIST, `${constants_1.ODB_FUNCTION_NAME}.zip`));
-        const { basePath } = await config_1.getNextConfig({ publish: netlifyConfig.build.publish, failBuild });
+        const { basePath } = await config_1.getNextConfig({ publish, failBuild });
+        verification_1.warnForProblematicUserRewrites({ basePath, redirects });
         await files_1.unpatchNextFiles(basePath);
     },
 };

package/lib/templates/getHandler.js

@@ -12,17 +12,19 @@ const makeHandler = () =>
 // We return a function and then call `toString()` on it to serialise it as the launcher function
 // eslint-disable-next-line max-params
 (conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
+    var _a;
     // This is just so nft knows about the page entrypoints. It's not actually used
     try {
         // eslint-disable-next-line node/no-missing-require
         require.resolve('./pages.js');
     }
     catch { }
-    // eslint-disable-next-line no-underscore-dangle
-    process.env._BYPASS_SSG = 'true';
     const ONE_YEAR_IN_SECONDS = 31536000;
+    (_a = process.env).NODE_ENV || (_a.NODE_ENV = 'production');
     // We don't want to write ISR files to disk in the lambda environment
     conf.experimental.isrFlushToDisk = false;
+    // eslint-disable-next-line no-underscore-dangle
+    process.env._BYPASS_SSG = 'true';
     // Set during the request as it needs the host header. Hoisted so we can define the function once
     let base;
     augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
@@ -69,13 +71,12 @@ const makeHandler = () =>
         const cacheHeader = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0];
         if (cacheHeader === null || cacheHeader === void 0 ? void 0 : cacheHeader.includes('stale-while-revalidate')) {
             if (requestMode === 'odb') {
-                requestMode = 'isr';
                 const ttl = getMaxAge(cacheHeader);
-                // Long-expiry TTL is basically no TTL
+                // Long-expiry TTL is basically no TTL, so we'll skip it
                 if (ttl > 0 && ttl < ONE_YEAR_IN_SECONDS) {
                     result.ttl = ttl;
+                    requestMode = 'isr';
                 }
-                multiValueHeaders['x-rendered-at'] = [new Date().toISOString()];
             }
             multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.0.0",
+  "version": "4.1.3",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -74,8 +74,8 @@
     "@babel/core": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
     "@babel/preset-typescript": "^7.16.0",
-    "@netlify/build": "^20.3.0",
-    "@netlify/eslint-config-node": "^4.0.0",
+    "@netlify/build": "^26.1.1",
+    "@netlify/eslint-config-node": "^4.1.2",
     "@testing-library/cypress": "^8.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.0.2",