@netlify/plugin-nextjs 5.8.1 → 5.9.1

package/dist/esm-chunks/chunk-BEIUVQZK.js

@@ -0,0 +1,212 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getRegionalBlobStore
+} from "./chunk-K4RDUZYO.js";
+import {
+  encodeBlobKey
+} from "./chunk-TYCYFZ22.js";
+
+// src/run/headers.ts
+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: ["__nextDataReq"],
+    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.usedFsReadForNonFallback) {
+    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.has("cache-control") || headers.has("netlify-cdn-cache-control"))) {
+    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 {
+  setVaryHeaders,
+  adjustDateHeader,
+  setCacheControlHeaders,
+  setCacheTagsHeaders,
+  setCacheStatusHeader
+};

package/dist/esm-chunks/chunk-BVYZSEV6.js

@@ -0,0 +1,306 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  encodeBlobKey
+} from "./chunk-TYCYFZ22.js";
+import {
+  wrapTracer
+} from "./chunk-5QSXBV7L.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-GNGHTHMQ.js";
+import {
+  verifyNetlifyForms
+} from "./chunk-ZSVHJNNY.js";
+import {
+  require_out
+} from "./chunk-KGYJQ2U2.js";
+import {
+  require_semver
+} from "./chunk-APO262HE.js";
+import {
+  __toESM
+} from "./chunk-OEQOKJGE.js";
+
+// src/build/content/prerendered.ts
+init_esm();
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+
+// node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// node_modules/p-limit/index.js
+import { AsyncResource } from "async_hooks";
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (function_, resolve, arguments_) => {
+    activeCount++;
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    queue.enqueue(
+      AsyncResource.bind(run.bind(void 0, function_, resolve, arguments_))
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// src/build/content/prerendered.ts
+var import_semver = __toESM(require_semver(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var writeCacheEntry = async (route, value, lastModified, ctx) => {
+  const path = join(ctx.blobDir, await encodeBlobKey(route));
+  const entry = JSON.stringify({
+    lastModified,
+    value
+  });
+  await writeFile(path, entry, "utf-8");
+};
+var routeToFilePath = (path) => {
+  if (path === "/") {
+    return "/index";
+  }
+  if (path.startsWith("/")) {
+    return path;
+  }
+  return `/${path}`;
+};
+var buildPagesCacheValue = async (path, shouldUseEnumKind, shouldSkipJson = false) => ({
+  kind: shouldUseEnumKind ? "PAGES" : "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: shouldSkipJson ? {} : JSON.parse(await readFile(`${path}.json`, "utf-8")),
+  headers: void 0,
+  status: void 0
+});
+var buildAppCacheValue = async (path, shouldUseAppPageKind) => {
+  const meta = JSON.parse(await readFile(`${path}.meta`, "utf-8"));
+  const html = await readFile(`${path}.html`, "utf-8");
+  if (shouldUseAppPageKind) {
+    return {
+      kind: "APP_PAGE",
+      html,
+      rscData: await readFile(`${path}.rsc`, "base64").catch(
+        () => readFile(`${path}.prefetch.rsc`, "base64")
+      ),
+      ...meta
+    };
+  }
+  const rsc = await readFile(`${path}.rsc`, "utf-8").catch(
+    () => readFile(`${path}.prefetch.rsc`, "utf-8")
+  );
+  if (!meta.status && rsc.includes("NEXT_NOT_FOUND") && !meta.headers["x-next-cache-tags"].includes("/@")) {
+    meta.status = 404;
+  }
+  return {
+    kind: "PAGE",
+    html,
+    pageData: rsc,
+    ...meta
+  };
+};
+var buildRouteCacheValue = async (path, initialRevalidateSeconds, shouldUseEnumKind) => ({
+  kind: shouldUseEnumKind ? "APP_ROUTE" : "ROUTE",
+  body: await readFile(`${path}.body`, "base64"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8")),
+  revalidate: initialRevalidateSeconds
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  return tracer.withActiveSpan("copyPrerenderedContent", async () => {
+    try {
+      await mkdir(ctx.blobDir, { recursive: true });
+      const manifest = await ctx.getPrerenderManifest();
+      const limitConcurrentPrerenderContentHandling = pLimit(10);
+      const shouldUseAppPageKind = ctx.nextVersion ? (0, import_semver.satisfies)(ctx.nextVersion, ">=15.0.0-canary.13 <15.0.0-d || >15.0.0-rc.0", {
+        includePrerelease: true
+      }) : false;
+      const shouldUseEnumKind = ctx.nextVersion ? (0, import_semver.satisfies)(ctx.nextVersion, ">=15.0.0-canary.114 <15.0.0-d || >15.0.0-rc.0", {
+        includePrerelease: true
+      }) : false;
+      await Promise.all([
+        ...Object.entries(manifest.routes).map(
+          ([route, meta]) => limitConcurrentPrerenderContentHandling(async () => {
+            const lastModified = meta.initialRevalidateSeconds ? Date.now() - 31536e6 : Date.now();
+            const key = routeToFilePath(route);
+            let value;
+            switch (true) {
+              // Parallel route default layout has no prerendered page
+              case (meta.dataRoute?.endsWith("/default.rsc") && !existsSync(join(ctx.publishDir, "server/app", `${key}.html`))):
+                return;
+              case meta.dataRoute?.endsWith(".json"):
+                if (manifest.notFoundRoutes.includes(route)) {
+                  return;
+                }
+                value = await buildPagesCacheValue(
+                  join(ctx.publishDir, "server/pages", key),
+                  shouldUseEnumKind
+                );
+                break;
+              case meta.dataRoute?.endsWith(".rsc"):
+                value = await buildAppCacheValue(
+                  join(ctx.publishDir, "server/app", key),
+                  shouldUseAppPageKind
+                );
+                break;
+              case meta.dataRoute === null:
+                value = await buildRouteCacheValue(
+                  join(ctx.publishDir, "server/app", key),
+                  meta.initialRevalidateSeconds,
+                  shouldUseEnumKind
+                );
+                break;
+              default:
+                throw new Error(`Unrecognized content: ${route}`);
+            }
+            if (value.kind === "PAGE" || value.kind === "PAGES" || value.kind === "APP_PAGE") {
+              verifyNetlifyForms(ctx, value.html);
+            }
+            await writeCacheEntry(key, value, lastModified, ctx);
+          })
+        ),
+        ...ctx.getFallbacks(manifest).map(async (route) => {
+          const key = routeToFilePath(route);
+          const value = await buildPagesCacheValue(
+            join(ctx.publishDir, "server/pages", key),
+            shouldUseEnumKind,
+            true
+            // there is no corresponding json file for fallback, so we are skipping it for this entry
+          );
+          await writeCacheEntry(key, value, Date.now(), ctx);
+        })
+      ]);
+      if (existsSync(join(ctx.publishDir, `server/app/_not-found.html`))) {
+        const lastModified = Date.now();
+        const key = "/404";
+        const value = await buildAppCacheValue(
+          join(ctx.publishDir, "server/app/_not-found"),
+          shouldUseAppPageKind
+        );
+        await writeCacheEntry(key, value, lastModified, ctx);
+      }
+    } catch (error) {
+      ctx.failBuild("Failed assembling prerendered content for upload", error);
+    }
+  });
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.glob)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const lastModified = Date.now() - 31536e6;
+        const path = join(ctx.publishDir, "cache/fetch-cache", key);
+        const value = await buildFetchCacheValue(path);
+        await writeCacheEntry(key, value, lastModified, ctx);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
+
+export {
+  copyPrerenderedContent,
+  copyFetchContent
+};

package/dist/esm-chunks/chunk-DLVROEVU.js

@@ -0,0 +1,144 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  copyNextDependencies,
+  copyNextServerCode,
+  verifyHandlerDirStructure
+} from "./chunk-IJZEDP6B.js";
+import {
+  wrapTracer
+} from "./chunk-5QSXBV7L.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-GNGHTHMQ.js";
+import {
+  SERVER_HANDLER_NAME
+} from "./chunk-GFYWJNQR.js";
+import {
+  require_out
+} from "./chunk-KGYJQ2U2.js";
+import {
+  __toESM
+} from "./chunk-OEQOKJGE.js";
+
+// src/build/functions/server.ts
+init_esm();
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { join as posixJoin } from "node:path/posix";
+var import_fast_glob = __toESM(require_out(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var copyHandlerDependencies = async (ctx) => {
+  await tracer.withActiveSpan("copyHandlerDependencies", async (span) => {
+    const promises = [];
+    const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
+    includedFiles.push(
+      posixJoin(ctx.relativeAppDir, ".env"),
+      posixJoin(ctx.relativeAppDir, ".env.production"),
+      posixJoin(ctx.relativeAppDir, ".env.local"),
+      posixJoin(ctx.relativeAppDir, ".env.production.local")
+    );
+    span.setAttribute("next.includedFiles", includedFiles.join(","));
+    const resolvedFiles = await Promise.all(
+      includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
+    );
+    for (const filePath of resolvedFiles.flat()) {
+      promises.push(
+        cp(
+          join(process.cwd(), filePath),
+          // the serverHandlerDir is aware of the dist dir.
+          // The distDir must not be the package path therefore we need to rely on the
+          // serverHandlerDir instead of the serverHandlerRootDir
+          // therefore we need to remove the package path from the filePath
+          join(ctx.serverHandlerDir, relative(ctx.relativeAppDir, filePath)),
+          {
+            recursive: true,
+            force: true
+          }
+        )
+      );
+    }
+    promises.push(
+      writeFile(
+        join(ctx.serverHandlerRuntimeModulesDir, "package.json"),
+        JSON.stringify({ type: "module" })
+      )
+    );
+    const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+    for (const filePath of fileList) {
+      promises.push(
+        cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerRuntimeModulesDir, filePath), {
+          recursive: true,
+          force: true
+        })
+      );
+    }
+    await Promise.all(promises);
+  });
+};
+var writeHandlerManifest = async (ctx) => {
+  await writeFile(
+    join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.json`),
+    JSON.stringify({
+      config: {
+        name: "Next.js Server Handler",
+        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
+        nodeBundler: "none",
+        // the folders can vary in monorepos based on the folder structure of the user so we have to glob all
+        includedFiles: ["**"],
+        includedFilesBasePath: ctx.serverHandlerRootDir
+      },
+      version: 1
+    }),
+    "utf-8"
+  );
+};
+var applyTemplateVariables = (template, variables) => {
+  return Object.entries(variables).reduce((acc, [key, value]) => {
+    return acc.replaceAll(key, value);
+  }, template);
+};
+var getHandlerFile = async (ctx) => {
+  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
+  const templateVariables = {
+    "{{useRegionalBlobs}}": ctx.useRegionalBlobs.toString()
+  };
+  if (ctx.relativeAppDir.length !== 0) {
+    const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
+    templateVariables["{{cwd}}"] = posixJoin(ctx.lambdaWorkingDirectory);
+    templateVariables["{{nextServerHandler}}"] = posixJoin(ctx.nextServerHandler);
+    return applyTemplateVariables(template, templateVariables);
+  }
+  return applyTemplateVariables(
+    await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8"),
+    templateVariables
+  );
+};
+var writeHandlerFile = async (ctx) => {
+  const handler = await getHandlerFile(ctx);
+  await writeFile(join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.mjs`), handler);
+};
+var clearStaleServerHandlers = async (ctx) => {
+  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
+};
+var createServerHandler = async (ctx) => {
+  await tracer.withActiveSpan("createServerHandler", async () => {
+    await mkdir(join(ctx.serverHandlerRuntimeModulesDir), { recursive: true });
+    await copyNextServerCode(ctx);
+    await copyNextDependencies(ctx);
+    await copyHandlerDependencies(ctx);
+    await writeHandlerManifest(ctx);
+    await writeHandlerFile(ctx);
+    await verifyHandlerDirStructure(ctx);
+  });
+};
+
+export {
+  clearStaleServerHandlers,
+  createServerHandler
+};