@netlify/plugin-nextjs 5.8.0 → 5.9.0

package/dist/run/handlers/request-context.cjs

@@ -96,12 +96,16 @@ var SystemLogger = class _SystemLogger {
 var systemLogger = new SystemLogger();
 
 // src/run/handlers/request-context.cts
-function createRequestContext(request) {
+function createRequestContext(request, context) {
   const backgroundWorkPromises = [];
   return {
     captureServerTiming: request?.headers.has("x-next-debug-logging") ?? false,
     trackBackgroundWork: (promise) => {
-      backgroundWorkPromises.push(promise);
+      if (context?.waitUntil) {
+        context.waitUntil(promise);
+      } else {
+        backgroundWorkPromises.push(promise);
+      }
     },
     get backgroundWorkPromise() {
       return Promise.allSettled(backgroundWorkPromises);

package/dist/run/handlers/server.js

@@ -4,6 +4,28 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  getTracer
+} from "../../esm-chunks/chunk-KBX7SJLC.js";
+import {
+  createRequestContext,
+  getLogger,
+  getRequestContext
+} from "../../esm-chunks/chunk-NDSDIXRD.js";
+import {
+  adjustDateHeader,
+  setCacheControlHeaders,
+  setCacheStatusHeader,
+  setCacheTagsHeaders,
+  setVaryHeaders
+} from "../../esm-chunks/chunk-BEIUVQZK.js";
+import "../../esm-chunks/chunk-K4RDUZYO.js";
+import {
+  nextResponseProxy
+} from "../../esm-chunks/chunk-XS27YRA5.js";
+import "../../esm-chunks/chunk-TYCYFZ22.js";
+import "../../esm-chunks/chunk-5QSXBV7L.js";
+import "../../esm-chunks/chunk-GNGHTHMQ.js";
 import {
   __commonJS,
   __toESM
@@ -3090,18 +3112,20 @@ function toComputeResponse(res) {
   return res.computeResponse;
 }
 
+// src/run/handlers/wait-until.cts
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
+function setupWaitUntil() {
+  ;
+  globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = {
+    get() {
+      return { waitUntil: getRequestContext()?.trackBackgroundWork };
+    }
+  };
+}
+
 // src/run/handlers/server.ts
-import {
-  adjustDateHeader,
-  setCacheControlHeaders,
-  setCacheStatusHeader,
-  setCacheTagsHeaders,
-  setVaryHeaders
-} from "../headers.js";
-import { nextResponseProxy } from "../revalidate.js";
-import { createRequestContext, getLogger, getRequestContext } from "./request-context.cjs";
-import { getTracer } from "./tracer.cjs";
-var nextImportPromise = import("../next.cjs");
+var nextImportPromise = import("../../esm-chunks/next-4L47PQSM.js");
+setupWaitUntil();
 var nextHandler;
 var nextConfig;
 var disableFaultyTransferEncodingHandling = (res) => {
@@ -3117,16 +3141,16 @@ var disableFaultyTransferEncodingHandling = (res) => {
     return originalStoreHeader.call(this, firstLine, headers);
   };
 };
-var server_default = async (request, context) => {
+var server_default = async (request) => {
   const tracer = getTracer();
   if (!nextHandler) {
     await tracer.withActiveSpan("initialize next server", async () => {
       const { getRunConfig, setRunConfig } = await import("../config.js");
       nextConfig = await getRunConfig();
       setRunConfig(nextConfig);
-      const { getMockedRequestHandlers } = await nextImportPromise;
+      const { getMockedRequestHandler } = await nextImportPromise;
       const url = new URL(request.url);
-      [nextHandler] = await getMockedRequestHandlers({
+      nextHandler = await getMockedRequestHandler({
         port: Number(url.port) || 443,
         hostname: url.hostname,
         dir: process.cwd(),
@@ -3169,15 +3193,11 @@ var server_default = async (request, context) => {
       const body = await response.text();
       return new Response(body || null, response);
     }
-    if (context.waitUntil) {
-      context.waitUntil(requestContext.backgroundWorkPromise);
-    }
     const keepOpenUntilNextFullyRendered = new TransformStream({
       async flush() {
         await nextHandlerPromise;
-        if (!context.waitUntil) {
-          await requestContext.backgroundWorkPromise;
-        }
+        res.emit("close");
+        await requestContext.backgroundWorkPromise;
       }
     });
     return new Response(response.body?.pipeThrough(keepOpenUntilNextFullyRendered), response);

package/dist/run/handlers/tracer.cjs

@@ -845,8 +845,89 @@ function handleFn(span, opts, fn) {
   }
 }
 
+// src/run/handlers/request-context.cts
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/chunk-HYMERDCV.mjs
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  const extendedGlobalThis = globalThis;
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+
 // src/run/handlers/tracer.cts
-var import_request_context = require("./request-context.cjs");
 var spanMeta = /* @__PURE__ */ new WeakMap();
 var spanCounter = /* @__PURE__ */ new WeakMap();
 function spanHook(span) {
@@ -855,7 +936,7 @@ function spanHook(span) {
     originalEnd(endTime);
     const meta = spanMeta.get(span);
     if (meta) {
-      const requestContext = (0, import_request_context.getRequestContext)();
+      const requestContext = getRequestContext();
       if (requestContext?.captureServerTiming) {
         const duration = (typeof endTime === "number" ? endTime : performance.now()) - meta.start;
         const serverTiming = requestContext.serverTiming ?? "";

package/dist/run/handlers/tracing.js

@@ -4,6 +4,9 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  getLogger
+} from "../../esm-chunks/chunk-NDSDIXRD.js";
 import {
   esm_exports,
   init_esm
@@ -68863,10 +68866,9 @@ var import_resources = __toESM(require_src5(), 1);
 var import_sdk_node = __toESM(require_src36(), 1);
 var import_sdk_trace_node = __toESM(require_src20(), 1);
 var import_semantic_conventions = __toESM(require_src(), 1);
-import { getLogger } from "./request-context.cjs";
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-4GFWM3PF.js");
+} = await import("../../esm-chunks/package-LCNINN36.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SEMRESATTRS_SERVICE_NAME]: name,

package/dist/run/handlers/wait-until.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/wait-until.cts
+var wait_until_exports = {};
+__export(wait_until_exports, {
+  setupWaitUntil: () => setupWaitUntil
+});
+module.exports = __toCommonJS(wait_until_exports);
+
+// src/run/handlers/request-context.cts
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/chunk-HYMERDCV.mjs
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  const extendedGlobalThis = globalThis;
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+
+// src/run/handlers/wait-until.cts
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
+function setupWaitUntil() {
+  ;
+  globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = {
+    get() {
+      return { waitUntil: getRequestContext()?.trackBackgroundWork };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupWaitUntil
+});

package/dist/run/headers.js

@@ -4,201 +4,16 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  adjustDateHeader,
+  setCacheControlHeaders,
+  setCacheStatusHeader,
+  setCacheTagsHeaders,
+  setVaryHeaders
+} from "../esm-chunks/chunk-BEIUVQZK.js";
+import "../esm-chunks/chunk-K4RDUZYO.js";
+import "../esm-chunks/chunk-TYCYFZ22.js";
 import "../esm-chunks/chunk-OEQOKJGE.js";
-
-// src/run/headers.ts
-import { encodeBlobKey } from "../shared/blobkey.js";
-import { getRegionalBlobStore } from "./regional-blob-store.cjs";
-var ALL_VARIATIONS = Symbol.for("ALL_VARIATIONS");
-var NetlifyVaryKeys = /* @__PURE__ */ new Set(["header", "language", "cookie", "query", "country"]);
-var isNetlifyVaryKey = (key) => NetlifyVaryKeys.has(key);
-var generateNetlifyVaryValues = ({
-  header,
-  language,
-  cookie,
-  query,
-  country
-}) => {
-  const values = [];
-  if (query.length !== 0) {
-    if (query.includes(ALL_VARIATIONS)) {
-      values.push(`query`);
-    } else {
-      values.push(`query=${query.join(`|`)}`);
-    }
-  }
-  if (header.length !== 0) {
-    values.push(`header=${header.join(`|`)}`);
-  }
-  if (language.length !== 0) {
-    values.push(`language=${language.join(`|`)}`);
-  }
-  if (cookie.length !== 0) {
-    values.push(`cookie=${cookie.join(`|`)}`);
-  }
-  if (country.length !== 0) {
-    values.push(`country=${country.join(`|`)}`);
-  }
-  return values.join(",");
-};
-var getHeaderValueArray = (header) => {
-  return header.split(",").map((value) => value.trim()).filter(Boolean);
-};
-var omitHeaderValues = (header, values) => {
-  const headerValues = getHeaderValueArray(header);
-  const filteredValues = headerValues.filter(
-    (value) => !values.some((val) => value.startsWith(val))
-  );
-  return filteredValues.join(", ");
-};
-var setVaryHeaders = (headers, request, { basePath, i18n }) => {
-  const netlifyVaryValues = {
-    header: ["x-nextjs-data", "x-next-debug-logging"],
-    language: [],
-    cookie: ["__prerender_bypass", "__next_preview_data"],
-    query: [],
-    country: []
-  };
-  const vary = headers.get("vary");
-  if (vary !== null) {
-    netlifyVaryValues.header.push(...getHeaderValueArray(vary));
-  }
-  const path = new URL(request.url).pathname;
-  const locales = i18n && i18n.localeDetection !== false ? i18n.locales : [];
-  if (locales.length > 1 && (path === "/" || path === basePath)) {
-    netlifyVaryValues.language.push(...locales);
-    netlifyVaryValues.cookie.push(`NEXT_LOCALE`);
-  }
-  const userNetlifyVary = headers.get("netlify-vary");
-  if (userNetlifyVary) {
-    const directives = getHeaderValueArray(userNetlifyVary);
-    for (const directive of directives) {
-      const [key, value] = directive.split("=");
-      if (key === "query" && !value) {
-        netlifyVaryValues.query.push(ALL_VARIATIONS);
-      } else if (value && isNetlifyVaryKey(key)) {
-        netlifyVaryValues[key].push(...value.split("|"));
-      }
-    }
-  }
-  headers.set(`netlify-vary`, generateNetlifyVaryValues(netlifyVaryValues));
-};
-var adjustDateHeader = async ({
-  headers,
-  request,
-  span,
-  tracer,
-  requestContext
-}) => {
-  const cacheState = headers.get("x-nextjs-cache");
-  const isServedFromCache = cacheState === "HIT" || cacheState === "STALE";
-  span.setAttributes({
-    "x-nextjs-cache": cacheState ?? void 0,
-    isServedFromCache
-  });
-  if (!isServedFromCache) {
-    return;
-  }
-  const key = new URL(request.url).pathname;
-  let lastModified;
-  if (requestContext.responseCacheGetLastModified) {
-    lastModified = requestContext.responseCacheGetLastModified;
-  } else {
-    span.recordException(
-      new Error("lastModified not found in requestContext, falling back to trying blobs")
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    const blobStore = getRegionalBlobStore({ consistency: "strong" });
-    const blobKey = await encodeBlobKey(key);
-    lastModified = await tracer.withActiveSpan(
-      "get cache to calculate date header",
-      async (getBlobForDateSpan) => {
-        getBlobForDateSpan.setAttributes({
-          key,
-          blobKey
-        });
-        const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
-        getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        return blob.lastModified;
-      }
-    );
-  }
-  if (!lastModified) {
-    span.recordException(
-      new Error(
-        "lastModified not found in either requestContext or blobs, date header for cached response is not set"
-      )
-    );
-    span.setAttributes({
-      severity: "alert",
-      warning: true
-    });
-    return;
-  }
-  const lastModifiedDate = new Date(lastModified);
-  headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
-  headers.set("date", lastModifiedDate.toUTCString());
-};
-var setCacheControlHeaders = ({ headers, status }, request, requestContext) => {
-  if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    const cdnCacheControl = (
-      // if we are serving already stale response, instruct edge to not attempt to cache that response
-      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : `s-maxage=${requestContext.routeHandlerRevalidate === false ? 31536e3 : requestContext.routeHandlerRevalidate}, stale-while-revalidate=31536000, durable`
-    );
-    headers.set("netlify-cdn-cache-control", cdnCacheControl);
-    return;
-  }
-  if (status === 404 && request.url.endsWith(".php")) {
-    headers.set("cache-control", "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", `max-age=31536000, durable`);
-  }
-  const cacheControl = headers.get("cache-control");
-  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control")) {
-    const browserCacheControl = omitHeaderValues(cacheControl, [
-      "s-maxage",
-      "stale-while-revalidate"
-    ]);
-    const cdnCacheControl = (
-      // if we are serving already stale response, instruct edge to not attempt to cache that response
-      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : [
-        ...getHeaderValueArray(cacheControl).map(
-          (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
-        ),
-        "durable"
-      ].join(", ")
-    );
-    headers.set("cache-control", browserCacheControl || "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", cdnCacheControl);
-    return;
-  }
-  if (cacheControl === null && !headers.has("cdn-cache-control") && !headers.has("netlify-cdn-cache-control") && requestContext.usedFsRead) {
-    headers.set("cache-control", "public, max-age=0, must-revalidate");
-    headers.set("netlify-cdn-cache-control", `max-age=31536000, durable`);
-  }
-};
-var setCacheTagsHeaders = (headers, requestContext) => {
-  if (requestContext.responseCacheTags) {
-    headers.set("netlify-cache-tag", requestContext.responseCacheTags.join(","));
-  }
-};
-var NEXT_CACHE_TO_CACHE_STATUS = {
-  HIT: `hit`,
-  MISS: `fwd=miss`,
-  STALE: `hit; fwd=stale`
-};
-var setCacheStatusHeader = (headers) => {
-  const nextCache = headers.get("x-nextjs-cache");
-  if (typeof nextCache === "string") {
-    if (nextCache in NEXT_CACHE_TO_CACHE_STATUS) {
-      const cacheStatus = NEXT_CACHE_TO_CACHE_STATUS[nextCache];
-      headers.set("cache-status", `"Next.js"; ${cacheStatus}`);
-    }
-    headers.delete("x-nextjs-cache");
-  }
-};
 export {
   adjustDateHeader,
   setCacheControlHeaders,