@netlify/plugin-nextjs 5.1.2 → 5.2.0

package/dist/build/plugin-context.js

@@ -4,12 +4,243 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  EDGE_HANDLER_NAME,
-  PluginContext,
-  SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-L6OM53B6.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/plugin-context.ts
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var PLUGIN_DIR = join(MODULE_DIR, "../..");
+var DEFAULT_PUBLISH_DIR = ".next";
+var SERVER_HANDLER_NAME = "___netlify-server-handler";
+var EDGE_HANDLER_NAME = "___netlify-edge-handler";
+var PluginContext = class {
+  utils;
+  netlifyConfig;
+  pluginName;
+  pluginVersion;
+  constants;
+  packageJSON;
+  /** Absolute path of the next runtime plugin directory */
+  pluginDir = PLUGIN_DIR;
+  get relPublishDir() {
+    return this.constants.PUBLISH_DIR ?? join(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR);
+  }
+  /** Temporary directory for stashing the build output */
+  get tempPublishDir() {
+    return this.resolveFromPackagePath(".netlify/.next");
+  }
+  /** Absolute path of the publish directory */
+  get publishDir() {
+    return resolve(this.relPublishDir);
+  }
+  /**
+   * Relative package path in non monorepo setups this is an empty string
+   * This path is provided by Next.js RequiredServerFiles manifest
+   * @example ''
+   * @example 'apps/my-app'
+   */
+  get relativeAppDir() {
+    return this.requiredServerFiles.relativeAppDir ?? "";
+  }
+  /**
+   * The working directory inside the lambda that is used for monorepos to execute the serverless function
+   */
+  get lambdaWorkingDirectory() {
+    return join("/var/task", this.distDirParent);
+  }
+  /**
+   * Retrieves the root of the `.next/standalone` directory
+   */
+  get standaloneRootDir() {
+    return join(this.publishDir, "standalone");
+  }
+  /**
+   * The resolved relative next dist directory defaults to `.next`,
+   * but can be configured through the next.config.js. For monorepos this will include the packagePath
+   * If we need just the plain dist dir use the `nextDistDir`
+   */
+  get distDir() {
+    const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
+    return relative(process.cwd(), resolve(this.relativeAppDir, dir));
+  }
+  /** Represents the parent directory of the .next folder or custom distDir */
+  get distDirParent() {
+    return join(this.distDir, "..");
+  }
+  /** The `.next` folder or what the custom dist dir is set to */
+  get nextDistDir() {
+    return relative(this.distDirParent, this.distDir);
+  }
+  /** Retrieves the `.next/standalone/` directory monorepo aware */
+  get standaloneDir() {
+    return join(this.standaloneRootDir, this.distDirParent);
+  }
+  /**
+   * Absolute path of the directory that is published and deployed to the Netlify CDN
+   * Will be swapped with the publish directory
+   * `.netlify/static`
+   */
+  get staticDir() {
+    return this.resolveFromPackagePath(".netlify/static");
+  }
+  /**
+   * Absolute path of the directory that will be deployed to the blob store
+   * region aware: `.netlify/deploy/v1/blobs/deploy`
+   * default: `.netlify/blobs/deploy`
+   */
+  get blobDir() {
+    if (this.useRegionalBlobs) {
+      return this.resolveFromPackagePath(".netlify/deploy/v1/blobs/deploy");
+    }
+    return this.resolveFromPackagePath(".netlify/blobs/deploy");
+  }
+  get buildVersion() {
+    return this.constants.NETLIFY_BUILD_VERSION || "v0.0.0";
+  }
+  get useRegionalBlobs() {
+    return false;
+  }
+  /**
+   * Absolute path of the directory containing the files for the serverless lambda function
+   * `.netlify/functions-internal`
+   */
+  get serverFunctionsDir() {
+    return this.resolveFromPackagePath(".netlify/functions-internal");
+  }
+  /** Absolute path of the server handler */
+  get serverHandlerRootDir() {
+    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
+  }
+  get serverHandlerDir() {
+    if (this.relativeAppDir.length === 0) {
+      return this.serverHandlerRootDir;
+    }
+    return join(this.serverHandlerRootDir, this.distDirParent);
+  }
+  get nextServerHandler() {
+    if (this.relativeAppDir.length !== 0) {
+      return join(this.lambdaWorkingDirectory, ".netlify/dist/run/handlers/server.js");
+    }
+    return "./.netlify/dist/run/handlers/server.js";
+  }
+  /**
+   * Absolute path of the directory containing the files for deno edge functions
+   * `.netlify/edge-functions`
+   */
+  get edgeFunctionsDir() {
+    return this.resolveFromPackagePath(".netlify/edge-functions");
+  }
+  /** Absolute path of the edge handler */
+  get edgeHandlerDir() {
+    return join(this.edgeFunctionsDir, EDGE_HANDLER_NAME);
+  }
+  constructor(options) {
+    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
+    this.pluginName = this.packageJSON.name;
+    this.pluginVersion = this.packageJSON.version;
+    this.constants = options.constants;
+    this.utils = options.utils;
+    this.netlifyConfig = options.netlifyConfig;
+  }
+  /** Resolves a path correctly with mono repository awareness for .netlify directories mainly  */
+  resolveFromPackagePath(...args) {
+    return resolve(this.constants.PACKAGE_PATH || "", ...args);
+  }
+  /** Resolves a path correctly from site directory */
+  resolveFromSiteDir(...args) {
+    return resolve(this.requiredServerFiles.appDir, ...args);
+  }
+  /** Get the next prerender-manifest.json */
+  async getPrerenderManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "prerender-manifest.json"), "utf-8"));
+  }
+  /**
+   * Uses various heuristics to try to find the .next dir.
+   * Works by looking for BUILD_ID, so requires the site to have been built
+   */
+  findDotNext() {
+    for (const dir of [
+      // The publish directory
+      this.publishDir,
+      // In the root
+      resolve(DEFAULT_PUBLISH_DIR),
+      // The sibling of the publish directory
+      resolve(this.publishDir, "..", DEFAULT_PUBLISH_DIR),
+      // In the package dir
+      resolve(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR)
+    ]) {
+      if (existsSync(join(dir, "BUILD_ID"))) {
+        return dir;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get Next.js middleware config from the build output
+   */
+  async getMiddlewareManifest() {
+    return JSON.parse(
+      await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
+    );
+  }
+  // don't make private as it is handy inside testing to override the config
+  _requiredServerFiles = null;
+  /** Get RequiredServerFiles manifest from build output **/
+  get requiredServerFiles() {
+    if (!this._requiredServerFiles) {
+      let requiredServerFilesJson = join(this.publishDir, "required-server-files.json");
+      if (!existsSync(requiredServerFilesJson)) {
+        const dotNext = this.findDotNext();
+        if (dotNext) {
+          requiredServerFilesJson = join(dotNext, "required-server-files.json");
+        }
+      }
+      this._requiredServerFiles = JSON.parse(
+        readFileSync(requiredServerFilesJson, "utf-8")
+      );
+    }
+    return this._requiredServerFiles;
+  }
+  #exportDetail = null;
+  /** Get metadata when output = export */
+  get exportDetail() {
+    if (this.buildConfig.output !== "export") {
+      return null;
+    }
+    if (!this.#exportDetail) {
+      const detailFile = join(
+        this.requiredServerFiles.appDir,
+        this.buildConfig.distDir,
+        "export-detail.json"
+      );
+      if (!existsSync(detailFile)) {
+        return null;
+      }
+      try {
+        this.#exportDetail = JSON.parse(readFileSync(detailFile, "utf-8"));
+      } catch {
+      }
+    }
+    return this.#exportDetail;
+  }
+  /** Get Next Config from build output **/
+  get buildConfig() {
+    return this.requiredServerFiles.config;
+  }
+  /**
+   * Get Next.js routes manifest from the build output
+   */
+  async getRoutesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
+  }
+  /** Fails a build with a message and an optional error */
+  failBuild(message, error) {
+    return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);
+  }
+};
 export {
   EDGE_HANDLER_NAME,
   PluginContext,

package/dist/build/templates/handler-monorepo.tmpl.js

@@ -7,6 +7,9 @@ import tracing from '{{cwd}}/.netlify/dist/run/handlers/tracing.js'
 
 process.chdir('{{cwd}}')
 
+// Set feature flag for regional blobs
+process.env.USE_REGIONAL_BLOBS = '{{useRegionalBlobs}}'
+
 let cachedHandler
 export default async function (req, context) {
   if (process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL) {

package/dist/build/templates/handler.tmpl.js

@@ -6,6 +6,9 @@ import serverHandler from './.netlify/dist/run/handlers/server.js'
 import { getTracer } from './.netlify/dist/run/handlers/tracer.cjs'
 import tracing from './.netlify/dist/run/handlers/tracing.js'
 
+// Set feature flag for regional blobs
+process.env.USE_REGIONAL_BLOBS = '{{useRegionalBlobs}}'
+
 export default async function handler(req, context) {
   if (process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL) {
     tracing.start()

package/dist/build/verification.js

@@ -5,14 +5,87 @@
       })();
     
 import {
-  verifyBuildConfig,
-  verifyNextVersion,
-  verifyNoAdvancedAPIRoutes,
-  verifyPublishDir
-} from "../esm-chunks/chunk-K7BTUM7O.js";
-import "../esm-chunks/chunk-PJG75HGC.js";
-import "../esm-chunks/chunk-BG455SFE.js";
-import "../esm-chunks/chunk-5JVNISGM.js";
+  require_semver
+} from "../esm-chunks/chunk-PJG75HGC.js";
+import {
+  __toESM
+} from "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/build/verification.ts
+var import_semver = __toESM(require_semver(), 1);
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { ApiRouteType, getAPIRoutesConfigs } from "./advanced-api-routes.js";
+var SUPPORTED_NEXT_VERSIONS = ">=13.5.0";
+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.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`
+      );
+    }
+  }
+}
+function verifyNextVersion(ctx, nextVersion) {
+  if (!(0, import_semver.satisfies)(nextVersion, SUPPORTED_NEXT_VERSIONS, { includePrerelease: true })) {
+    ctx.failBuild(
+      `@netlify/plugin-next@5 requires Next.js version ${SUPPORTED_NEXT_VERSIONS}, but found ${nextVersion}. Please upgrade your project's Next.js version.`
+    );
+  }
+}
+function verifyBuildConfig(ctx) {
+  if (ctx.buildConfig.experimental.ppr) {
+    console.log(
+      `Partial prerendering is not yet fully supported on Netlify, see https://ntl.fyi/nextjs-ppr for details`
+    );
+  }
+}
+async function verifyNoAdvancedAPIRoutes(ctx) {
+  const apiRoutesConfigs = await getAPIRoutesConfigs(ctx);
+  const unsupportedAPIRoutes = apiRoutesConfigs.filter((apiRouteConfig) => {
+    return apiRouteConfig.config.type === ApiRouteType.BACKGROUND || apiRouteConfig.config.type === ApiRouteType.SCHEDULED;
+  });
+  if (unsupportedAPIRoutes.length !== 0) {
+    ctx.failBuild(
+      `@netlify/plugin-next@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.`
+    );
+  }
+}
 export {
   verifyBuildConfig,
   verifyNextVersion,

package/dist/esm-chunks/{package-RVJOBSMH.js → package-ZBRSUKN7.js}

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.1.2";
+var version = "5.2.0";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -57,14 +57,14 @@ var bugs = {
 var homepage = "https://github.com/netlify/next-runtime-minimal#readme";
 var devDependencies = {
   "@fastly/http-compute-js": "1.1.4",
-  "@netlify/blobs": "^7.0.1",
-  "@netlify/build": "^29.37.2",
-  "@netlify/edge-bundler": "^11.4.0",
+  "@netlify/blobs": "^7.3.0",
+  "@netlify/build": "^29.41.0",
+  "@netlify/edge-bundler": "^12.0.0",
   "@netlify/edge-functions": "^2.5.1",
   "@netlify/eslint-config-node": "^7.0.1",
   "@netlify/functions": "^2.5.1",
   "@netlify/serverless-functions-api": "^1.10.1",
-  "@netlify/zip-it-and-ship-it": "^9.30.0",
+  "@netlify/zip-it-and-ship-it": "^9.32.0",
   "@opentelemetry/api": "^1.8.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.49.0",
   "@opentelemetry/resources": "^1.21.0",

package/dist/index.js

@@ -4,21 +4,6 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  createServerHandler
-} from "./esm-chunks/chunk-HESS57SH.js";
-import {
-  copyPrerenderedContent
-} from "./esm-chunks/chunk-MRD3XSKD.js";
-import "./esm-chunks/chunk-4BNHE6TP.js";
-import {
-  copyStaticAssets,
-  copyStaticContent,
-  copyStaticExport,
-  publishStaticDir,
-  unpublishStaticDir
-} from "./esm-chunks/chunk-V2T6NUOM.js";
-import "./esm-chunks/chunk-TYCYFZ22.js";
 import {
   wrapTracer
 } from "./esm-chunks/chunk-PDPDW32D.js";
@@ -26,33 +11,36 @@ import {
   init_esm,
   trace
 } from "./esm-chunks/chunk-Y3K5Q6FP.js";
+import "./esm-chunks/chunk-5JVNISGM.js";
+
+// src/index.ts
+init_esm();
+import { rm } from "fs/promises";
+import { restoreBuildCache, saveBuildCache } from "./build/cache.js";
+import { copyPrerenderedContent } from "./build/content/prerendered.js";
 import {
-  createEdgeHandlers
-} from "./esm-chunks/chunk-UTQSBE5O.js";
-import "./esm-chunks/chunk-VZNKO4OO.js";
-import {
-  restoreBuildCache,
-  saveBuildCache
-} from "./esm-chunks/chunk-72ZI2IVI.js";
-import {
-  setImageConfig
-} from "./esm-chunks/chunk-MCEOSJH6.js";
-import {
-  PluginContext
-} from "./esm-chunks/chunk-L6OM53B6.js";
+  copyStaticAssets,
+  copyStaticContent,
+  copyStaticExport,
+  publishStaticDir,
+  unpublishStaticDir
+} from "./build/content/static.js";
+import { createEdgeHandlers } from "./build/functions/edge.js";
+import { createServerHandler } from "./build/functions/server.js";
+import { setImageConfig } from "./build/image-cdn.js";
+import { PluginContext } from "./build/plugin-context.js";
 import {
   verifyBuildConfig,
   verifyNoAdvancedAPIRoutes,
   verifyPublishDir
-} from "./esm-chunks/chunk-K7BTUM7O.js";
-import "./esm-chunks/chunk-PJG75HGC.js";
-import "./esm-chunks/chunk-BG455SFE.js";
-import "./esm-chunks/chunk-UYKENJEU.js";
-import "./esm-chunks/chunk-5JVNISGM.js";
-
-// src/index.ts
-init_esm();
+} from "./build/verification.js";
 var tracer = wrapTracer(trace.getTracer("Next.js runtime"));
+var onPreDev = async (options) => {
+  await tracer.withActiveSpan("onPreDev", async () => {
+    const context = new PluginContext(options);
+    await rm(context.blobDir, { recursive: true, force: true });
+  });
+};
 var onPreBuild = async (options) => {
   await tracer.withActiveSpan("onPreBuild", async () => {
     process.env.NEXT_PRIVATE_STANDALONE = "true";
@@ -108,5 +96,6 @@ export {
   onEnd,
   onPostBuild,
   onPreBuild,
+  onPreDev,
   onSuccess
 };

package/dist/run/config.js

@@ -4,13 +4,32 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  getRunConfig,
-  getTagsManifest,
-  setRunConfig
-} from "../esm-chunks/chunk-3SUDZQ7L.js";
-import "../esm-chunks/chunk-UYKENJEU.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// src/run/config.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { PLUGIN_DIR, RUN_CONFIG } from "./constants.js";
+var getRunConfig = async () => {
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, RUN_CONFIG), "utf-8"));
+};
+var setRunConfig = (config) => {
+  const cacheHandler = join(PLUGIN_DIR, ".netlify/dist/run/handlers/cache.cjs");
+  if (!existsSync(cacheHandler)) {
+    throw new Error(`Cache handler not found at ${cacheHandler}`);
+  }
+  config.experimental = {
+    ...config.experimental,
+    incrementalCacheHandlerPath: cacheHandler
+  };
+  config.cacheHandler = cacheHandler;
+  config.cacheMaxMemorySize = 0;
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+};
+var getTagsManifest = async () => {
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, ".netlify/tags-manifest.json"), "utf-8"));
+};
 export {
   getRunConfig,
   getTagsManifest,

package/dist/run/constants.js

@@ -4,12 +4,14 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  MODULE_DIR,
-  PLUGIN_DIR,
-  RUN_CONFIG
-} from "../esm-chunks/chunk-UYKENJEU.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
+
+// 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,