@netlify/plugin-nextjs 5.1.2 → 5.2.1

package/dist/run/handlers/cache.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -248,31 +245,6 @@ var require_main = __commonJS({
   }
 });
 
-// src/shared/blobkey.ts
-var blobkey_exports = {};
-__export(blobkey_exports, {
-  encodeBlobKey: () => encodeBlobKey
-});
-async function encodeBlobKey(key) {
-  const buffer = import_node_buffer.Buffer.from(key);
-  const base64 = buffer.toString("base64url");
-  if (base64.length <= maxLength) {
-    return base64;
-  }
-  const digest = await import_node_crypto.webcrypto.subtle.digest("SHA-256", buffer);
-  const hash = import_node_buffer.Buffer.from(digest).toString("base64url");
-  return `${base64.slice(0, maxLength - hash.length - 1)}-${hash}`;
-}
-var import_node_buffer, import_node_crypto, maxLength;
-var init_blobkey = __esm({
-  "src/shared/blobkey.ts"() {
-    "use strict";
-    import_node_buffer = require("node:buffer");
-    import_node_crypto = require("node:crypto");
-    maxLength = 180;
-  }
-});
-
 // src/run/handlers/cache.cts
 var cache_exports = {};
 __export(cache_exports, {
@@ -280,545 +252,12 @@ __export(cache_exports, {
   default: () => cache_default
 });
 module.exports = __toCommonJS(cache_exports);
-var import_node_buffer2 = require("node:buffer");
-
-// node_modules/@netlify/blobs/dist/chunk-6TGYNZGH.js
-var BlobsInternalError = class extends Error {
-  constructor(statusCode) {
-    super(`Netlify Blobs has generated an internal error: ${statusCode} response`);
-    this.name = "BlobsInternalError";
-  }
-};
-var collectIterator = async (iterator) => {
-  const result = [];
-  for await (const item of iterator) {
-    result.push(item);
-  }
-  return result;
-};
-var base64Decode = (input) => {
-  const { Buffer: Buffer4 } = globalThis;
-  if (Buffer4) {
-    return Buffer4.from(input, "base64").toString();
-  }
-  return atob(input);
-};
-var base64Encode = (input) => {
-  const { Buffer: Buffer4 } = globalThis;
-  if (Buffer4) {
-    return Buffer4.from(input).toString("base64");
-  }
-  return btoa(input);
-};
-var BASE64_PREFIX = "b64;";
-var METADATA_HEADER_INTERNAL = "x-amz-meta-user";
-var METADATA_HEADER_EXTERNAL = "netlify-blobs-metadata";
-var METADATA_MAX_SIZE = 2 * 1024;
-var encodeMetadata = (metadata) => {
-  if (!metadata) {
-    return null;
-  }
-  const encodedObject = base64Encode(JSON.stringify(metadata));
-  const payload = `b64;${encodedObject}`;
-  if (METADATA_HEADER_EXTERNAL.length + payload.length > METADATA_MAX_SIZE) {
-    throw new Error("Metadata object exceeds the maximum size");
-  }
-  return payload;
-};
-var decodeMetadata = (header) => {
-  if (!header || !header.startsWith(BASE64_PREFIX)) {
-    return {};
-  }
-  const encodedData = header.slice(BASE64_PREFIX.length);
-  const decodedData = base64Decode(encodedData);
-  const metadata = JSON.parse(decodedData);
-  return metadata;
-};
-var getMetadataFromResponse = (response) => {
-  if (!response.headers) {
-    return {};
-  }
-  const value = response.headers.get(METADATA_HEADER_EXTERNAL) || response.headers.get(METADATA_HEADER_INTERNAL);
-  try {
-    return decodeMetadata(value);
-  } catch {
-    throw new Error(
-      "An internal error occurred while trying to retrieve the metadata for an entry. Please try updating to the latest version of the Netlify Blobs client."
-    );
-  }
-};
-var BlobsConsistencyError = class extends Error {
-  constructor() {
-    super(
-      `Netlify Blobs has failed to perform a read using strong consistency because the environment has not been configured with a 'uncachedEdgeURL' property`
-    );
-    this.name = "BlobsConsistencyError";
-  }
-};
-var getEnvironment = () => {
-  const { Deno, Netlify, process } = globalThis;
-  return Netlify?.env ?? Deno?.env ?? {
-    delete: (key) => delete process?.env[key],
-    get: (key) => process?.env[key],
-    has: (key) => Boolean(process?.env[key]),
-    set: (key, value) => {
-      if (process?.env) {
-        process.env[key] = value;
-      }
-    },
-    toObject: () => process?.env ?? {}
-  };
-};
-var getEnvironmentContext = () => {
-  const context = globalThis.netlifyBlobsContext || getEnvironment().get("NETLIFY_BLOBS_CONTEXT");
-  if (typeof context !== "string" || !context) {
-    return {};
-  }
-  const data = base64Decode(context);
-  try {
-    return JSON.parse(data);
-  } catch {
-  }
-  return {};
-};
-var MissingBlobsEnvironmentError = class extends Error {
-  constructor(requiredProperties) {
-    super(
-      `The environment has not been configured to use Netlify Blobs. To use it manually, supply the following properties when creating a store: ${requiredProperties.join(
-        ", "
-      )}`
-    );
-    this.name = "MissingBlobsEnvironmentError";
-  }
-};
-var DEFAULT_RETRY_DELAY = getEnvironment().get("NODE_ENV") === "test" ? 1 : 5e3;
-var MIN_RETRY_DELAY = 1e3;
-var MAX_RETRY = 5;
-var RATE_LIMIT_HEADER = "X-RateLimit-Reset";
-var fetchAndRetry = async (fetch2, url, options, attemptsLeft = MAX_RETRY) => {
-  try {
-    const res = await fetch2(url, options);
-    if (attemptsLeft > 0 && (res.status === 429 || res.status >= 500)) {
-      const delay = getDelay(res.headers.get(RATE_LIMIT_HEADER));
-      await sleep(delay);
-      return fetchAndRetry(fetch2, url, options, attemptsLeft - 1);
-    }
-    return res;
-  } catch (error) {
-    if (attemptsLeft === 0) {
-      throw error;
-    }
-    const delay = getDelay();
-    await sleep(delay);
-    return fetchAndRetry(fetch2, url, options, attemptsLeft - 1);
-  }
-};
-var getDelay = (rateLimitReset) => {
-  if (!rateLimitReset) {
-    return DEFAULT_RETRY_DELAY;
-  }
-  return Math.max(Number(rateLimitReset) * 1e3 - Date.now(), MIN_RETRY_DELAY);
-};
-var sleep = (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
-});
-var SIGNED_URL_ACCEPT_HEADER = "application/json;type=signed-url";
-var Client = class {
-  constructor({ apiURL, consistency, edgeURL, fetch: fetch2, siteID, token, uncachedEdgeURL }) {
-    this.apiURL = apiURL;
-    this.consistency = consistency ?? "eventual";
-    this.edgeURL = edgeURL;
-    this.fetch = fetch2 ?? globalThis.fetch;
-    this.siteID = siteID;
-    this.token = token;
-    this.uncachedEdgeURL = uncachedEdgeURL;
-    if (!this.fetch) {
-      throw new Error(
-        "Netlify Blobs could not find a `fetch` client in the global scope. You can either update your runtime to a version that includes `fetch` (like Node.js 18.0.0 or above), or you can supply your own implementation using the `fetch` property."
-      );
-    }
-  }
-  async getFinalRequest({
-    consistency: opConsistency,
-    key,
-    metadata,
-    method,
-    parameters = {},
-    storeName
-  }) {
-    const encodedMetadata = encodeMetadata(metadata);
-    const consistency = opConsistency ?? this.consistency;
-    let urlPath = `/${this.siteID}`;
-    if (storeName) {
-      urlPath += `/${storeName}`;
-    }
-    if (key) {
-      urlPath += `/${key}`;
-    }
-    if (this.edgeURL) {
-      if (consistency === "strong" && !this.uncachedEdgeURL) {
-        throw new BlobsConsistencyError();
-      }
-      const headers = {
-        authorization: `Bearer ${this.token}`
-      };
-      if (encodedMetadata) {
-        headers[METADATA_HEADER_INTERNAL] = encodedMetadata;
-      }
-      const url2 = new URL(urlPath, consistency === "strong" ? this.uncachedEdgeURL : this.edgeURL);
-      for (const key2 in parameters) {
-        url2.searchParams.set(key2, parameters[key2]);
-      }
-      return {
-        headers,
-        url: url2.toString()
-      };
-    }
-    const apiHeaders = { authorization: `Bearer ${this.token}` };
-    const url = new URL(`/api/v1/blobs${urlPath}`, this.apiURL ?? "https://api.netlify.com");
-    for (const key2 in parameters) {
-      url.searchParams.set(key2, parameters[key2]);
-    }
-    if (storeName === void 0 || key === void 0) {
-      return {
-        headers: apiHeaders,
-        url: url.toString()
-      };
-    }
-    if (encodedMetadata) {
-      apiHeaders[METADATA_HEADER_EXTERNAL] = encodedMetadata;
-    }
-    if (method === "head" || method === "delete") {
-      return {
-        headers: apiHeaders,
-        url: url.toString()
-      };
-    }
-    const res = await this.fetch(url.toString(), {
-      headers: { ...apiHeaders, accept: SIGNED_URL_ACCEPT_HEADER },
-      method
-    });
-    if (res.status !== 200) {
-      throw new Error(`Netlify Blobs has generated an internal error: ${res.status} response`);
-    }
-    const { url: signedURL } = await res.json();
-    const userHeaders = encodedMetadata ? { [METADATA_HEADER_INTERNAL]: encodedMetadata } : void 0;
-    return {
-      headers: userHeaders,
-      url: signedURL
-    };
-  }
-  async makeRequest({
-    body,
-    consistency,
-    headers: extraHeaders,
-    key,
-    metadata,
-    method,
-    parameters,
-    storeName
-  }) {
-    const { headers: baseHeaders = {}, url } = await this.getFinalRequest({
-      consistency,
-      key,
-      metadata,
-      method,
-      parameters,
-      storeName
-    });
-    const headers = {
-      ...baseHeaders,
-      ...extraHeaders
-    };
-    if (method === "put") {
-      headers["cache-control"] = "max-age=0, stale-while-revalidate=60";
-    }
-    const options = {
-      body,
-      headers,
-      method
-    };
-    if (body instanceof ReadableStream) {
-      options.duplex = "half";
-    }
-    return fetchAndRetry(this.fetch, url, options);
-  }
-};
-var getClientOptions = (options, contextOverride) => {
-  const context = contextOverride ?? getEnvironmentContext();
-  const siteID = context.siteID ?? options.siteID;
-  const token = context.token ?? options.token;
-  if (!siteID || !token) {
-    throw new MissingBlobsEnvironmentError(["siteID", "token"]);
-  }
-  const clientOptions = {
-    apiURL: context.apiURL ?? options.apiURL,
-    consistency: options.consistency,
-    edgeURL: context.edgeURL ?? options.edgeURL,
-    fetch: options.fetch,
-    siteID,
-    token,
-    uncachedEdgeURL: context.uncachedEdgeURL ?? options.uncachedEdgeURL
-  };
-  return clientOptions;
-};
-
-// node_modules/@netlify/blobs/dist/main.js
-var DEPLOY_STORE_PREFIX = "deploy:";
-var LEGACY_STORE_INTERNAL_PREFIX = "netlify-internal/legacy-namespace/";
-var SITE_STORE_PREFIX = "site:";
-var Store = class _Store {
-  constructor(options) {
-    this.client = options.client;
-    if ("deployID" in options) {
-      _Store.validateDeployID(options.deployID);
-      this.name = DEPLOY_STORE_PREFIX + options.deployID;
-    } else if (options.name.startsWith(LEGACY_STORE_INTERNAL_PREFIX)) {
-      const storeName = options.name.slice(LEGACY_STORE_INTERNAL_PREFIX.length);
-      _Store.validateStoreName(storeName);
-      this.name = storeName;
-    } else {
-      _Store.validateStoreName(options.name);
-      this.name = SITE_STORE_PREFIX + options.name;
-    }
-  }
-  async delete(key) {
-    const res = await this.client.makeRequest({ key, method: "delete", storeName: this.name });
-    if (![200, 204, 404].includes(res.status)) {
-      throw new BlobsInternalError(res.status);
-    }
-  }
-  async get(key, options) {
-    const { consistency, type } = options ?? {};
-    const res = await this.client.makeRequest({ consistency, key, method: "get", storeName: this.name });
-    if (res.status === 404) {
-      return null;
-    }
-    if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
-    }
-    if (type === void 0 || type === "text") {
-      return res.text();
-    }
-    if (type === "arrayBuffer") {
-      return res.arrayBuffer();
-    }
-    if (type === "blob") {
-      return res.blob();
-    }
-    if (type === "json") {
-      return res.json();
-    }
-    if (type === "stream") {
-      return res.body;
-    }
-    throw new BlobsInternalError(res.status);
-  }
-  async getMetadata(key, { consistency } = {}) {
-    const res = await this.client.makeRequest({ consistency, key, method: "head", storeName: this.name });
-    if (res.status === 404) {
-      return null;
-    }
-    if (res.status !== 200 && res.status !== 304) {
-      throw new BlobsInternalError(res.status);
-    }
-    const etag = res?.headers.get("etag") ?? void 0;
-    const metadata = getMetadataFromResponse(res);
-    const result = {
-      etag,
-      metadata
-    };
-    return result;
-  }
-  async getWithMetadata(key, options) {
-    const { consistency, etag: requestETag, type } = options ?? {};
-    const headers = requestETag ? { "if-none-match": requestETag } : void 0;
-    const res = await this.client.makeRequest({
-      consistency,
-      headers,
-      key,
-      method: "get",
-      storeName: this.name
-    });
-    if (res.status === 404) {
-      return null;
-    }
-    if (res.status !== 200 && res.status !== 304) {
-      throw new BlobsInternalError(res.status);
-    }
-    const responseETag = res?.headers.get("etag") ?? void 0;
-    const metadata = getMetadataFromResponse(res);
-    const result = {
-      etag: responseETag,
-      metadata
-    };
-    if (res.status === 304 && requestETag) {
-      return { data: null, ...result };
-    }
-    if (type === void 0 || type === "text") {
-      return { data: await res.text(), ...result };
-    }
-    if (type === "arrayBuffer") {
-      return { data: await res.arrayBuffer(), ...result };
-    }
-    if (type === "blob") {
-      return { data: await res.blob(), ...result };
-    }
-    if (type === "json") {
-      return { data: await res.json(), ...result };
-    }
-    if (type === "stream") {
-      return { data: res.body, ...result };
-    }
-    throw new Error(`Invalid 'type' property: ${type}. Expected: arrayBuffer, blob, json, stream, or text.`);
-  }
-  list(options = {}) {
-    const iterator = this.getListIterator(options);
-    if (options.paginate) {
-      return iterator;
-    }
-    return collectIterator(iterator).then(
-      (items) => items.reduce(
-        (acc, item) => ({
-          blobs: [...acc.blobs, ...item.blobs],
-          directories: [...acc.directories, ...item.directories]
-        }),
-        { blobs: [], directories: [] }
-      )
-    );
-  }
-  async set(key, data, { metadata } = {}) {
-    _Store.validateKey(key);
-    const res = await this.client.makeRequest({
-      body: data,
-      key,
-      metadata,
-      method: "put",
-      storeName: this.name
-    });
-    if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
-    }
-  }
-  async setJSON(key, data, { metadata } = {}) {
-    _Store.validateKey(key);
-    const payload = JSON.stringify(data);
-    const headers = {
-      "content-type": "application/json"
-    };
-    const res = await this.client.makeRequest({
-      body: payload,
-      headers,
-      key,
-      metadata,
-      method: "put",
-      storeName: this.name
-    });
-    if (res.status !== 200) {
-      throw new BlobsInternalError(res.status);
-    }
-  }
-  static formatListResultBlob(result) {
-    if (!result.key) {
-      return null;
-    }
-    return {
-      etag: result.etag,
-      key: result.key
-    };
-  }
-  static validateKey(key) {
-    if (key === "") {
-      throw new Error("Blob key must not be empty.");
-    }
-    if (key.startsWith("/") || key.startsWith("%2F")) {
-      throw new Error("Blob key must not start with forward slash (/).");
-    }
-    if (new TextEncoder().encode(key).length > 600) {
-      throw new Error(
-        "Blob key must be a sequence of Unicode characters whose UTF-8 encoding is at most 600 bytes long."
-      );
-    }
-  }
-  static validateDeployID(deployID) {
-    if (!/^\w{1,24}$/.test(deployID)) {
-      throw new Error(`'${deployID}' is not a valid Netlify deploy ID.`);
-    }
-  }
-  static validateStoreName(name) {
-    if (name.includes("/") || name.includes("%2F")) {
-      throw new Error("Store name must not contain forward slashes (/).");
-    }
-    if (new TextEncoder().encode(name).length > 64) {
-      throw new Error(
-        "Store name must be a sequence of Unicode characters whose UTF-8 encoding is at most 64 bytes long."
-      );
-    }
-  }
-  getListIterator(options) {
-    const { client, name: storeName } = this;
-    const parameters = {};
-    if (options?.prefix) {
-      parameters.prefix = options.prefix;
-    }
-    if (options?.directories) {
-      parameters.directories = "true";
-    }
-    return {
-      [Symbol.asyncIterator]() {
-        let currentCursor = null;
-        let done = false;
-        return {
-          async next() {
-            if (done) {
-              return { done: true, value: void 0 };
-            }
-            const nextParameters = { ...parameters };
-            if (currentCursor !== null) {
-              nextParameters.cursor = currentCursor;
-            }
-            const res = await client.makeRequest({
-              method: "get",
-              parameters: nextParameters,
-              storeName
-            });
-            const page = await res.json();
-            if (page.next_cursor) {
-              currentCursor = page.next_cursor;
-            } else {
-              done = true;
-            }
-            const blobs = (page.blobs ?? []).map(_Store.formatListResultBlob).filter(Boolean);
-            return {
-              done: false,
-              value: {
-                blobs,
-                directories: page.directories ?? []
-              }
-            };
-          }
-        };
-      }
-    };
-  }
-};
-var getDeployStore = (options = {}) => {
-  const context = getEnvironmentContext();
-  const deployID = options.deployID ?? context.deployID;
-  if (!deployID) {
-    throw new MissingBlobsEnvironmentError(["deployID"]);
-  }
-  const clientOptions = getClientOptions(options, context);
-  const client = new Client(clientOptions);
-  return new Store({ client, deployID });
-};
-
-// src/run/handlers/cache.cts
+var import_node_buffer = require("node:buffer");
 var import_functions = __toESM(require_main());
 var import_constants = require("next/dist/lib/constants.js");
+var import_regional_blob_store = require("../regional-blob-store.cjs");
 var import_request_context = require("./request-context.cjs");
 var import_tracer = require("./tracer.cjs");
-var fetchBeforeNextPatchedIt = globalThis.fetch;
 var NetlifyCacheHandler = class {
   options;
   revalidatedTags;
@@ -828,12 +267,12 @@ var NetlifyCacheHandler = class {
   constructor(options) {
     this.options = options;
     this.revalidatedTags = options.revalidatedTags;
-    this.blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt, consistency: "strong" });
+    this.blobStore = (0, import_regional_blob_store.getRegionalBlobStore)({ consistency: "strong" });
     this.tagManifestsFetchedFromBlobStoreInCurrentRequest = {};
   }
   async encodeBlobKey(key) {
-    const { encodeBlobKey: encodeBlobKey2 } = await Promise.resolve().then(() => (init_blobkey(), blobkey_exports));
-    return await encodeBlobKey2(key);
+    const { encodeBlobKey } = await import("../../shared/blobkey.js");
+    return await encodeBlobKey(key);
   }
   captureResponseCacheLastModified(cacheValue, key, getCacheKeySpan) {
     if (cacheValue.value?.kind === "FETCH") {
@@ -912,7 +351,7 @@ var NetlifyCacheHandler = class {
             lastModified: blob.lastModified,
             value: {
               ...valueWithoutRevalidate,
-              body: import_node_buffer2.Buffer.from(valueWithoutRevalidate.body, "base64")
+              body: import_node_buffer.Buffer.from(valueWithoutRevalidate.body, "base64")
             }
           };
         }

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

@@ -27,8 +27,15 @@ __export(request_context_exports, {
 module.exports = __toCommonJS(request_context_exports);
 var import_node_async_hooks = require("node:async_hooks");
 function createRequestContext(debug = false) {
+  const backgroundWorkPromises = [];
   return {
-    debug
+    debug,
+    trackBackgroundWork: (promise) => {
+      backgroundWorkPromises.push(promise);
+    },
+    get backgroundWorkPromise() {
+      return Promise.allSettled(backgroundWorkPromises);
+    }
   };
 }
 var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");

package/dist/run/handlers/server.js

@@ -4,24 +4,6 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  adjustDateHeader,
-  setCacheControlHeaders,
-  setCacheStatusHeader,
-  setCacheTagsHeaders,
-  setVaryHeaders
-} from "../../esm-chunks/chunk-PMRBBOBY.js";
-import {
-  nextResponseProxy
-} from "../../esm-chunks/chunk-RL4K4CVH.js";
-import {
-  import_internal
-} from "../../esm-chunks/chunk-HYBEXB2Z.js";
-import "../../esm-chunks/chunk-TYCYFZ22.js";
-import {
-  getTagsManifest
-} from "../../esm-chunks/chunk-3SUDZQ7L.js";
-import "../../esm-chunks/chunk-UYKENJEU.js";
 import {
   __commonJS,
   __toESM
@@ -3257,6 +3239,16 @@ function toComputeResponse(res) {
 }
 
 // src/run/handlers/server.ts
+import { getTagsManifest } from "../config.js";
+import {
+  adjustDateHeader,
+  setCacheStatusHeader,
+  setCacheControlHeaders,
+  setCacheTagsHeaders,
+  setVaryHeaders
+} from "../headers.js";
+import { nextResponseProxy } from "../revalidate.js";
+import { logger } from "../systemlog.js";
 import { createRequestContext, getRequestContext } from "./request-context.cjs";
 import { getTracer } from "./tracer.cjs";
 var nextImportPromise = import("../next.cjs");
@@ -3276,7 +3268,7 @@ var disableFaultyTransferEncodingHandling = (res) => {
     return originalStoreHeader.call(this, firstLine, headers);
   };
 };
-var server_default = async (request) => {
+var server_default = async (request, context) => {
   const tracer = getTracer();
   if (!nextHandler) {
     await tracer.withActiveSpan("initialize next server", async (span) => {
@@ -3319,7 +3311,7 @@ var server_default = async (request) => {
     const requestContext = getRequestContext() ?? createRequestContext();
     const resProxy = nextResponseProxy(res, requestContext);
     const nextHandlerPromise = nextHandler(req, resProxy).catch((error) => {
-      import_internal.systemLogger.withError(error).error("next handler error");
+      logger.withError(error).error("next handler error");
       console.error(error);
       resProxy.statusCode = 500;
       span.setAttribute("http.status_code", 500);
@@ -3338,9 +3330,15 @@ var server_default = async (request) => {
       const body = await response.text();
       return new Response(body || null, response);
     }
+    if (context.waitUntil) {
+      context.waitUntil(requestContext.backgroundWorkPromise);
+    }
     const keepOpenUntilNextFullyRendered = new TransformStream({
-      flush() {
-        return nextHandlerPromise;
+      async flush() {
+        await nextHandlerPromise;
+        if (!context.waitUntil) {
+          await requestContext.backgroundWorkPromise;
+        }
       }
     });
     return new Response(response.body?.pipeThrough(keepOpenUntilNextFullyRendered), response);