@netlify/plugin-nextjs 4.1.0 → 4.2.0

package/README.md

@@ -85,6 +85,14 @@ you can remove it. Alternatively you can
 support. See [`demos/next-export`](https://github.com/netlify/netlify-plugin-nextjs/tree/main/demos/next-export) for an
 example.
 
+## Generated functions
+
+This plugin works by generating three Netlify functions that handle requests that haven't been pre-rendered. These are
+`___netlify-handler` (for SSR and API routes), `___netlify-odb-handler` (for ISR and fallback routes), and `_ipx` (for
+images). You can see the requests for these in [the function logs](https://docs.netlify.com/functions/logs/). For ISR
+and fallback routes you will not see any requests that are served from the edge cache, just actual rendering requests.
+These are all internal functions, so you won't find them in your site's own functions directory.
+
 ## 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/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 = 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");
@@ -45,8 +41,9 @@ const generateStaticRedirects = ({ netlifyConfig, nextConfig: { i18n, basePath }
     }
 };
 exports.generateStaticRedirects = generateStaticRedirects;
-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 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',
@@ -56,78 +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 }));
     });
-    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(
-    // 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.shouldSkip = 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,7 +34,93 @@ 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' ||

package/lib/index.js

@@ -39,13 +39,12 @@ const plugin = {
             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'");
         }
@@ -60,6 +59,7 @@ const plugin = {
         await redirects_1.generateRedirects({
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
+            buildId,
         });
     },
     async onPostBuild({ netlifyConfig: { build: { publish }, redirects, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {

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,17 +71,17 @@ 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'];
         }
         multiValueHeaders['x-render-mode'] = [requestMode];
+        console.log(`[${event.httpMethod}] ${event.path} (${requestMode === null || requestMode === void 0 ? void 0 : requestMode.toUpperCase()})`);
         return {
             ...result,
             multiValueHeaders,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "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": "^25.0.1",
-    "@netlify/eslint-config-node": "^4.0.1",
+    "@netlify/build": "^26.1.3",
+    "@netlify/eslint-config-node": "^4.1.3",
     "@testing-library/cypress": "^8.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.0.2",