@netlify/plugin-nextjs 4.30.0 → 4.30.1

package/lib/helpers/edge.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadAppPathRoutesManifest = exports.loadMiddlewareManifest = void 0;
+exports.writeEdgeFunctions = exports.writeRscDataEdgeFunction = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadPrerenderManifest = exports.loadAppPathRoutesManifest = exports.loadMiddlewareManifest = exports.isAppDirRoute = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const chalk_1 = require("chalk");
@@ -17,10 +17,14 @@ const maybeLoadJson = (path) => {
         return (0, fs_extra_1.readJson)(path);
     }
 };
+const isAppDirRoute = (route, appPathRoutesManifest) => Boolean(appPathRoutesManifest) && Object.values(appPathRoutesManifest).includes(route);
+exports.isAppDirRoute = isAppDirRoute;
 const loadMiddlewareManifest = (netlifyConfig) => maybeLoadJson((0, path_1.resolve)(netlifyConfig.build.publish, 'server', 'middleware-manifest.json'));
 exports.loadMiddlewareManifest = loadMiddlewareManifest;
 const loadAppPathRoutesManifest = (netlifyConfig) => maybeLoadJson((0, path_1.resolve)(netlifyConfig.build.publish, 'app-path-routes-manifest.json'));
 exports.loadAppPathRoutesManifest = loadAppPathRoutesManifest;
+const loadPrerenderManifest = (netlifyConfig) => (0, fs_extra_1.readJSON)((0, path_1.resolve)(netlifyConfig.build.publish, 'prerender-manifest.json'));
+exports.loadPrerenderManifest = loadPrerenderManifest;
 /**
  * Convert the Next middleware name into a valid Edge Function name
  */
@@ -110,9 +114,8 @@ const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) =
 };
 const getEdgeTemplatePath = (file) => (0, path_1.join)(__dirname, '..', '..', 'src', 'templates', 'edge', file);
 const copyEdgeSourceFile = ({ file, target, edgeFunctionDir, }) => fs_1.promises.copyFile(getEdgeTemplatePath(file), (0, path_1.join)(edgeFunctionDir, target !== null && target !== void 0 ? target : file));
-const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, pageRegexMap, appPathRoutesManifest = {}, nextConfig, cache, }) => {
-    const name = sanitizeName(edgeFunctionDefinition.name);
-    const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, name);
+const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, functionName, matchers = [], middleware = false, }) => {
+    const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, functionName);
     const bundle = await getMiddlewareBundle({
         edgeFunctionDefinition,
         netlifyConfig,
@@ -121,37 +124,30 @@ const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, net
     await fs_1.promises.writeFile((0, path_1.join)(edgeFunctionDir, 'bundle.js'), bundle);
     await copyEdgeSourceFile({
         edgeFunctionDir,
-        file: 'runtime.ts',
+        file: middleware ? 'middleware-runtime.ts' : 'function-runtime.ts',
         target: 'index.ts',
     });
-    const matchers = [];
+    if (middleware) {
+        // Functions don't have complex matchers, so we can rely on the Netlify matcher
+        await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionDir, 'matchers.json'), matchers);
+    }
+};
+const generateEdgeFunctionMiddlewareMatchers = ({ edgeFunctionDefinition, nextConfig, }) => {
     // The v1 middleware manifest has a single regexp, but the v2 has an array of matchers
     if ('regexp' in edgeFunctionDefinition) {
-        matchers.push({ regexp: edgeFunctionDefinition.regexp });
+        return [{ regexp: edgeFunctionDefinition.regexp }];
     }
-    else if (nextConfig.i18n) {
-        matchers.push(...edgeFunctionDefinition.matchers.map((matcher) => ({
+    if (nextConfig.i18n) {
+        return edgeFunctionDefinition.matchers.map((matcher) => ({
             ...matcher,
             regexp: (0, matchers_1.makeLocaleOptional)(matcher.regexp),
-        })));
+        }));
     }
-    else {
-        matchers.push(...edgeFunctionDefinition.matchers);
-    }
-    // If the EF matches a page, it's an app dir page so needs a matcher too
-    // The object will be empty if appDir isn't enabled in the Next config
-    if (pageRegexMap && edgeFunctionDefinition.page in appPathRoutesManifest) {
-        const regexp = pageRegexMap.get(appPathRoutesManifest[edgeFunctionDefinition.page]);
-        if (regexp) {
-            matchers.push({ regexp });
-        }
-    }
-    await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionDir, 'matchers.json'), matchers);
-    // We add a defintion for each matching path
-    return matchers.map((matcher) => {
-        const pattern = (0, matchers_1.stripLookahead)(matcher.regexp);
-        return { function: name, pattern, name: edgeFunctionDefinition.name, cache };
-    });
+    return edgeFunctionDefinition.matchers;
+};
+const middlewareMatcherToEdgeFunctionDefinition = (matcher, name, cache) => {
+    const pattern = (0, matchers_1.transformCaptureGroups)((0, matchers_1.stripLookahead)(matcher.regexp));
+    return { function: name, pattern, name, cache };
 };
 const cleanupEdgeFunctions = ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions', }) => (0, fs_extra_1.emptyDir)(INTERNAL_EDGE_FUNCTIONS_SRC);
 exports.cleanupEdgeFunctions = cleanupEdgeFunctions;
@@ -175,9 +171,57 @@ const writeDevEdgeFunction = async ({ INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/ed
     await copyEdgeSourceFile({ edgeFunctionDir, file: 'next-dev.js', target: 'index.js' });
 };
 exports.writeDevEdgeFunction = writeDevEdgeFunction;
+/**
+ * Writes an edge function that routes RSC data requests to the `.rsc` route
+ */
+const writeRscDataEdgeFunction = async ({ prerenderManifest, appPathRoutesManifest, }) => {
+    if (!prerenderManifest || !appPathRoutesManifest) {
+        return [];
+    }
+    const staticAppdirRoutes = [];
+    for (const [path, route] of Object.entries(prerenderManifest.routes)) {
+        if ((0, exports.isAppDirRoute)(route.srcRoute, appPathRoutesManifest)) {
+            staticAppdirRoutes.push(path, route.dataRoute);
+        }
+    }
+    const dynamicAppDirRoutes = [];
+    for (const [path, route] of Object.entries(prerenderManifest.dynamicRoutes)) {
+        if ((0, exports.isAppDirRoute)(path, appPathRoutesManifest)) {
+            dynamicAppDirRoutes.push(route.routeRegex, route.dataRouteRegex);
+        }
+    }
+    if (staticAppdirRoutes.length === 0 && dynamicAppDirRoutes.length === 0) {
+        return [];
+    }
+    const edgeFunctionDir = (0, path_1.resolve)('.netlify', 'edge-functions', 'rsc-data');
+    await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
+    await copyEdgeSourceFile({ edgeFunctionDir, file: 'rsc-data.ts' });
+    return [
+        ...staticAppdirRoutes.map((path) => ({
+            function: 'rsc-data',
+            name: 'RSC data routing',
+            path,
+        })),
+        ...dynamicAppDirRoutes.map((pattern) => ({
+            function: 'rsc-data',
+            name: 'RSC data routing',
+            pattern,
+        })),
+    ];
+};
+exports.writeRscDataEdgeFunction = writeRscDataEdgeFunction;
+const getEdgeFunctionPatternForPage = ({ edgeFunctionDefinition, pageRegexMap, appPathRoutesManifest, }) => {
+    // We don't just use the matcher from the edge function definition, because it doesn't handle trailing slashes
+    var _a;
+    // appDir functions have a name that _isn't_ the route name, but rather the route with `/page` appended
+    const regexp = pageRegexMap.get((_a = appPathRoutesManifest === null || appPathRoutesManifest === void 0 ? void 0 : appPathRoutesManifest[edgeFunctionDefinition.page]) !== null && _a !== void 0 ? _a : edgeFunctionDefinition.page);
+    // If we need to fall back to the matcher, we need to add an optional trailing slash
+    return regexp !== null && regexp !== void 0 ? regexp : edgeFunctionDefinition.matchers[0].regexp.replace(/([^/])\$$/, '$1/?$');
+};
 /**
  * Writes Edge Functions for the Next middleware
  */
+// eslint-disable-next-line max-lines-per-function
 const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
     var _a;
     const manifest = {
@@ -192,6 +236,7 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
     const usesAppDir = (_a = nextConfig.experimental) === null || _a === void 0 ? void 0 : _a.appDir;
     await (0, fs_extra_1.copy)(getEdgeTemplatePath('../edge-shared'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared'));
     await (0, fs_extra_1.writeJSON)((0, path_1.join)(edgeFunctionRoot, 'edge-shared', 'nextConfig.json'), nextConfig);
+    await (0, fs_extra_1.copy)((0, path_1.join)(publish, 'prerender-manifest.json'), (0, path_1.join)(edgeFunctionRoot, 'edge-shared', 'prerender-manifest.json'));
     if (!(0, destr_1.default)(process.env.NEXT_DISABLE_EDGE_IMAGES) &&
         !(0, destr_1.default)(process.env.NEXT_DISABLE_NETLIFY_EDGE) &&
         !(0, destr_1.default)(process.env.DISABLE_IPX)) {
@@ -207,6 +252,11 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
         });
     }
     if (!(0, destr_1.default)(process.env.NEXT_DISABLE_NETLIFY_EDGE)) {
+        const rscFunctions = await (0, exports.writeRscDataEdgeFunction)({
+            prerenderManifest: await (0, exports.loadPrerenderManifest)(netlifyConfig),
+            appPathRoutesManifest: await (0, exports.loadAppPathRoutesManifest)(netlifyConfig),
+        });
+        manifest.functions.push(...rscFunctions);
         const middlewareManifest = await (0, exports.loadMiddlewareManifest)(netlifyConfig);
         if (!middlewareManifest) {
             console.error("Couldn't find the middleware manifest");
@@ -216,16 +266,22 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
         for (const middleware of middlewareManifest.sortedMiddleware) {
             usesEdge = true;
             const edgeFunctionDefinition = middlewareManifest.middleware[middleware];
-            const functionDefinitions = await writeEdgeFunction({
+            const functionName = sanitizeName(edgeFunctionDefinition.name);
+            const matchers = generateEdgeFunctionMiddlewareMatchers({
                 edgeFunctionDefinition,
                 edgeFunctionRoot,
-                netlifyConfig,
                 nextConfig,
             });
-            manifest.functions.push(...functionDefinitions);
+            await writeEdgeFunction({
+                edgeFunctionDefinition,
+                edgeFunctionRoot,
+                netlifyConfig,
+                functionName,
+                matchers,
+                middleware: true,
+            });
+            manifest.functions.push(...matchers.map((matcher) => middlewareMatcherToEdgeFunctionDefinition(matcher, functionName)));
         }
-        // Older versions of the manifest format don't have the functions field
-        // No, the version field was not incremented
         if (typeof middlewareManifest.functions === 'object') {
             // When using the app dir, we also need to check if the EF matches a page
             const appPathRoutesManifest = await (0, exports.loadAppPathRoutesManifest)(netlifyConfig);
@@ -235,17 +291,25 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
             ]));
             for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
                 usesEdge = true;
-                const functionDefinitions = await writeEdgeFunction({
+                const functionName = sanitizeName(edgeFunctionDefinition.name);
+                await writeEdgeFunction({
                     edgeFunctionDefinition,
                     edgeFunctionRoot,
                     netlifyConfig,
+                    functionName,
+                });
+                const pattern = getEdgeFunctionPatternForPage({
+                    edgeFunctionDefinition,
                     pageRegexMap,
                     appPathRoutesManifest,
-                    nextConfig,
+                });
+                manifest.functions.push({
+                    function: functionName,
+                    name: edgeFunctionDefinition.name,
+                    pattern,
                     // cache: "manual" is currently experimental, so we restrict it to sites that use experimental appDir
                     cache: usesAppDir ? 'manual' : undefined,
                 });
-                manifest.functions.push(...functionDefinitions);
             }
         }
         if (usesEdge) {

package/lib/helpers/files.js

@@ -13,6 +13,7 @@ const p_limit_1 = __importDefault(require("p-limit"));
 const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
 const constants_1 = require("../constants");
+const edge_1 = require("./edge");
 const utils_1 = require("./utils");
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
 const SOURCE_FILE_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx'];
@@ -75,16 +76,18 @@ const moveStaticPages = async ({ netlifyConfig, target, i18n, basePath, }) => {
     // Load the middleware manifest so we can check if a file matches it before moving
     const middlewarePaths = await (0, exports.getMiddleware)(netlifyConfig.build.publish);
     const middleware = middlewarePaths.map((path) => path.slice(1));
-    const prerenderManifest = await (0, fs_extra_1.readJson)((0, pathe_1.join)(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    const prerenderManifest = await (0, edge_1.loadPrerenderManifest)(netlifyConfig);
     const { redirects, rewrites } = await (0, fs_extra_1.readJson)((0, pathe_1.join)(netlifyConfig.build.publish, 'routes-manifest.json'));
     const isrFiles = new Set();
     const shortRevalidateRoutes = [];
-    Object.entries(prerenderManifest.routes).forEach(([route, { initialRevalidateSeconds }]) => {
+    Object.entries(prerenderManifest.routes).forEach(([route, ssgRoute]) => {
+        const { initialRevalidateSeconds } = ssgRoute;
+        const trimmedPath = route === '/' ? 'index' : route.slice(1);
         if (initialRevalidateSeconds) {
             // Find all files used by ISR routes
-            const trimmedPath = route === '/' ? 'index' : route.slice(1);
             isrFiles.add(`${trimmedPath}.html`);
             isrFiles.add(`${trimmedPath}.json`);
+            isrFiles.add(`${trimmedPath}.rsc`);
             if (initialRevalidateSeconds < constants_1.MINIMUM_REVALIDATE_SECONDS) {
                 shortRevalidateRoutes.push({ Route: route, Revalidate: initialRevalidateSeconds });
             }

package/lib/helpers/matchers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLocaleOptional = exports.stripLookahead = void 0;
+exports.makeLocaleOptional = exports.transformCaptureGroups = exports.stripLookahead = void 0;
 const regexp_tree_1 = require("regexp-tree");
 // The Go regexp lib doesn't support lookaheads, so we need to remove them
 const stripLookahead = (regex) => {
@@ -27,6 +27,9 @@ const stripLookahead = (regex) => {
     }
 };
 exports.stripLookahead = stripLookahead;
+// The Go regexp lib has alternative syntax for named capture groups
+const transformCaptureGroups = (regex) => regex.replace(/\(\?<\w+>/, '(');
+exports.transformCaptureGroups = transformCaptureGroups;
 const LOCALIZED_REGEX_PREFIX = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))';
 const OPTIONAL_REGEX_PREFIX = '(?:\\/(_next\\/data\\/[^/]{1,}))?(?:\\/([^/.]{1,}))?';
 // Make the locale section of the matcher regex optional

package/lib/helpers/redirects.js

@@ -6,6 +6,7 @@ const fs_extra_1 = require("fs-extra");
 const outdent_1 = require("outdent");
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
+const edge_1 = require("./edge");
 const files_1 = require("./files");
 const utils_1 = require("./utils");
 const matchesMiddleware = (middleware, route) => middleware.some((middlewarePath) => route.startsWith(middlewarePath));
@@ -52,7 +53,7 @@ const generateStaticRedirects = ({ netlifyConfig, nextConfig: { i18n, basePath }
 };
 exports.generateStaticRedirects = generateStaticRedirects;
 /**
- * Routes that match middleware need to always use the SSR function
+ * Routes that match origin middleware need to always use the SSR function
  * This generates a rewrite for every middleware in every locale, both with and without a splat
  */
 const generateMiddlewareRewrites = ({ basePath, middleware, i18n, buildId }) => {
@@ -79,11 +80,11 @@ const generateMiddlewareRewrites = ({ basePath, middleware, i18n, buildId }) =>
         // Flatten the array of arrays. Can't use flatMap as it might be 2 levels deep
         .flat(2));
 };
-const generateStaticIsrRewrites = ({ staticRouteEntries, basePath, i18n, buildId, middleware, }) => {
+const generateStaticIsrRewrites = ({ staticRouteEntries, basePath, i18n, buildId, middleware, appPathRoutes, }) => {
     const staticIsrRoutesThatMatchMiddleware = [];
     const staticRoutePaths = new Set();
     const staticIsrRewrites = [];
-    staticRouteEntries.forEach(([route, { initialRevalidateSeconds }]) => {
+    staticRouteEntries.forEach(([route, { initialRevalidateSeconds, dataRoute, srcRoute }]) => {
         if ((0, utils_1.isApiRoute)(route) || (0, utils_1.is404Route)(route, i18n)) {
             return;
         }
@@ -92,30 +93,40 @@ const generateStaticIsrRewrites = ({ staticRouteEntries, basePath, i18n, buildId
             // These can be ignored, as they're static files handled by the CDN
             return;
         }
+        // appDir routes are a different format, so we need to handle them differently
+        const isAppDir = (0, edge_1.isAppDirRoute)(srcRoute, appPathRoutes);
         // 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);
+        if ((i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) && (route.startsWith(`/${i18n.defaultLocale}/`) || route === `/${i18n.defaultLocale}`)) {
+            route = route.slice(i18n.defaultLocale.length + 1) || '/';
             staticRoutePaths.add(route);
             if (matchesMiddleware(middleware, route)) {
                 staticIsrRoutesThatMatchMiddleware.push(route);
             }
             staticIsrRewrites.push(...(0, utils_1.redirectsForNextRouteWithData)({
                 route,
-                dataRoute: (0, utils_1.routeToDataRoute)(route, buildId, i18n.defaultLocale),
+                dataRoute: isAppDir ? dataRoute : (0, utils_1.routeToDataRoute)(route, buildId, i18n.defaultLocale),
                 basePath,
                 to: constants_1.ODB_FUNCTION_PATH,
                 force: true,
             }));
         }
         else if (matchesMiddleware(middleware, route)) {
-            //  Routes that match middleware can't use the ODB
+            //  Routes that match origin middleware can't use the ODB. Edge middleware will always return false
             staticIsrRoutesThatMatchMiddleware.push(route);
         }
         else {
             // ISR routes use the ODB handler
             staticIsrRewrites.push(
             // No i18n, because the route is already localized
-            ...(0, utils_1.redirectsForNextRoute)({ route, basePath, to: constants_1.ODB_FUNCTION_PATH, force: true, buildId, i18n: null }));
+            ...(0, utils_1.redirectsForNextRoute)({
+                route,
+                basePath,
+                to: constants_1.ODB_FUNCTION_PATH,
+                force: true,
+                buildId,
+                dataRoute: isAppDir ? dataRoute : null,
+                i18n: null,
+            }));
         }
     });
     return {
@@ -127,7 +138,7 @@ const generateStaticIsrRewrites = ({ staticRouteEntries, basePath, i18n, buildId
 /**
  * Generate rewrites for all dynamic routes
  */
-const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, middleware, basePath, buildId, i18n, is404Isr, }) => {
+const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, middleware, basePath, buildId, i18n, is404Isr, appPathRoutes, }) => {
     const dynamicRewrites = [];
     const dynamicRoutesThatMatchMiddleware = [];
     dynamicRoutes.forEach((route) => {
@@ -138,6 +149,17 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
             if (matchesMiddleware(middleware, route.page)) {
                 dynamicRoutesThatMatchMiddleware.push(route.page);
             }
+            else if ((0, edge_1.isAppDirRoute)(route.page, appPathRoutes)) {
+                dynamicRewrites.push(...(0, utils_1.redirectsForNextRoute)({
+                    route: route.page,
+                    buildId,
+                    basePath,
+                    to: constants_1.ODB_FUNCTION_PATH,
+                    i18n,
+                    dataRoute: prerenderedDynamicRoutes[route.page].dataRoute,
+                    withData: true,
+                }));
+            }
             else if (prerenderedDynamicRoutes[route.page].fallback === false && !is404Isr) {
                 dynamicRewrites.push(...(0, utils_1.redirectsForNext404Route)({ route: route.page, buildId, basePath, i18n }));
             }
@@ -170,6 +192,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     ...(await (0, utils_1.getPreviewRewrites)({ basePath, appDir })));
     const middleware = await (0, files_1.getMiddleware)(netlifyConfig.build.publish);
     netlifyConfig.redirects.push(...generateMiddlewareRewrites({ basePath, i18n, middleware, buildId }));
+    const appPathRoutes = await (0, edge_1.loadAppPathRoutesManifest)(netlifyConfig);
     const staticRouteEntries = Object.entries(prerenderedStaticRoutes);
     const is404Isr = staticRouteEntries.some(([route, { initialRevalidateSeconds }]) => (0, utils_1.is404Route)(route, i18n) && initialRevalidateSeconds !== false);
     const routesThatMatchMiddleware = [];
@@ -179,6 +202,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
         i18n,
         buildId,
         middleware,
+        appPathRoutes,
     });
     routesThatMatchMiddleware.push(...staticIsrRoutesThatMatchMiddleware);
     netlifyConfig.redirects.push(...staticIsrRewrites);
@@ -199,6 +223,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
         buildId,
         i18n,
         is404Isr,
+        appPathRoutes,
     });
     netlifyConfig.redirects.push(...dynamicRewrites);
     routesThatMatchMiddleware.push(...dynamicRoutesThatMatchMiddleware);

package/lib/helpers/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRemotePatterns = exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNext404Route = exports.redirectsForNextRoute = exports.is404Route = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = exports.getFunctionNameForPage = void 0;
+exports.getRemotePatterns = exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNext404Route = exports.redirectsForNextRoute = exports.is404Route = exports.isApiRoute = exports.localizeRoute = exports.routeToDataRoute = exports.generateNetlifyRoutes = exports.toNetlifyRoute = exports.getFunctionNameForPage = void 0;
 const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
@@ -47,17 +47,17 @@ const toNetlifyRoute = (nextRoute) => {
         .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
 };
 exports.toNetlifyRoute = toNetlifyRoute;
-const netlifyRoutesForNextRouteWithData = ({ route, dataRoute }) => [
-    ...(0, exports.toNetlifyRoute)(dataRoute),
-    ...(0, exports.toNetlifyRoute)(route),
-];
-exports.netlifyRoutesForNextRouteWithData = netlifyRoutesForNextRouteWithData;
+const generateNetlifyRoutes = ({ route, dataRoute, withData = true, }) => [...(withData ? (0, exports.toNetlifyRoute)(dataRoute) : []), ...(0, exports.toNetlifyRoute)(route)];
+exports.generateNetlifyRoutes = generateNetlifyRoutes;
 const routeToDataRoute = (route, buildId, locale) => `/_next/data/${buildId}${locale ? `/${locale}` : ''}${route === '/' ? '/index' : route}.json`;
 exports.routeToDataRoute = routeToDataRoute;
-const netlifyRoutesForNextRoute = (route, buildId, i18n) => {
+// Default locale is served from root, not localized
+const localizeRoute = (route, locale, defaultLocale) => locale === defaultLocale ? route : `/${locale}${route}`;
+exports.localizeRoute = localizeRoute;
+const netlifyRoutesForNextRoute = ({ route, buildId, i18n, withData = true, dataRoute, }) => {
     var _a;
     if (!((_a = i18n === null || i18n === void 0 ? void 0 : i18n.locales) === null || _a === void 0 ? void 0 : _a.length)) {
-        return (0, exports.netlifyRoutesForNextRouteWithData)({ route, dataRoute: (0, exports.routeToDataRoute)(route, buildId) }).map((redirect) => ({
+        return (0, exports.generateNetlifyRoutes)({ route, dataRoute: dataRoute || (0, exports.routeToDataRoute)(route, buildId), withData }).map((redirect) => ({
             redirect,
             locale: false,
         }));
@@ -65,13 +65,14 @@ const netlifyRoutesForNextRoute = (route, buildId, i18n) => {
     const { locales, defaultLocale } = i18n;
     const routes = [];
     locales.forEach((locale) => {
-        // Data route is always localized
-        const dataRoute = (0, exports.routeToDataRoute)(route, buildId, locale);
-        routes.push(
-        // Default locale is served from root, not localized
-        ...(0, exports.netlifyRoutesForNextRouteWithData)({
-            route: locale === defaultLocale ? route : `/${locale}${route}`,
-            dataRoute,
+        // Data route is always localized, except for appDir
+        const localizedDataRoute = dataRoute
+            ? (0, exports.localizeRoute)(dataRoute, locale, defaultLocale)
+            : (0, exports.routeToDataRoute)(route, buildId, locale);
+        routes.push(...(0, exports.generateNetlifyRoutes)({
+            route: (0, exports.localizeRoute)(route, locale, defaultLocale),
+            dataRoute: localizedDataRoute,
+            withData,
         }).map((redirect) => ({
             redirect,
             locale,
@@ -83,21 +84,21 @@ const isApiRoute = (route) => route.startsWith('/api/') || route === '/api';
 exports.isApiRoute = isApiRoute;
 const is404Route = (route, i18n) => i18n ? i18n.locales.some((locale) => route === `/${locale}/404`) : route === '/404';
 exports.is404Route = is404Route;
-const redirectsForNextRoute = ({ route, buildId, basePath, to, i18n, status = 200, force = false, }) => netlifyRoutesForNextRoute(route, buildId, i18n).map(({ redirect }) => ({
+const redirectsForNextRoute = ({ route, buildId, basePath, to, i18n, status = 200, force = false, withData = true, dataRoute, }) => netlifyRoutesForNextRoute({ route, buildId, i18n, withData, dataRoute }).map(({ redirect }) => ({
     from: `${basePath}${redirect}`,
     to,
     status,
     force,
 }));
 exports.redirectsForNextRoute = redirectsForNextRoute;
-const redirectsForNext404Route = ({ route, buildId, basePath, i18n, force = false, }) => netlifyRoutesForNextRoute(route, buildId, i18n).map(({ redirect, locale }) => ({
+const redirectsForNext404Route = ({ route, buildId, basePath, i18n, force = false, }) => netlifyRoutesForNextRoute({ route, buildId, i18n }).map(({ redirect, locale }) => ({
     from: `${basePath}${redirect}`,
     to: locale ? `${basePath}/server/pages/${locale}/404.html` : `${basePath}/server/pages/404.html`,
     status: 404,
     force,
 }));
 exports.redirectsForNext404Route = redirectsForNext404Route;
-const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status = 200, force = false, }) => (0, exports.netlifyRoutesForNextRouteWithData)({ route, dataRoute }).map((redirect) => ({
+const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status = 200, force = false, }) => (0, exports.generateNetlifyRoutes)({ route, dataRoute, withData: true }).map((redirect) => ({
     from: `${basePath}${redirect}`,
     to,
     status,

package/lib/templates/getApiHandler.js

@@ -97,7 +97,7 @@ const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '
   const { Server } = require("http");
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
-  const { getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
+  const { getMultiValueHeaders, getNextServer } = require('./handlerUtils')
 
   ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `const { schedule } = require("@netlify/functions")` : ''}
 

package/lib/templates/getHandler.js

@@ -10,7 +10,7 @@ const path = require('path');
 // eslint-disable-next-line n/prefer-global/url, n/prefer-global/url-search-params
 const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node-bridge/bridge');
-const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, getNextServer, } = require('./handlerUtils');
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, getNextServer, normalizePath, } = require('./handlerUtils');
 // We return a function and then call `toString()` on it to serialise it as the launcher function
 // eslint-disable-next-line max-params
 const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
@@ -79,8 +79,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
         if (prefetchResponse) {
             return prefetchResponse;
         }
-        // Ensure that paths are encoded - but don't double-encode them
-        event.path = new URL(event.rawUrl).pathname;
+        event.path = normalizePath(event);
         // 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;
@@ -99,7 +98,7 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
                 headers: multiValueHeaders,
                 statusCode: result.statusCode,
             };
-            console.log('Origin response:', JSON.stringify(response, null, 2));
+            console.log('Next server response:', JSON.stringify(response, null, 2));
         }
         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;
@@ -142,7 +141,7 @@ const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '..
   const { promises } = require("fs");
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
-  const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, getNextServer } = require('./handlerUtils')
+  const { augmentFsModule, getMaxAge, getMultiValueHeaders, getPrefetchResponse, getNextServer, normalizePath } = require('./handlerUtils')
 
   ${isODB ? `const { builder } = require("@netlify/functions")` : ''}
   const { config }  = require("${publishDir}/required-server-files.json")

package/lib/templates/handlerUtils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPrefetchResponse = exports.getNextServer = exports.augmentFsModule = exports.getMultiValueHeaders = exports.getMaxAge = exports.downloadFile = void 0;
+exports.normalizePath = exports.getPrefetchResponse = exports.getNextServer = exports.augmentFsModule = exports.getMultiValueHeaders = exports.getMaxAge = exports.downloadFile = void 0;
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
@@ -191,3 +191,18 @@ const getPrefetchResponse = (event, mode) => {
     return false;
 };
 exports.getPrefetchResponse = getPrefetchResponse;
+const normalizePath = (event) => {
+    var _a;
+    if ((_a = event.headers) === null || _a === void 0 ? void 0 : _a.rsc) {
+        const originalPath = event.headers['x-rsc-route'];
+        if (originalPath) {
+            if (event.headers['x-next-debug-logging']) {
+                console.log('Original path:', originalPath);
+            }
+            return originalPath;
+        }
+    }
+    // Ensure that paths are encoded - but don't double-encode them
+    return new URL(event.rawUrl).pathname;
+};
+exports.normalizePath = normalizePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.30.0",
+  "version": "4.30.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [
@@ -36,7 +36,7 @@
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^29.4.1",
+    "@netlify/build": "^29.5.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",

package/src/templates/edge/function-runtime.ts

@@ -0,0 +1,23 @@
+import type { Context } from 'https://edge.netlify.com'
+// Available at build time
+import edgeFunction from './bundle.js'
+import { buildNextRequest, buildResponse, redirectTrailingSlash } from '../edge-shared/utils.ts'
+import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
+
+const handler = async (req: Request, context: Context) => {
+  const url = new URL(req.url)
+  const redirect = redirectTrailingSlash(url, nextConfig.trailingSlash)
+  if (redirect) {
+    return redirect
+  }
+  const request = buildNextRequest(req, context, nextConfig)
+  try {
+    const result = await edgeFunction({ request })
+    return buildResponse({ result, request: req, context })
+  } catch (error) {
+    console.error(error)
+    return new Response(error.message, { status: 500 })
+  }
+}
+
+export default handler

package/src/templates/edge/{runtime.ts → middleware-runtime.ts}

@@ -1,49 +1,13 @@
 import type { Context } from 'https://edge.netlify.com'
 // Available at build time
 import matchers from './matchers.json' assert { type: 'json' }
-import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
 import edgeFunction from './bundle.js'
-import { buildResponse } from '../edge-shared/utils.ts'
+import { buildNextRequest, buildResponse } from '../edge-shared/utils.ts'
 import { getMiddlewareRouteMatcher, MiddlewareRouteMatch, searchParamsToUrlQuery } from '../edge-shared/next-utils.ts'
+import nextConfig from '../edge-shared/nextConfig.json' assert { type: 'json' }
 
 const matchesMiddleware: MiddlewareRouteMatch = getMiddlewareRouteMatcher(matchers || [])
 
-export interface FetchEventResult {
-  response: Response
-  waitUntil: Promise<any>
-}
-
-export interface I18NConfig {
-  defaultLocale: string
-  localeDetection?: false
-  locales: string[]
-}
-
-export interface RequestData {
-  geo?: {
-    city?: string
-    country?: string
-    region?: string
-    latitude?: string
-    longitude?: string
-    timezone?: string
-  }
-  headers: Record<string, string>
-  ip?: string
-  method: string
-  nextConfig?: {
-    basePath?: string
-    i18n?: I18NConfig | null
-    trailingSlash?: boolean
-  }
-  page?: {
-    name?: string
-    params?: { [key: string]: string }
-  }
-  url: string
-  body?: ReadableStream<Uint8Array>
-}
-
 export interface RequestContext {
   request: Request
   context: Context
@@ -70,15 +34,6 @@ const handler = async (req: Request, context: Context) => {
     return
   }
 
-  const geo: RequestData['geo'] = {
-    country: context.geo.country?.code,
-    region: context.geo.subdivision?.code,
-    city: context.geo.city,
-    latitude: context.geo.latitude?.toString(),
-    longitude: context.geo.longitude?.toString(),
-    timezone: context.geo.timezone,
-  }
-
   const requestId = req.headers.get('x-nf-request-id')
   if (!requestId) {
     console.error('Missing x-nf-request-id header')
@@ -89,15 +44,7 @@ const handler = async (req: Request, context: Context) => {
     })
   }
 
-  const request: RequestData = {
-    headers: Object.fromEntries(req.headers.entries()),
-    geo,
-    url: req.url,
-    method: req.method,
-    ip: context.ip,
-    body: req.body ?? undefined,
-    nextConfig,
-  }
+  const request = buildNextRequest(req, context, nextConfig)
 
   try {
     const result = await edgeFunction({ request })

package/src/templates/edge/next-dev.js

@@ -5,6 +5,7 @@ import { buildResponse } from '../edge-shared/utils.ts'
 
 globalThis.NFRequestContextMap ||= new Map()
 globalThis.__dirname = fromFileUrl(new URL('./', import.meta.url)).slice(0, -1)
+globalThis.process ||= { env: Deno.env.toObject() }
 
 // Next.js uses this extension to the Headers API implemented by Cloudflare workerd
 if (!('getAll' in Headers.prototype)) {

package/src/templates/edge/rsc-data.ts

@@ -0,0 +1,5 @@
+import prerenderManifest from '../edge-shared/prerender-manifest.json' assert { type: 'json' }
+import { getRscDataRouter, PrerenderManifest } from '../edge-shared/rsc-data.ts'
+
+const handler = getRscDataRouter(prerenderManifest as PrerenderManifest)
+export default handler

package/src/templates/edge-shared/nextConfig.json

@@ -0,0 +1,3 @@
+{
+  "trailingSlash": true
+}

package/src/templates/edge-shared/prerender-manifest.json

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "routes": {},
+  "dynamicRoutes": {},
+  "notFoundRoutes": [],
+  "preview": {}
+}

package/src/templates/edge-shared/rsc-data.ts

@@ -0,0 +1,74 @@
+import type { EdgeFunction } from 'https://edge.netlify.com'
+
+export declare type SsgRoute = {
+  initialRevalidateSeconds: number | false
+  srcRoute: string | null
+  dataRoute: string
+}
+export declare type DynamicSsgRoute = {
+  routeRegex: string
+  fallback: string | null | false
+  dataRoute: string
+  dataRouteRegex: string
+}
+export declare type PrerenderManifest = {
+  version: 3
+  routes: {
+    [route: string]: SsgRoute
+  }
+  dynamicRoutes: {
+    [route: string]: DynamicSsgRoute
+  }
+  notFoundRoutes: string[]
+}
+
+const noop = () => {}
+
+// Ensure that routes with and without a trailing slash map to different ODB paths
+const rscifyPath = (route: string) => {
+  if (route.endsWith('/')) {
+    return route.slice(0, -1) + '.rsc/'
+  }
+  return route + '.rsc'
+}
+
+export const getRscDataRouter = ({ routes: staticRoutes, dynamicRoutes }: PrerenderManifest): EdgeFunction => {
+  const staticRouteSet = new Set(
+    Object.entries(staticRoutes)
+      .filter(([, { dataRoute }]) => dataRoute.endsWith('.rsc'))
+      .map(([route]) => route),
+  )
+
+  const dynamicRouteMatcher = Object.values(dynamicRoutes)
+    .filter(({ dataRoute }) => dataRoute.endsWith('.rsc'))
+    .map(({ routeRegex }) => new RegExp(routeRegex))
+
+  const matchesDynamicRscDataRoute = (pathname: string) => {
+    return dynamicRouteMatcher.some((matcher) => matcher.test(pathname))
+  }
+
+  const matchesStaticRscDataRoute = (pathname: string) => {
+    const key = pathname.endsWith('/') ? pathname.slice(0, -1) : pathname
+    return staticRouteSet.has(key)
+  }
+
+  const matchesRscRoute = (pathname: string) => {
+    return matchesStaticRscDataRoute(pathname) || matchesDynamicRscDataRoute(pathname)
+  }
+
+  return (request, context) => {
+    const debug = request.headers.has('x-next-debug-logging')
+    const log = debug ? (...args: unknown[]) => console.log(...args) : noop
+    const url = new URL(request.url)
+    // If this is a static RSC request, rewrite to the data route
+    if (request.headers.get('rsc') === '1') {
+      log('Is rsc request')
+      if (matchesRscRoute(url.pathname)) {
+        request.headers.set('x-rsc-route', url.pathname)
+        const target = rscifyPath(url.pathname)
+        log('Rewriting to', target)
+        return context.rewrite(target)
+      }
+    }
+  }
+}

package/src/templates/edge-shared/utils.test.ts

@@ -1,6 +1,6 @@
 import { assertEquals } from 'https://deno.land/std@0.167.0/testing/asserts.ts'
 import { beforeEach, describe, it } from 'https://deno.land/std@0.167.0/testing/bdd.ts'
-import { updateModifiedHeaders, FetchEventResult } from './utils.ts'
+import { redirectTrailingSlash, updateModifiedHeaders } from './utils.ts'
 
 describe('updateModifiedHeaders', () => {
   it("does not modify the headers if 'x-middleware-override-headers' is not found", () => {
@@ -62,3 +62,53 @@ describe('updateModifiedHeaders', () => {
     })
   })
 })
+
+describe('trailing slash redirects', () => {
+  it('adds a trailing slash to the pathn if trailingSlash is enabled', () => {
+    const url = new URL('https://example.com/foo')
+    const result = redirectTrailingSlash(url, true)
+    assertEquals(result?.status, 308)
+    assertEquals(result?.headers.get('location'), 'https://example.com/foo/')
+  })
+
+  it("doesn't add a trailing slash if trailingSlash is false", () => {
+    const url = new URL('https://example.com/foo')
+    const result = redirectTrailingSlash(url, false)
+    assertEquals(result, undefined)
+  })
+
+  it("doesn't add a trailing slash if the path is a file", () => {
+    const url = new URL('https://example.com/foo.txt')
+    const result = redirectTrailingSlash(url, true)
+    assertEquals(result, undefined)
+  })
+  it('adds a trailing slash if there is a dot in the path', () => {
+    const url = new URL('https://example.com/foo.bar/baz')
+    const result = redirectTrailingSlash(url, true)
+    assertEquals(result?.status, 308)
+    assertEquals(result?.headers.get('location'), 'https://example.com/foo.bar/baz/')
+  })
+  it("doesn't add a trailing slash if the path is /", () => {
+    const url = new URL('https://example.com/')
+    const result = redirectTrailingSlash(url, true)
+    assertEquals(result, undefined)
+  })
+  it('removes a trailing slash from the path if trailingSlash is false', () => {
+    const url = new URL('https://example.com/foo/')
+    const result = redirectTrailingSlash(url, false)
+    assertEquals(result?.status, 308)
+    assertEquals(result?.headers.get('location'), 'https://example.com/foo')
+  })
+  it("doesn't remove a trailing slash if trailingSlash is true", () => {
+    const url = new URL('https://example.com/foo/')
+    const result = redirectTrailingSlash(url, true)
+    assertEquals(result, undefined)
+  })
+
+  it('removes a trailing slash from the path if the path is a file', () => {
+    const url = new URL('https://example.com/foo.txt/')
+    const result = redirectTrailingSlash(url, false)
+    assertEquals(result?.status, 308)
+    assertEquals(result?.headers.get('location'), 'https://example.com/foo.txt')
+  })
+})

package/src/templates/edge-shared/utils.ts

@@ -56,6 +56,37 @@ interface MiddlewareRequest {
   rewrite(destination: string | URL, init?: ResponseInit): Response
 }
 
+export interface I18NConfig {
+  defaultLocale: string
+  localeDetection?: false
+  locales: string[]
+}
+
+export interface RequestData {
+  geo?: {
+    city?: string
+    country?: string
+    region?: string
+    latitude?: string
+    longitude?: string
+    timezone?: string
+  }
+  headers: Record<string, string>
+  ip?: string
+  method: string
+  nextConfig?: {
+    basePath?: string
+    i18n?: I18NConfig | null
+    trailingSlash?: boolean
+  }
+  page?: {
+    name?: string
+    params?: { [key: string]: string }
+  }
+  url: string
+  body?: ReadableStream<Uint8Array>
+}
+
 function isMiddlewareRequest(response: Response | MiddlewareRequest): response is MiddlewareRequest {
   return 'originalRequest' in response
 }
@@ -90,6 +121,34 @@ export function updateModifiedHeaders(requestHeaders: Headers, responseHeaders:
   responseHeaders.delete('x-middleware-override-headers')
 }
 
+export const buildNextRequest = (
+  request: Request,
+  context: Context,
+  nextConfig?: RequestData['nextConfig'],
+): RequestData => {
+  const { url, method, body, headers } = request
+
+  const { country, subdivision, city, latitude, longitude, timezone } = context.geo
+
+  const geo: RequestData['geo'] = {
+    country: country?.code,
+    region: subdivision?.code,
+    city,
+    latitude: latitude?.toString(),
+    longitude: longitude?.toString(),
+    timezone,
+  }
+
+  return {
+    headers: Object.fromEntries(headers.entries()),
+    geo,
+    url,
+    method,
+    ip: context.ip,
+    body: body ?? undefined,
+    nextConfig,
+  }
+}
 export const buildResponse = async ({
   result,
   request,
@@ -196,3 +255,19 @@ export const buildResponse = async ({
   }
   return res
 }
+
+export const redirectTrailingSlash = (url: URL, trailingSlash: boolean): Response | undefined => {
+  const { pathname } = url
+  if (pathname === '/') {
+    return
+  }
+  if (!trailingSlash && pathname.endsWith('/')) {
+    url.pathname = pathname.slice(0, -1)
+    return Response.redirect(url, 308)
+  }
+  // Add a slash, unless there's a file extension
+  if (trailingSlash && !pathname.endsWith('/') && !pathname.split('/').pop()?.includes('.')) {
+    url.pathname = `${pathname}/`
+    return Response.redirect(url, 308)
+  }
+}