@netlify/plugin-nextjs 4.30.5-setcookie.0 → 4.32.0

package/lib/helpers/edge.js

@@ -199,101 +199,108 @@ const writeEdgeFunctions = async ({ netlifyConfig, routesManifest, }) => {
     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)) {
-        console.log('Using Netlify Edge Functions for image format detection. Set env var "NEXT_DISABLE_EDGE_IMAGES=true" to disable.');
-        const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, 'ipx');
-        await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
-        await copyEdgeSourceFile({ edgeFunctionDir, file: 'ipx.ts', target: 'index.ts' });
-        await (0, fs_extra_1.copyFile)((0, path_1.join)('.netlify', 'functions-internal', '_ipx', 'imageconfig.json'), (0, path_1.join)(edgeFunctionDir, 'imageconfig.json'));
-        manifest.functions.push({
-            function: 'ipx',
-            name: 'next/image handler',
-            path: '/_next/image*',
-        });
+    // early return if edge is disabled
+    if ((0, destr_1.default)(process.env.NEXT_DISABLE_NETLIFY_EDGE)) {
+        console.log('Environment variable NEXT_DISABLE_NETLIFY_EDGE has been set, skipping Netlify Edge Function creation.');
+        return;
+    }
+    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");
+        return;
     }
-    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),
+    let usesEdge = false;
+    for (const middleware of middlewareManifest.sortedMiddleware) {
+        usesEdge = true;
+        const edgeFunctionDefinition = middlewareManifest.middleware[middleware];
+        const functionName = sanitizeName(edgeFunctionDefinition.name);
+        const matchers = generateEdgeFunctionMiddlewareMatchers({
+            edgeFunctionDefinition,
+            edgeFunctionRoot,
+            nextConfig,
         });
-        manifest.functions.push(...rscFunctions);
-        const middlewareManifest = await (0, exports.loadMiddlewareManifest)(netlifyConfig);
-        if (!middlewareManifest) {
-            console.error("Couldn't find the middleware manifest");
-            return;
-        }
-        let usesEdge = false;
-        for (const middleware of middlewareManifest.sortedMiddleware) {
+        await writeEdgeFunction({
+            edgeFunctionDefinition,
+            edgeFunctionRoot,
+            netlifyConfig,
+            functionName,
+            matchers,
+            middleware: true,
+        });
+        manifest.functions.push(...matchers.map((matcher) => middlewareMatcherToEdgeFunctionDefinition(matcher, functionName)));
+    }
+    // Functions (i.e. not middleware, but edge SSR and API routes)
+    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);
+        // A map of all route pages to their page regex. This is used for pages dir and appDir.
+        const pageRegexMap = new Map([...(routesManifest.dynamicRoutes || []), ...(routesManifest.staticRoutes || [])].map((route) => [
+            route.page,
+            route.regex,
+        ]));
+        // Create a map of pages-dir routes to their data route regex (appDir uses the same route as the HTML)
+        const dataRoutesMap = new Map([...(routesManifest.dataRoutes || [])].map((route) => [route.page, route.dataRouteRegex]));
+        for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
             usesEdge = true;
-            const edgeFunctionDefinition = middlewareManifest.middleware[middleware];
             const functionName = sanitizeName(edgeFunctionDefinition.name);
-            const matchers = generateEdgeFunctionMiddlewareMatchers({
-                edgeFunctionDefinition,
-                edgeFunctionRoot,
-                nextConfig,
-            });
             await writeEdgeFunction({
                 edgeFunctionDefinition,
                 edgeFunctionRoot,
                 netlifyConfig,
                 functionName,
-                matchers,
-                middleware: true,
             });
-            manifest.functions.push(...matchers.map((matcher) => middlewareMatcherToEdgeFunctionDefinition(matcher, functionName)));
-        }
-        // Functions (i.e. not middleware, but edge SSR and API routes)
-        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);
-            // A map of all route pages to their page regex. This is used for pages dir and appDir.
-            const pageRegexMap = new Map([...(routesManifest.dynamicRoutes || []), ...(routesManifest.staticRoutes || [])].map((route) => [
-                route.page,
-                route.regex,
-            ]));
-            // Create a map of pages-dir routes to their data route regex (appDir uses the same route as the HTML)
-            const dataRoutesMap = new Map([...(routesManifest.dataRoutes || [])].map((route) => [route.page, route.dataRouteRegex]));
-            for (const edgeFunctionDefinition of Object.values(middlewareManifest.functions)) {
-                usesEdge = true;
-                const functionName = sanitizeName(edgeFunctionDefinition.name);
-                await writeEdgeFunction({
-                    edgeFunctionDefinition,
-                    edgeFunctionRoot,
-                    netlifyConfig,
-                    functionName,
-                });
-                const pattern = (0, exports.getEdgeFunctionPatternForPage)({
-                    edgeFunctionDefinition,
-                    pageRegexMap,
-                    appPathRoutesManifest,
-                });
+            const pattern = (0, exports.getEdgeFunctionPatternForPage)({
+                edgeFunctionDefinition,
+                pageRegexMap,
+                appPathRoutesManifest,
+            });
+            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,
+            });
+            // pages-dir page routes also have a data route. If there's a match, add an entry mapping that to the function too
+            const dataRoute = dataRoutesMap.get(edgeFunctionDefinition.page);
+            if (dataRoute) {
                 manifest.functions.push({
                     function: functionName,
                     name: edgeFunctionDefinition.name,
-                    pattern,
-                    // cache: "manual" is currently experimental, so we restrict it to sites that use experimental appDir
+                    pattern: dataRoute,
                     cache: usesAppDir ? 'manual' : undefined,
                 });
-                // pages-dir page routes also have a data route. If there's a match, add an entry mapping that to the function too
-                const dataRoute = dataRoutesMap.get(edgeFunctionDefinition.page);
-                if (dataRoute) {
-                    manifest.functions.push({
-                        function: functionName,
-                        name: edgeFunctionDefinition.name,
-                        pattern: dataRoute,
-                        cache: usesAppDir ? 'manual' : undefined,
-                    });
-                }
             }
         }
-        if (usesEdge) {
-            console.log((0, outdent_1.outdent) `
-        ✨ Deploying middleware and functions to ${(0, chalk_1.greenBright) `Netlify Edge Functions`} ✨
-        This feature is in beta. Please share your feedback here: https://ntl.fyi/next-netlify-edge
-      `);
-        }
+    }
+    if ((0, destr_1.default)(process.env.NEXT_FORCE_EDGE_IMAGES) &&
+        !(0, destr_1.default)(process.env.NEXT_DISABLE_EDGE_IMAGES) &&
+        !(0, destr_1.default)(process.env.DISABLE_IPX)) {
+        usesEdge = true;
+        console.log('Using Netlify Edge Functions for image format detection. Set env var "NEXT_DISABLE_EDGE_IMAGES=true" to disable.');
+        const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, 'ipx');
+        await (0, fs_extra_1.ensureDir)(edgeFunctionDir);
+        await copyEdgeSourceFile({ edgeFunctionDir, file: 'ipx.ts', target: 'index.ts' });
+        await (0, fs_extra_1.copyFile)((0, path_1.join)('.netlify', 'functions-internal', '_ipx', 'imageconfig.json'), (0, path_1.join)(edgeFunctionDir, 'imageconfig.json'));
+        manifest.functions.push({
+            function: 'ipx',
+            name: 'next/image handler',
+            path: '/_next/image*',
+        });
+    }
+    else {
+        console.log('You are not using Netlify Edge Functions for image format detection. Set env var "NEXT_FORCE_EDGE_IMAGES=true" to enable.');
+    }
+    if (usesEdge) {
+        console.log((0, outdent_1.outdent) `
+      ✨ Deploying middleware and functions to ${(0, chalk_1.greenBright) `Netlify Edge Functions`} ✨
+      This feature is in beta. Please share your feedback here: https://ntl.fyi/next-netlify-edge
+    `);
     }
     await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionRoot, 'manifest.json'), manifest);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.30.5-setcookie.0",
+  "version": "4.32.0",
   "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.6.0",
+    "@netlify/build": "^29.6.7",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",

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

@@ -18,19 +18,6 @@ if (!('getAll' in Headers.prototype)) {
   }
 }
 
-// Check if a file exists, given a relative path
-const exists = async (relativePath) => {
-  const path = fromFileUrl(new URL(relativePath, import.meta.url))
-  try {
-    await Deno.stat(path)
-    return true
-  } catch (error) {
-    if (error instanceof Deno.errors.NotFound) {
-      return false
-    }
-    throw error
-  }
-}
 let idx = 0
 
 const handler = async (req, context) => {
@@ -45,14 +32,19 @@ const handler = async (req, context) => {
   // We don't want to just try importing and use that to test,
   // because that would also throw if there's an error in the middleware,
   // which we would want to surface not ignore.
-  if (await exists('../../middleware.js')) {
+  try {
     // We need to cache-bust the import because otherwise it will claim it
     // doesn't exist if the user creates it after the server starts
     const nextMiddleware = await import(`../../middleware.js#${idx++}`)
     middleware = nextMiddleware.middleware
-  } else {
-    //  No middleware, so we silently return
-    return
+  } catch (importError) {
+    // Error message is `Module not found "file://<path>/middleware.js#123456".` in Deno
+    if (importError.code === 'ERR_MODULE_NOT_FOUND' && importError.message.includes(`middleware.js#${idx}`)) {
+      //  No middleware, so we silently return
+      return
+    }
+
+    throw importError
   }
 
   //  This is the format expected by Next.js along with the timezone which we support.