@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.1

package/dist/esm-chunks/chunk-5N2CWXSJ.js

@@ -0,0 +1,564 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/headers.ts
+import { Buffer as Buffer4 } from "node:buffer";
+
+// node_modules/@netlify/blobs/dist/main.js
+import { Buffer } from "buffer";
+import { env } from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
+var getEnvironmentContext = () => {
+  const context = globalThis.netlifyBlobsContext || env.NETLIFY_BLOBS_CONTEXT;
+  if (typeof context !== "string" || !context) {
+    return {};
+  }
+  const data = Buffer.from(context, "base64").toString();
+  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 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 = Buffer2.from(JSON.stringify(metadata)).toString("base64");
+  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 = Buffer2.from(encodedData, "base64").toString();
+  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 DEFAULT_RETRY_DELAY = 5e3;
+var MIN_RETRY_DELAY = 1e3;
+var MAX_RETRY = 5;
+var RATE_LIMIT_HEADER = "X-RateLimit-Reset";
+var fetchAndRetry = async (fetch, url, options, attemptsLeft = MAX_RETRY) => {
+  try {
+    const res = await fetch(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(fetch, url, options, attemptsLeft - 1);
+    }
+    return res;
+  } catch (error) {
+    if (attemptsLeft === 0) {
+      throw error;
+    }
+    const delay = getDelay();
+    await sleep(delay);
+    return fetchAndRetry(fetch, 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((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var Client = class {
+  constructor({ apiURL, edgeURL, fetch, siteID, token }) {
+    this.apiURL = apiURL;
+    this.edgeURL = edgeURL;
+    this.fetch = fetch ?? globalThis.fetch;
+    this.siteID = siteID;
+    this.token = token;
+    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({ key, metadata, method, parameters = {}, storeName }) {
+    const encodedMetadata = encodeMetadata(metadata);
+    if (this.edgeURL) {
+      const headers = {
+        authorization: `Bearer ${this.token}`
+      };
+      if (encodedMetadata) {
+        headers[METADATA_HEADER_INTERNAL] = encodedMetadata;
+      }
+      const path = key ? `/${this.siteID}/${storeName}/${key}` : `/${this.siteID}/${storeName}`;
+      const url2 = new URL(path, 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/sites/${this.siteID}/blobs`, this.apiURL ?? "https://api.netlify.com");
+    for (const key2 in parameters) {
+      url.searchParams.set(key2, parameters[key2]);
+    }
+    url.searchParams.set("context", storeName);
+    if (key === void 0) {
+      return {
+        headers: apiHeaders,
+        url: url.toString()
+      };
+    }
+    url.pathname += `/${key}`;
+    if (encodedMetadata) {
+      apiHeaders[METADATA_HEADER_EXTERNAL] = encodedMetadata;
+    }
+    if (method === "head") {
+      return {
+        headers: apiHeaders,
+        url: url.toString()
+      };
+    }
+    const res = await this.fetch(url.toString(), { headers: apiHeaders, 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,
+    headers: extraHeaders,
+    key,
+    metadata,
+    method,
+    parameters,
+    storeName
+  }) {
+    const { headers: baseHeaders = {}, url } = await this.getFinalRequest({
+      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,
+    edgeURL: context.edgeURL ?? options.edgeURL,
+    fetch: options.fetch,
+    siteID,
+    token
+  };
+  return clientOptions;
+};
+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 Store = class _Store {
+  constructor(options) {
+    this.client = options.client;
+    if ("deployID" in options) {
+      _Store.validateDeployID(options.deployID);
+      this.name = `deploy:${options.deployID}`;
+    } else {
+      _Store.validateStoreName(options.name);
+      this.name = 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 { type } = options ?? {};
+    const res = await this.client.makeRequest({ 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) {
+    const res = await this.client.makeRequest({ 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 { etag: requestETag, type } = options ?? {};
+    const headers = requestETag ? { "if-none-match": requestETag } : void 0;
+    const res = await this.client.makeRequest({ 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 (Buffer3.byteLength(key, "utf8") > 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.startsWith("deploy:") || name.startsWith("deploy%3A1")) {
+      throw new Error("Store name must not start with the `deploy:` reserved keyword.");
+    }
+    if (name.includes("/") || name.includes("%2F")) {
+      throw new Error("Store name must not contain forward slashes (/).");
+    }
+    if (Buffer3.byteLength(name, "utf8") > 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/headers.ts
+var generateNetlifyVaryValues = ({ headers, languages, cookies }) => {
+  const values = [];
+  if (headers.length !== 0) {
+    values.push(`header=${headers.join(`|`)}`);
+  }
+  if (languages.length !== 0) {
+    values.push(`language=${languages.join(`|`)}`);
+  }
+  if (cookies.length !== 0) {
+    values.push(`cookie=${cookies.join(`|`)}`);
+  }
+  return values.join(",");
+};
+var getHeaderValueArray = (header) => {
+  return header.split(",").map((value) => value.trim());
+};
+var omitHeaderValues = (header, values) => {
+  const headerValues = getHeaderValueArray(header);
+  const filteredValues = headerValues.filter(
+    (value) => !values.some((val) => value.startsWith(val))
+  );
+  return filteredValues.join(", ");
+};
+var mapHeaderValues = (header, callback) => {
+  const headerValues = getHeaderValueArray(header);
+  const mappedValues = headerValues.map(callback);
+  return mappedValues.join(", ");
+};
+var setVaryHeaders = (headers, request, { basePath, i18n }) => {
+  const netlifyVaryValues = {
+    headers: [],
+    languages: [],
+    cookies: ["__prerender_bypass", "__next_preview_data"]
+  };
+  const vary = headers.get("vary");
+  if (vary !== null) {
+    netlifyVaryValues.headers.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.languages.push(...locales);
+    netlifyVaryValues.cookies.push(`NEXT_LOCALE`);
+  }
+  headers.set(`netlify-vary`, generateNetlifyVaryValues(netlifyVaryValues));
+};
+function encodeBlobKey(key) {
+  return Buffer4.from(key.replace(/^\//, "")).toString("base64");
+}
+var adjustDateHeader = async (headers, request) => {
+  if (headers.get("x-nextjs-cache") !== "HIT") {
+    return;
+  }
+  const path = new URL(request.url).pathname;
+  const key = encodeBlobKey(path);
+  const blobStore = getDeployStore();
+  const { lastModified } = await blobStore.get(key, { type: "json" }) ?? {};
+  if (!lastModified) {
+    return;
+  }
+  const lastModifiedDate = new Date(lastModified);
+  headers.set("x-nextjs-date", headers.get("date") ?? lastModifiedDate.toUTCString());
+  headers.set("date", lastModifiedDate.toUTCString());
+};
+var setCacheControlHeaders = (headers, request) => {
+  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 privateCacheControl = omitHeaderValues(cacheControl, [
+      "s-maxage",
+      "stale-while-revalidate"
+    ]);
+    const sharedCacheControl = mapHeaderValues(
+      cacheControl,
+      (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
+    );
+    headers.set("cache-control", privateCacheControl || "public, max-age=0, must-revalidate");
+    headers.set("netlify-cdn-cache-control", sharedCacheControl);
+  }
+};
+var setCacheTagsHeaders = (headers, request, manifest) => {
+  const path = new URL(request.url).pathname;
+  const tags = manifest[path];
+  headers.set("cache-tag", tags);
+};
+
+export {
+  setVaryHeaders,
+  adjustDateHeader,
+  setCacheControlHeaders,
+  setCacheTagsHeaders
+};

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

@@ -0,0 +1,113 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/content/server.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, readlink, symlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var copyNextServerCode = async (ctx) => {
+  const srcDir = join(ctx.publishDir, "standalone/.next");
+  const destDir = join(ctx.serverHandlerDir, ".next");
+  const paths = await (0, import_fast_glob.default)([`*`, `server/*`, `server/chunks/*`, `server/+(app|pages)/**/*.js`], {
+    cwd: srcDir,
+    extglob: true
+  });
+  await Promise.all(
+    paths.map(async (path) => {
+      const srcPath = join(srcDir, path);
+      const destPath = join(destDir, path);
+      if (path === "server/middleware-manifest.json") {
+        try {
+          await replaceMiddlewareManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch middleware manifest file", { cause: error });
+        }
+        return;
+      }
+      await cp(srcPath, destPath, { recursive: true });
+    })
+  );
+};
+async function recreateNodeModuleSymlinks(src, dest, org) {
+  const dirents = await readdir(join(src, org || ""), { withFileTypes: true });
+  await Promise.all(
+    dirents.map(async (dirent) => {
+      if (dirent.name.startsWith("@")) {
+        return recreateNodeModuleSymlinks(src, dest, dirent.name);
+      }
+      if (dirent.isSymbolicLink()) {
+        const symlinkSrc = join(dest, org || "", dirent.name);
+        const symlinkTarget = await readlink(join(src, org || "", dirent.name));
+        const symlinkDest = join(dest, org || "", symlinkTarget);
+        if (existsSync(symlinkDest) && !existsSync(symlinkSrc)) {
+          if (org) {
+            await mkdir(join(dest, org), { recursive: true });
+          }
+          await symlink(symlinkDest, symlinkSrc);
+        }
+      }
+    })
+  );
+}
+var copyNextDependencies = async (ctx) => {
+  const srcDir = join(ctx.publishDir, "standalone/node_modules");
+  const destDir = join(ctx.serverHandlerDir, "node_modules");
+  await cp(srcDir, destDir, { recursive: true });
+  await recreateNodeModuleSymlinks(ctx.resolve("node_modules"), destDir);
+};
+var writeTagsManifest = async (ctx) => {
+  const manifest = await ctx.getPrerenderManifest();
+  const routes = Object.entries(manifest.routes).map(async ([route, definition]) => {
+    let tags;
+    if (definition.dataRoute?.endsWith(".rsc")) {
+      const path = join(ctx.publishDir, `server/app/${route === "/" ? "/index" : route}.meta`);
+      try {
+        const file = await readFile(path, "utf-8");
+        const meta = JSON.parse(file);
+        tags = meta.headers["x-next-cache-tags"];
+      } catch {
+        console.log(`Unable to read cache tags for: ${path}`);
+      }
+    }
+    if (definition.dataRoute?.endsWith(".json")) {
+      tags = `_N_T_${route}`;
+    }
+    if (definition.dataRoute === null) {
+      tags = definition.initialHeaders?.["x-next-cache-tags"];
+    }
+    return [route, tags];
+  });
+  await writeFile(
+    join(ctx.serverHandlerDir, ".netlify/tags-manifest.json"),
+    JSON.stringify(Object.fromEntries(await Promise.all(routes))),
+    "utf-8"
+  );
+};
+var replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
+  };
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
+};
+
+export {
+  copyNextServerCode,
+  copyNextDependencies,
+  writeTagsManifest
+};