@netlify/plugin-nextjs 5.12.1 → 5.13.1

package/dist/run/handlers/tracer.cjs

@@ -169,7 +169,7 @@ var __spreadArray = function(to, from, pack) {
 };
 var DiagComponentLogger = (
   /** @class */
-  function() {
+  (function() {
     function DiagComponentLogger2(props) {
       this._namespace = props.namespace || "DiagComponentLogger";
     }
@@ -209,7 +209,7 @@ var DiagComponentLogger = (
       return logProxy("verbose", this._namespace, args);
     };
     return DiagComponentLogger2;
-  }()
+  })()
 );
 function logProxy(funcName, namespace, args) {
   var logger = getGlobal("diag");
@@ -287,7 +287,7 @@ var __spreadArray2 = function(to, from, pack) {
 var API_NAME = "diag";
 var DiagAPI = (
   /** @class */
-  function() {
+  (function() {
     function DiagAPI2() {
       function _logProxy(funcName) {
         return function() {
@@ -346,7 +346,7 @@ var DiagAPI = (
       return this._instance;
     };
     return DiagAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/context/context.js
@@ -355,7 +355,7 @@ function createContextKey(description) {
 }
 var BaseContext = (
   /** @class */
-  /* @__PURE__ */ function() {
+  /* @__PURE__ */ (function() {
     function BaseContext2(parentContext) {
       var self = this;
       self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
@@ -374,7 +374,7 @@ var BaseContext = (
       };
     }
     return BaseContext2;
-  }()
+  })()
 );
 var ROOT_CONTEXT = new BaseContext();
 
@@ -407,7 +407,7 @@ var __spreadArray3 = function(to, from, pack) {
 };
 var NoopContextManager = (
   /** @class */
-  function() {
+  (function() {
     function NoopContextManager2() {
     }
     NoopContextManager2.prototype.active = function() {
@@ -430,7 +430,7 @@ var NoopContextManager = (
       return this;
     };
     return NoopContextManager2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/api/context.js
@@ -464,7 +464,7 @@ var API_NAME2 = "context";
 var NOOP_CONTEXT_MANAGER = new NoopContextManager();
 var ContextAPI = (
   /** @class */
-  function() {
+  (function() {
     function ContextAPI2() {
     }
     ContextAPI2.getInstance = function() {
@@ -498,7 +498,7 @@ var ContextAPI = (
       unregisterGlobal(API_NAME2, DiagAPI.instance());
     };
     return ContextAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
@@ -520,7 +520,7 @@ var INVALID_SPAN_CONTEXT = {
 // node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
 var NonRecordingSpan = (
   /** @class */
-  function() {
+  (function() {
     function NonRecordingSpan2(_spanContext) {
       if (_spanContext === void 0) {
         _spanContext = INVALID_SPAN_CONTEXT;
@@ -553,7 +553,7 @@ var NonRecordingSpan = (
     NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
     };
     return NonRecordingSpan2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
@@ -598,7 +598,7 @@ function wrapSpanContext(spanContext) {
 var contextApi = ContextAPI.getInstance();
 var NoopTracer = (
   /** @class */
-  function() {
+  (function() {
     function NoopTracer2() {
     }
     NoopTracer2.prototype.startSpan = function(name, options, context2) {
@@ -638,7 +638,7 @@ var NoopTracer = (
       return contextApi.with(contextWithSpanSet, fn, void 0, span);
     };
     return NoopTracer2;
-  }()
+  })()
 );
 function isSpanContext(spanContext) {
   return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
@@ -648,7 +648,7 @@ function isSpanContext(spanContext) {
 var NOOP_TRACER = new NoopTracer();
 var ProxyTracer = (
   /** @class */
-  function() {
+  (function() {
     function ProxyTracer2(_provider, name, version, options) {
       this._provider = _provider;
       this.name = name;
@@ -674,27 +674,27 @@ var ProxyTracer = (
       return this._delegate;
     };
     return ProxyTracer2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
 var NoopTracerProvider = (
   /** @class */
-  function() {
+  (function() {
     function NoopTracerProvider2() {
     }
     NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
       return new NoopTracer();
     };
     return NoopTracerProvider2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
 var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
 var ProxyTracerProvider = (
   /** @class */
-  function() {
+  (function() {
     function ProxyTracerProvider2() {
     }
     ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
@@ -713,7 +713,7 @@ var ProxyTracerProvider = (
       return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
     };
     return ProxyTracerProvider2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace/status.js
@@ -731,7 +731,7 @@ var context = ContextAPI.getInstance();
 var API_NAME3 = "trace";
 var TraceAPI = (
   /** @class */
-  function() {
+  (function() {
     function TraceAPI2() {
       this._proxyTracerProvider = new ProxyTracerProvider();
       this.wrapSpanContext = wrapSpanContext;
@@ -767,7 +767,7 @@ var TraceAPI = (
       this._proxyTracerProvider = new ProxyTracerProvider();
     };
     return TraceAPI2;
-  }()
+  })()
 );
 
 // node_modules/@opentelemetry/api/build/esm/trace-api.js
@@ -785,7 +785,7 @@ function wrapTracer(tracer2) {
 }
 var SugaredTracer = (
   /** @class */
-  function() {
+  (function() {
     function SugaredTracer2(tracer2) {
       this._tracer = tracer2;
       this.startSpan = tracer2.startSpan.bind(this._tracer);
@@ -803,7 +803,7 @@ var SugaredTracer = (
       return handleFn(span, opts, fn);
     };
     return SugaredTracer2;
-  }()
+  })()
 );
 function massageParams(arg, arg2, arg3) {
   var opts;

package/dist/run/next.cjs

@@ -540,7 +540,7 @@ ResponseCache.prototype.get = function get(...getArgs) {
   }
   return originalGet.apply(this, getArgs);
 };
-async function getMockedRequestHandler(...args) {
+async function getMockedRequestHandler(nextConfig, ...args) {
   const initContext = { initializingServer: true };
   const initAsyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
   const tracer = (0, import_tracer.getTracer)();
@@ -553,7 +553,7 @@ async function getMockedRequestHandler(...args) {
       } catch (error) {
         if (typeof path === "string" && path.endsWith(".html")) {
           const cacheStore = (0, import_storage.getMemoizedKeyValueStoreBackedByRegionalBlobStore)();
-          const relPath = (0, import_node_path.relative)((0, import_node_path.resolve)(".next/server/pages"), path);
+          const relPath = (0, import_node_path.relative)((0, import_node_path.resolve)(nextConfig.distDir, "server/pages"), path);
           const file = await cacheStore.get(relPath, "staticHtml.get");
           if (file !== null) {
             if (file.isFullyStaticPage) {

package/edge-runtime/lib/cjs.ts

@@ -0,0 +1,330 @@
+import { Module, createRequire } from 'node:module'
+import vm from 'node:vm'
+import { sep } from 'node:path'
+import { join, dirname, sep as posixSep } from 'node:path/posix'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const toPosixPath = (path: string) => path.split(sep).join(posixSep)
+
+type RegisteredModule = {
+  source: string
+  loaded: boolean
+  filepath: string
+  // lazily parsed json string
+  parsedJson?: any
+}
+type ModuleResolutions = (subpath: string) => string
+const registeredModules = new Map<string, RegisteredModule>()
+const memoizedPackageResolvers = new WeakMap<RegisteredModule, ModuleResolutions>()
+
+const require = createRequire(import.meta.url)
+
+let hookedIn = false
+
+function parseJson(matchedModule: RegisteredModule) {
+  if (matchedModule.parsedJson) {
+    return matchedModule.parsedJson
+  }
+
+  try {
+    const jsonContent = JSON.parse(matchedModule.source)
+    matchedModule.parsedJson = jsonContent
+    return jsonContent
+  } catch (error) {
+    throw new Error(`Failed to parse JSON module: ${matchedModule.filepath}`, { cause: error })
+  }
+}
+
+type Condition = string // 'import', 'require', 'default', 'node-addon' etc
+type SubpathMatcher = string
+type ConditionalTarget = { [key in Condition]: string | ConditionalTarget }
+type SubpathTarget = string | ConditionalTarget
+/**
+ * @example
+ * {
+ *   ".": "./main.js",
+ *   "./foo": {
+ *     "import": "./foo.js",
+ *     "require": "./foo.cjs"
+ *   }
+ * }
+ */
+type NormalizedExports = Record<SubpathMatcher, SubpathTarget | Record<Condition, SubpathTarget>>
+
+// https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L555
+function isConditionalExportsMainSugar(exports: any) {
+  if (typeof exports === 'string' || Array.isArray(exports)) {
+    return true
+  }
+  if (typeof exports !== 'object' || exports === null) {
+    return false
+  }
+
+  // not doing validation at this point, if the package.json was misconfigured
+  // we would not get to this point as it would throw when running `next build`
+  const keys = Object.keys(exports)
+  return keys.length > 0 && (keys[0] === '' || keys[0][0] !== '.')
+}
+
+// https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L671
+function patternKeyCompare(a: string, b: string) {
+  const aPatternIndex = a.indexOf('*')
+  const bPatternIndex = b.indexOf('*')
+  const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1
+  const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1
+  if (baseLenA > baseLenB) {
+    return -1
+  }
+  if (baseLenB > baseLenA) {
+    return 1
+  }
+  if (aPatternIndex === -1) {
+    return 1
+  }
+  if (bPatternIndex === -1) {
+    return -1
+  }
+  if (a.length > b.length) {
+    return -1
+  }
+  if (b.length > a.length) {
+    return 1
+  }
+  return 0
+}
+
+function applyWildcardMatch(target: string, bestMatchSubpath?: string) {
+  return bestMatchSubpath ? target.replace('*', bestMatchSubpath) : target
+}
+
+// https://github.com/nodejs/node/blob/323f19c18fea06b9234a0c945394447b077fe565/lib/internal/modules/helpers.js#L76
+const conditions = new Set(['require', 'node', 'node-addons', 'default'])
+
+// https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L480
+function matchConditions(target: SubpathTarget, bestMatchSubpath?: string) {
+  if (typeof target === 'string') {
+    return applyWildcardMatch(target, bestMatchSubpath)
+  }
+
+  if (Array.isArray(target) && target.length > 0) {
+    for (const targetItem of target) {
+      return matchConditions(targetItem, bestMatchSubpath)
+    }
+  }
+
+  if (typeof target === 'object' && target !== null) {
+    for (const [condition, targetValue] of Object.entries(target)) {
+      if (conditions.has(condition)) {
+        return matchConditions(targetValue, bestMatchSubpath)
+      }
+    }
+  }
+
+  throw new Error('Invalid package target')
+}
+
+function getPackageResolver(packageJsonMatchedModule: RegisteredModule) {
+  const memoized = memoizedPackageResolvers.get(packageJsonMatchedModule)
+  if (memoized) {
+    return memoized
+  }
+
+  // https://nodejs.org/api/packages.html#package-entry-points
+
+  const pkgJson = parseJson(packageJsonMatchedModule)
+
+  let exports: NormalizedExports | null = null
+  if (pkgJson.exports) {
+    // https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L590
+    exports = isConditionalExportsMainSugar(pkgJson.exports)
+      ? { '.': pkgJson.exports }
+      : pkgJson.exports
+  }
+
+  const resolveInPackage: ModuleResolutions = (subpath: string) => {
+    if (exports) {
+      const normalizedSubpath = subpath.length === 0 ? '.' : './' + subpath
+
+      // https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L594
+      // simple case with matching as-is
+      if (
+        normalizedSubpath in exports &&
+        !normalizedSubpath.includes('*') &&
+        !normalizedSubpath.endsWith('/')
+      ) {
+        return matchConditions(exports[normalizedSubpath])
+      }
+
+      // https://github.com/nodejs/node/blob/6fd67ec6e3ccbdfcfa0300b9b742040a0607a4bc/lib/internal/modules/esm/resolve.js#L610
+      let bestMatchKey = ''
+      let bestMatchSubpath
+      for (const key of Object.keys(exports)) {
+        const patternIndex = key.indexOf('*')
+        if (patternIndex !== -1 && normalizedSubpath.startsWith(key.slice(0, patternIndex))) {
+          const patternTrailer = key.slice(patternIndex + 1)
+          if (
+            normalizedSubpath.length > key.length &&
+            normalizedSubpath.endsWith(patternTrailer) &&
+            patternKeyCompare(bestMatchKey, key) === 1 &&
+            key.lastIndexOf('*') === patternIndex
+          ) {
+            bestMatchKey = key
+            bestMatchSubpath = normalizedSubpath.slice(
+              patternIndex,
+              normalizedSubpath.length - patternTrailer.length,
+            )
+          }
+        }
+      }
+
+      if (bestMatchKey && typeof bestMatchSubpath === 'string') {
+        const matchedTarget = exports[bestMatchKey]
+        return matchConditions(matchedTarget, bestMatchSubpath)
+      }
+
+      // if exports are defined, they are source of truth and any imports not allowed by it will fail
+      throw new Error(`Cannot find module '${normalizedSubpath}'`)
+    }
+
+    if (subpath.length === 0 && pkgJson.main) {
+      return pkgJson.main
+    }
+
+    return subpath
+  }
+
+  memoizedPackageResolvers.set(packageJsonMatchedModule, resolveInPackage)
+
+  return resolveInPackage
+}
+
+function seedCJSModuleCacheAndReturnTarget(matchedModule: RegisteredModule, parent: Module) {
+  if (matchedModule.loaded) {
+    return matchedModule.filepath
+  }
+  const { source, filepath } = matchedModule
+
+  const mod = new Module(filepath)
+  mod.parent = parent
+  mod.filename = filepath
+  mod.path = dirname(filepath)
+  // @ts-expect-error - private untyped API
+  mod.paths = Module._nodeModulePaths(mod.path)
+  require.cache[filepath] = mod
+
+  try {
+    if (filepath.endsWith('.json')) {
+      Object.assign(mod.exports, parseJson(matchedModule))
+    } else {
+      const wrappedSource = `(function (exports, require, module, __filename, __dirname) { ${source}\n});`
+      const compiled = vm.runInThisContext(wrappedSource, {
+        filename: filepath,
+        lineOffset: 0,
+        displayErrors: true,
+      })
+      const modRequire = createRequire(pathToFileURL(filepath, { windows: false }))
+      compiled(mod.exports, modRequire, mod, filepath, dirname(filepath))
+    }
+    mod.loaded = matchedModule.loaded = true
+  } catch (error) {
+    throw new Error(`Failed to compile CJS module: ${filepath}`, { cause: error })
+  }
+
+  return filepath
+}
+
+// ideally require.extensions could be used, but it does NOT include '.cjs', so hardcoding instead
+const exts = ['.js', '.cjs', '.json']
+
+function tryWithExtensions(filename: string) {
+  let matchedModule = registeredModules.get(filename)
+  if (!matchedModule) {
+    for (const ext of exts) {
+      // require("./test") might resolve to ./test.js
+      const targetWithExt = filename + ext
+
+      matchedModule = registeredModules.get(targetWithExt)
+      if (matchedModule) {
+        break
+      }
+    }
+  }
+
+  return matchedModule
+}
+
+function tryMatchingWithIndex(target: string) {
+  let matchedModule = tryWithExtensions(target)
+  if (!matchedModule) {
+    // require("./test") might resolve to ./test/index.js
+    const indexTarget = join(target, 'index')
+    matchedModule = tryWithExtensions(indexTarget)
+  }
+
+  return matchedModule
+}
+
+export function registerCJSModules(baseUrl: URL, modules: Map<string, string>) {
+  const basePath = dirname(toPosixPath(fileURLToPath(baseUrl, { windows: false })))
+
+  for (const [filename, source] of modules.entries()) {
+    const target = join(basePath, filename)
+    registeredModules.set(target, { source, loaded: false, filepath: target })
+  }
+
+  if (!hookedIn) {
+    // @ts-expect-error - private untyped API
+    const original_resolveFilename = Module._resolveFilename.bind(Module)
+    // @ts-expect-error - private untyped API
+    Module._resolveFilename = (...args) => {
+      let target = args[0]
+      let isRelative = args?.[0].startsWith('.')
+
+      if (isRelative) {
+        // only handle relative require paths
+        const requireFrom = toPosixPath(args?.[1]?.filename)
+
+        target = join(dirname(requireFrom), args[0])
+      }
+
+      let matchedModule = tryMatchingWithIndex(target)
+
+      if (!isRelative && !target.startsWith('/')) {
+        const packageName = target.startsWith('@')
+          ? target.split('/').slice(0, 2).join('/')
+          : target.split('/')[0]
+        const moduleInPackagePath = target.slice(packageName.length + 1)
+
+        for (const nodeModulePathsRaw of args[1].paths) {
+          const nodeModulePaths = toPosixPath(nodeModulePathsRaw)
+          const potentialPackageJson = join(nodeModulePaths, packageName, 'package.json')
+
+          const maybePackageJson = registeredModules.get(potentialPackageJson)
+
+          let relativeTarget = moduleInPackagePath
+
+          if (maybePackageJson) {
+            const packageResolver = getPackageResolver(maybePackageJson)
+
+            relativeTarget = packageResolver(moduleInPackagePath)
+          }
+
+          const potentialPath = join(nodeModulePaths, packageName, relativeTarget)
+
+          matchedModule = tryMatchingWithIndex(potentialPath)
+          if (matchedModule) {
+            break
+          }
+        }
+      }
+
+      if (matchedModule) {
+        return seedCJSModuleCacheAndReturnTarget(matchedModule, args[1])
+      }
+
+      return original_resolveFilename(...args)
+    }
+
+    hookedIn = true
+  }
+}

package/edge-runtime/shim/node.js

@@ -0,0 +1,16 @@
+// NOTE: This is a fragment of a JavaScript program that will be inlined with
+// a Webpack bundle. You should not import this file from anywhere in the
+// application.
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+import { createRequire } from 'node:module' // used in dynamically generated part
+import process from 'node:process'
+
+import { registerCJSModules } from '../edge-runtime/lib/cjs.ts' // used in dynamically generated part
+
+globalThis.process = process
+
+globalThis.AsyncLocalStorage = AsyncLocalStorage
+
+// needed for path.relative and path.resolve to work
+Deno.cwd = () => ''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.12.1",
+  "version": "5.13.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",
@@ -9,6 +9,8 @@
     "edge-runtime",
     "!edge-runtime/deno.json",
     "!edge-runtime/deno.lock",
+    "!edge-runtime/**/*.test.ts",
+    "!edge-runtime/lib/fixture",
     "manifest.yml"
   ],
   "engines": {

package/edge-runtime/lib/middleware.test.ts

@@ -1,92 +0,0 @@
-import { assertEquals } from 'https://deno.land/std@0.175.0/testing/asserts.ts'
-import { mergeMiddlewareCookies } from './middleware.ts'
-
-const MIDDLEWARE_HEADER = 'x-middleware-set-cookie'
-
-Deno.test('mergeMiddlewareCookies', async (t) => {
-  await t.step('should handle empty cookies', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, '')
-  })
-
-  await t.step('should return request cookies when there are no middleware headers', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    request.headers.set('Cookie', 'oatmeal=raisin')
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'oatmeal=raisin')
-  })
-
-  await t.step('should not require cookies in request to be set', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    response.headers.set(MIDDLEWARE_HEADER, 'peanut=butter; Path=/')
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'peanut=butter')
-  })
-
-  await t.step('should merge request and middleware cookies', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    request.headers.set('Cookie', 'oatmeal=raisin')
-    response.headers.set(MIDDLEWARE_HEADER, 'peanut=butter; Path=/')
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'oatmeal=raisin; peanut=butter')
-  })
-
-  await t.step('should overwrite request cookies with latest values', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    request.headers.set('Cookie', 'oatmeal=chocolate')
-    response.headers.set(MIDDLEWARE_HEADER, 'oatmeal=raisin; Path=/')
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'oatmeal=raisin')
-  })
-
-  await t.step('should not decode middleware cookie values', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    response.headers.set(MIDDLEWARE_HEADER, 'greeting=Hello%20from%20the%20cookie; Path=/')
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'greeting=Hello%20from%20the%20cookie')
-  })
-
-  await t.step('should support multiple cookies being set in middleware', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    response.headers.set(
-      MIDDLEWARE_HEADER,
-      'oatmeal=raisin; Path=/,peanut=butter; Path=/,chocolate=chip; Path=/',
-    )
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'oatmeal=raisin; peanut=butter; chocolate=chip')
-  })
-
-  await t.step('should ignore comma in middleware cookie expiry', async () => {
-    const request = new Request('https://www.test-url.com')
-    const response = new Response()
-
-    response.headers.set(
-      MIDDLEWARE_HEADER,
-      'oatmeal=raisin; Path=/; Expires=Wed, 23 Apr 2025 13:37:43 GMT; Max-Age=604800',
-    )
-
-    const result = mergeMiddlewareCookies(response, request)
-    assertEquals(result, 'oatmeal=raisin')
-  })
-})