@netlify/plugin-nextjs 5.8.1 → 5.9.0

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

@@ -0,0 +1,122 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/handlers/request-context.cts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// node_modules/@netlify/functions/dist/chunk-HYMERDCV.mjs
+import { env } from "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 LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 1] = "Debug";
+  LogLevel2[LogLevel2["Log"] = 2] = "Log";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (env.NETLIFY_DEV && !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
+function createRequestContext(request, context) {
+  const backgroundWorkPromises = [];
+  return {
+    captureServerTiming: request?.headers.has("x-next-debug-logging") ?? false,
+    trackBackgroundWork: (promise) => {
+      if (context?.waitUntil) {
+        context.waitUntil(promise);
+      } else {
+        backgroundWorkPromises.push(promise);
+      }
+    },
+    get backgroundWorkPromise() {
+      return Promise.allSettled(backgroundWorkPromises);
+    },
+    logger: systemLogger.withLogLevel(
+      request?.headers.has("x-nf-debug-logging") || request?.headers.has("x-next-debug-logging") ? LogLevel.Debug : LogLevel.Log
+    )
+  };
+}
+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 AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+function getLogger() {
+  return getRequestContext()?.logger ?? systemLogger;
+}
+
+export {
+  createRequestContext,
+  getRequestContext,
+  getLogger
+};

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

@@ -0,0 +1,25 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/shared/blobkey.ts
+import { Buffer } from "node:buffer";
+import { webcrypto as crypto } from "node:crypto";
+var maxLength = 180;
+async function encodeBlobKey(key) {
+  const buffer = Buffer.from(key);
+  const base64 = buffer.toString("base64url");
+  if (base64.length <= maxLength) {
+    return base64;
+  }
+  const digest = await crypto.subtle.digest("SHA-256", buffer);
+  const hash = Buffer.from(digest).toString("base64url");
+  return `${base64.slice(0, maxLength - hash.length - 1)}-${hash}`;
+}
+
+export {
+  encodeBlobKey
+};

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

@@ -0,0 +1,19 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/constants.ts
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var PLUGIN_DIR = resolve(`${MODULE_DIR}../../..`);
+var RUN_CONFIG = "run-config.json";
+
+export {
+  MODULE_DIR,
+  PLUGIN_DIR,
+  RUN_CONFIG
+};

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

@@ -0,0 +1,34 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/revalidate.ts
+import { isPromise } from "node:util/types";
+function isRevalidateMethod(key, nextResponseField) {
+  return key === "revalidate" && typeof nextResponseField === "function";
+}
+var nextResponseProxy = (res, requestContext) => {
+  return new Proxy(res, {
+    get(target, key) {
+      const originalValue = Reflect.get(target, key);
+      if (isRevalidateMethod(key, originalValue)) {
+        return function newRevalidate(...args) {
+          requestContext.didPagesRouterOnDemandRevalidate = true;
+          const result = originalValue.apply(target, args);
+          if (result && isPromise(result)) {
+            requestContext.trackBackgroundWork(result);
+          }
+          return result;
+        };
+      }
+      return originalValue;
+    }
+  });
+};
+
+export {
+  nextResponseProxy
+};

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

@@ -0,0 +1,148 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  __require
+} from "./chunk-OEQOKJGE.js";
+
+// src/build/advanced-api-routes.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var ApiRouteType = /* @__PURE__ */ ((ApiRouteType2) => {
+  ApiRouteType2["SCHEDULED"] = "experimental-scheduled";
+  ApiRouteType2["BACKGROUND"] = "experimental-background";
+  return ApiRouteType2;
+})(ApiRouteType || {});
+async function getAPIRoutesConfigs(ctx) {
+  const uniqueApiRoutes = /* @__PURE__ */ new Set();
+  const functionsConfigManifestPath = join(
+    ctx.publishDir,
+    "server",
+    "functions-config-manifest.json"
+  );
+  if (existsSync(functionsConfigManifestPath)) {
+    const functionsConfigManifest = JSON.parse(
+      await readFile(functionsConfigManifestPath, "utf-8")
+    );
+    for (const apiRoute of Object.keys(functionsConfigManifest.functions)) {
+      uniqueApiRoutes.add(apiRoute);
+    }
+  }
+  const pagesManifestPath = join(ctx.publishDir, "server", "pages-manifest.json");
+  if (existsSync(pagesManifestPath)) {
+    const pagesManifest = JSON.parse(await readFile(pagesManifestPath, "utf-8"));
+    for (const route of Object.keys(pagesManifest)) {
+      if (route.startsWith("/api/")) {
+        uniqueApiRoutes.add(route);
+      }
+    }
+  }
+  if (uniqueApiRoutes.size === 0) {
+    return [];
+  }
+  const appDir = ctx.resolveFromSiteDir(".");
+  const pagesDir = join(appDir, "pages");
+  const srcPagesDir = join(appDir, "src", "pages");
+  const { pageExtensions } = ctx.requiredServerFiles.config;
+  return Promise.all(
+    [...uniqueApiRoutes].map(async (apiRoute) => {
+      const filePath = getSourceFileForPage(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
+      const sharedFields = {
+        apiRoute,
+        filePath,
+        config: {}
+      };
+      if (filePath) {
+        const config = await extractConfigFromFile(filePath, appDir);
+        return {
+          ...sharedFields,
+          config
+        };
+      }
+      return sharedFields;
+    })
+  );
+}
+var SOURCE_FILE_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+var getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIONS) => {
+  for (const root of roots) {
+    for (const extension of pageExtensions) {
+      const file = join(root, `${page}.${extension}`);
+      if (existsSync(file)) {
+        return file;
+      }
+      const fileAtFolderIndex = join(root, page, `index.${extension}`);
+      if (existsSync(fileAtFolderIndex)) {
+        return fileAtFolderIndex;
+      }
+    }
+  }
+};
+var findModuleFromBase = ({
+  paths,
+  candidates
+}) => {
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate, { paths });
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const modulePath = __require.resolve(candidate);
+      if (modulePath) {
+        return modulePath;
+      }
+    } catch {
+    }
+  }
+  return null;
+};
+var extractConstValue;
+var parseModule;
+var extractConfigFromFile = async (apiFilePath, appDir) => {
+  if (!apiFilePath || !existsSync(apiFilePath)) {
+    return {};
+  }
+  const extractConstValueModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/extract-const-value"]
+  });
+  const parseModulePath = findModuleFromBase({
+    paths: [appDir],
+    candidates: ["next/dist/build/analysis/parse-module"]
+  });
+  if (!extractConstValueModulePath || !parseModulePath) {
+    return {};
+  }
+  if (!extractConstValue && extractConstValueModulePath) {
+    extractConstValue = __require(extractConstValueModulePath);
+  }
+  if (!parseModule && parseModulePath) {
+    parseModule = __require(parseModulePath).parseModule;
+  }
+  const { extractExportedConstValue } = extractConstValue;
+  const fileContent = await readFile(apiFilePath, "utf8");
+  if (!fileContent.includes("config")) {
+    return {};
+  }
+  const ast = await parseModule(apiFilePath, fileContent);
+  try {
+    return extractExportedConstValue(ast, "config");
+  } catch {
+    return {};
+  }
+};
+
+export {
+  ApiRouteType,
+  getAPIRoutesConfigs
+};

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

@@ -0,0 +1,120 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-KGYJQ2U2.js";
+import {
+  getAPIRoutesConfigs
+} from "./chunk-ZENB67PD.js";
+import {
+  require_semver
+} from "./chunk-APO262HE.js";
+import {
+  __toESM
+} from "./chunk-OEQOKJGE.js";
+
+// src/build/verification.ts
+var import_fast_glob = __toESM(require_out(), 1);
+var import_semver = __toESM(require_semver(), 1);
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var SUPPORTED_NEXT_VERSIONS = ">=13.5.0";
+var verifications = /* @__PURE__ */ new Set();
+function verifyPublishDir(ctx) {
+  if (!existsSync(ctx.publishDir)) {
+    ctx.failBuild(
+      `Your publish directory was not found at: ${ctx.publishDir}. Please check your build settings`
+    );
+  }
+  if (ctx.publishDir === ctx.resolveFromPackagePath("")) {
+    ctx.failBuild(
+      `Your publish directory cannot be the same as the base directory of your site. Please check your build settings`
+    );
+  }
+  try {
+    ctx.buildConfig;
+  } catch {
+    ctx.failBuild(
+      "Your publish directory does not contain expected Next.js build output. Please check your build settings"
+    );
+  }
+  if (ctx.buildConfig.output === "standalone" || ctx.buildConfig.output === void 0) {
+    if (!existsSync(join(ctx.publishDir, "BUILD_ID"))) {
+      ctx.failBuild(
+        "Your publish directory does not contain expected Next.js build output. Please check your build settings"
+      );
+    }
+    if (!existsSync(ctx.standaloneRootDir)) {
+      ctx.failBuild(
+        `Your publish directory does not contain expected Next.js build output. Please make sure you are using Next.js version (${SUPPORTED_NEXT_VERSIONS})`
+      );
+    }
+    if (ctx.nextVersion && !(0, import_semver.satisfies)(ctx.nextVersion, SUPPORTED_NEXT_VERSIONS, { includePrerelease: true })) {
+      ctx.failBuild(
+        `@netlify/plugin-nextjs@5 requires Next.js version ${SUPPORTED_NEXT_VERSIONS}, but found ${ctx.nextVersion}. Please upgrade your project's Next.js version.`
+      );
+    }
+  }
+  if (ctx.buildConfig.output === "export") {
+    if (!ctx.exportDetail?.success) {
+      ctx.failBuild(`Your export failed to build. Please check your build settings`);
+    }
+    if (!existsSync(ctx.exportDetail?.outDirectory)) {
+      ctx.failBuild(
+        `Your export directory was not found at: ${ctx.exportDetail?.outDirectory}. Please check your build settings`
+      );
+    }
+  }
+}
+async function verifyAdvancedAPIRoutes(ctx) {
+  const apiRoutesConfigs = await getAPIRoutesConfigs(ctx);
+  const unsupportedAPIRoutes = apiRoutesConfigs.filter((apiRouteConfig) => {
+    return apiRouteConfig.config.type === "experimental-background" /* BACKGROUND */ || apiRouteConfig.config.type === "experimental-scheduled" /* SCHEDULED */;
+  });
+  if (unsupportedAPIRoutes.length !== 0) {
+    ctx.failBuild(
+      `@netlify/plugin-nextjs@5 does not support advanced API routes. The following API routes should be migrated to Netlify background or scheduled functions:
+${unsupportedAPIRoutes.map((apiRouteConfig) => ` - ${apiRouteConfig.apiRoute} (type: "${apiRouteConfig.config.type}")`).join("\n")}
+
+Refer to https://ntl.fyi/next-scheduled-bg-function-migration as migration example.`
+    );
+  }
+}
+var formDetectionRegex = /<form[^>]*?\s(netlify|data-netlify)[=>\s]/;
+async function verifyNetlifyFormsWorkaround(ctx) {
+  const srcDir = ctx.resolveFromSiteDir("public");
+  const paths = await (0, import_fast_glob.glob)("**/*.html", {
+    cwd: srcDir,
+    dot: true
+  });
+  try {
+    for (const path of paths) {
+      const html = await readFile(join(srcDir, path), "utf-8");
+      if (formDetectionRegex.test(html)) {
+        verifications.add("netlifyFormsWorkaround");
+        return;
+      }
+    }
+  } catch (error) {
+    ctx.failBuild("Failed verifying public files", error);
+  }
+}
+function verifyNetlifyForms(ctx, html) {
+  if (process.env.NETLIFY_NEXT_VERIFY_FORMS !== "0" && process.env.NETLIFY_NEXT_VERIFY_FORMS?.toUpperCase() !== "FALSE" && !verifications.has("netlifyFormsWorkaround") && formDetectionRegex.test(html)) {
+    ctx.failBuild(
+      "@netlify/plugin-nextjs@5 requires migration steps to support Netlify Forms. Refer to https://ntl.fyi/next-runtime-forms-migration for migration example."
+    );
+  }
+}
+
+export {
+  verifyPublishDir,
+  verifyAdvancedAPIRoutes,
+  verifyNetlifyFormsWorkaround,
+  verifyNetlifyForms
+};