@netlify/plugin-nextjs 4.27.2 → 4.28.1

package/lib/helpers/edge.js

@@ -12,6 +12,7 @@ const destr_1 = __importDefault(require("destr"));
 const fs_extra_1 = require("fs-extra");
 const outdent_1 = require("outdent");
 const config_1 = require("./config");
+const matchers_1 = require("./matchers");
 const loadMiddlewareManifest = (netlifyConfig) => {
     const middlewarePath = (0, path_1.resolve)(netlifyConfig.build.publish, 'server', 'middleware-manifest.json');
     if (!(0, fs_1.existsSync)(middlewarePath)) {
@@ -28,13 +29,33 @@ const sanitizeName = (name) => `next_${name.replace(/\W/g, '_')}`;
  * Initialization added to the top of the edge function bundle
  */
 const preamble = /* js */ `
-
-globalThis.process = { env: {...Deno.env.toObject(), NEXT_RUNTIME: 'edge', 'NEXT_PRIVATE_MINIMAL_MODE': '1' } }
-let _ENTRIES = {}
+import {
+  decode as _base64Decode,
+} from "https://deno.land/std@0.159.0/encoding/base64.ts";
 // Deno defines "window", but naughty libraries think this means it's a browser
 delete globalThis.window
+globalThis.process = { env: {...Deno.env.toObject(), NEXT_RUNTIME: 'edge', 'NEXT_PRIVATE_MINIMAL_MODE': '1' } }
 // Next uses "self" as a function-scoped global-like object
 const self = {}
+let _ENTRIES = {}
+
+//  Next uses blob: urls to refer to local assets, so we need to intercept these
+const _fetch = globalThis.fetch
+const fetch = async (url, init) => {
+  try {
+    if (typeof url === 'object' && url.href?.startsWith('blob:')) {
+      const key = url.href.slice(5)
+      if (key in _ASSETS) {
+        return new Response(_base64Decode(_ASSETS[key]))
+      }
+    }
+    return await _fetch(url, init)
+  } catch (error) {
+    console.error(error)
+    throw error
+  }
+}
+
 `;
 // Slightly different spacing in different versions!
 const IMPORT_UNSUPPORTED = [
@@ -47,6 +68,19 @@ const IMPORT_UNSUPPORTED = [
 const getMiddlewareBundle = async ({ edgeFunctionDefinition, netlifyConfig, }) => {
     const { publish } = netlifyConfig.build;
     const chunks = [preamble];
+    if ('wasm' in edgeFunctionDefinition) {
+        for (const { name, filePath } of edgeFunctionDefinition.wasm) {
+            const wasm = await fs_1.promises.readFile((0, path_1.join)(publish, filePath));
+            chunks.push(`const ${name} = _base64Decode(${JSON.stringify(wasm.toString('base64'))}).buffer`);
+        }
+    }
+    if ('assets' in edgeFunctionDefinition) {
+        chunks.push(`const _ASSETS = {}`);
+        for (const { name, filePath } of edgeFunctionDefinition.assets) {
+            const wasm = await fs_1.promises.readFile((0, path_1.join)(publish, filePath));
+            chunks.push(`_ASSETS[${JSON.stringify(name)}] = ${JSON.stringify(wasm.toString('base64'))}`);
+        }
+    }
     for (const file of edgeFunctionDefinition.files) {
         const filePath = (0, path_1.join)(publish, file);
         let data = await fs_1.promises.readFile(filePath, 'utf8');
@@ -61,7 +95,7 @@ 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, }) => {
+const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, netlifyConfig, nextConfig, }) => {
     const name = sanitizeName(edgeFunctionDefinition.name);
     const edgeFunctionDir = (0, path_1.join)(edgeFunctionRoot, name);
     const bundle = await getMiddlewareBundle({
@@ -80,13 +114,19 @@ const writeEdgeFunction = async ({ edgeFunctionDefinition, edgeFunctionRoot, net
     if ('regexp' in edgeFunctionDefinition) {
         matchers.push({ regexp: edgeFunctionDefinition.regexp });
     }
+    else if (nextConfig.i18n) {
+        matchers.push(...edgeFunctionDefinition.matchers.map((matcher) => ({
+            ...matcher,
+            regexp: (0, matchers_1.makeLocaleOptional)(matcher.regexp),
+        })));
+    }
     else {
         matchers.push(...edgeFunctionDefinition.matchers);
     }
     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 = matcher.regexp;
+        const pattern = (0, matchers_1.stripLookahead)(matcher.regexp);
         return { function: name, pattern, name: edgeFunctionDefinition.name };
     });
 };
@@ -155,6 +195,7 @@ const writeEdgeFunctions = async (netlifyConfig) => {
                 edgeFunctionDefinition,
                 edgeFunctionRoot,
                 netlifyConfig,
+                nextConfig,
             });
             manifest.functions.push(...functionDefinitions);
         }
@@ -167,6 +208,7 @@ const writeEdgeFunctions = async (netlifyConfig) => {
                     edgeFunctionDefinition,
                     edgeFunctionRoot,
                     netlifyConfig,
+                    nextConfig,
                 });
                 manifest.functions.push(...functionDefinitions);
             }

package/lib/helpers/matchers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLocaleOptional = 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) => {
+    // Early return if there's no lookahead
+    if (!(regex === null || regex === void 0 ? void 0 : regex.includes('(?!'))) {
+        return regex;
+    }
+    try {
+        // Parse the regexp into an AST
+        const re = (0, regexp_tree_1.transform)(`/${regex}/`, {
+            Assertion(path) {
+                // Remove the lookahead
+                if (path.node.kind === 'Lookahead') {
+                    path.remove();
+                }
+            },
+        });
+        // Strip the leading and trailing slashes
+        return re.toString().slice(1, -1);
+    }
+    catch {
+        //  Failed to parse regex, so return unchanged
+        return regex;
+    }
+};
+exports.stripLookahead = stripLookahead;
+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
+const makeLocaleOptional = (regex) => regex.replace(LOCALIZED_REGEX_PREFIX, OPTIONAL_REGEX_PREFIX);
+exports.makeLocaleOptional = makeLocaleOptional;

package/lib/index.js

@@ -82,7 +82,9 @@ const plugin = {
                 await (0, config_1.updateRequiredServerFiles)(publish, config);
             }
             else {
-                const nextAuthUrl = `${process.env.DEPLOY_PRIME_URL}${basePath}`;
+                // Using the deploy prime url in production leads to issues because the unique deploy ID is part of the generated URL
+                // and will not match the expected URL in the callback URL of an OAuth application.
+                const nextAuthUrl = `${process.env.CONTEXT === 'production' ? process.env.URL : process.env.DEPLOY_PRIME_URL}${basePath}`;
                 console.log(`NextAuth package detected, setting NEXTAUTH_URL environment variable to ${nextAuthUrl}`);
                 config.config.env.NEXTAUTH_URL = nextAuthUrl;
                 await (0, config_1.updateRequiredServerFiles)(publish, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.27.2",
+  "version": "4.28.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [
@@ -28,18 +28,19 @@
     "p-limit": "^3.1.0",
     "pathe": "^0.2.0",
     "pretty-bytes": "^5.6.0",
+    "regexp-tree": "^0.1.24",
     "semver": "^7.3.5",
     "slash": "^3.0.0",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
     "@delucis/if-env": "^1.1.2",
-    "@netlify/build": "^28.1.0",
+    "@netlify/build": "^28.1.2",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.4.1",
     "@types/merge-stream": "^1.1.2",
     "@types/node": "^17.0.25",
-    "next": "^12.3.0",
+    "next": "^12.3.2-canary.43",
     "npm-run-all": "^4.1.5",
     "typescript": "^4.6.3"
   },

package/src/templates/edge/bundle.js

@@ -2,6 +2,6 @@
  * This placeholder is replaced with the compiled Next.js bundle at build time
  * @param {Object} props
  * @param {import("./runtime.ts").RequestData} props.request
- * @returns {Promise<import("./utils.ts").FetchEventResult>}
+ * @returns {Promise<import("../edge-shared/utils.ts").FetchEventResult>}
  */
 export default async ({ request }) => {}

package/src/templates/edge/runtime.ts

@@ -33,7 +33,7 @@ export interface RequestData {
     name?: string
     params?: { [key: string]: string }
   }
-  url: URL
+  url: string
   body?: ReadableStream<Uint8Array>
 }
 
@@ -82,7 +82,7 @@ const handler = async (req: Request, context: Context) => {
   const request: RequestData = {
     headers: Object.fromEntries(req.headers.entries()),
     geo,
-    url,
+    url: req.url,
     method: req.method,
     ip: context.ip,
     body: req.body ?? undefined,

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

@@ -83,7 +83,10 @@ export const buildResponse = async ({
       const transformed = response.dataTransforms.reduce((prev, transform) => {
         return transform(prev)
       }, props)
-      return new Response(JSON.stringify(transformed), response)
+      const body = JSON.stringify(transformed)
+      const headers = new Headers(response.headers)
+      headers.set('content-length', String(body.length))
+      return new Response(body, { ...response, headers })
     }
     // This var will hold the contents of the script tag
     let buffer = ''