@netlify/plugin-nextjs 5.0.0-rc.6 → 5.0.0-rc.7

package/README.md

@@ -40,6 +40,8 @@ create it. These also run nightly and on release PRs.
 
 ### Integration testing
 
+> **Prerequisite** Run `npm run build` before running integration tests.
+
 How to add new integration test scenarios to the application:
 
 1. Create a new folder under `tests/fixtures/<your-name>`

package/dist/build/content/next-shims/telemetry-storage.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/build/content/next-shims/telemetry-storage.cts
+var telemetry_storage_exports = {};
+__export(telemetry_storage_exports, {
+  TelemetryShim: () => TelemetryShim
+});
+module.exports = __toCommonJS(telemetry_storage_exports);
+var TelemetryShim = class {
+  sessionId = "shim";
+  get anonymousId() {
+    return "shim";
+  }
+  get salt() {
+    return "shim";
+  }
+  setEnabled() {
+    return null;
+  }
+  get isEnabled() {
+    return false;
+  }
+  oneWayHash() {
+    return "shim";
+  }
+  record() {
+    return Promise.resolve({ isFulfilled: true, isRejected: false });
+  }
+  flush() {
+    return Promise.resolve(null);
+  }
+  flushDetached() {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TelemetryShim
+});

package/dist/build/content/prerendered.js

@@ -7,7 +7,9 @@
 import {
   copyFetchContent,
   copyPrerenderedContent
-} from "../../esm-chunks/chunk-75UGFPYW.js";
+} from "../../esm-chunks/chunk-4635LKT6.js";
+import "../../esm-chunks/chunk-PDPDW32D.js";
+import "../../esm-chunks/chunk-Y3K5Q6FP.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";

package/dist/build/content/server.js

@@ -7,9 +7,12 @@
 import {
   copyNextDependencies,
   copyNextServerCode,
+  getPatchesToApply,
   verifyHandlerDirStructure,
   writeTagsManifest
-} from "../../esm-chunks/chunk-CSTSA3JJ.js";
+} from "../../esm-chunks/chunk-YSGPGDIG.js";
+import "../../esm-chunks/chunk-PDPDW32D.js";
+import "../../esm-chunks/chunk-Y3K5Q6FP.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-MGPEWDDD.js";
 import "../../esm-chunks/chunk-PJG75HGC.js";
@@ -18,6 +21,7 @@ import "../../esm-chunks/chunk-5JVNISGM.js";
 export {
   copyNextDependencies,
   copyNextServerCode,
+  getPatchesToApply,
   verifyHandlerDirStructure,
   writeTagsManifest
 };

package/dist/build/content/static.js

@@ -10,7 +10,9 @@ import {
   copyStaticExport,
   publishStaticDir,
   unpublishStaticDir
-} from "../../esm-chunks/chunk-WFVNEURA.js";
+} from "../../esm-chunks/chunk-GV3YIJ33.js";
+import "../../esm-chunks/chunk-PDPDW32D.js";
+import "../../esm-chunks/chunk-Y3K5Q6FP.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";

package/dist/build/functions/server.js

@@ -6,8 +6,10 @@
     
 import {
   createServerHandler
-} from "../../esm-chunks/chunk-W7XTKMHH.js";
-import "../../esm-chunks/chunk-CSTSA3JJ.js";
+} from "../../esm-chunks/chunk-757FQQND.js";
+import "../../esm-chunks/chunk-YSGPGDIG.js";
+import "../../esm-chunks/chunk-PDPDW32D.js";
+import "../../esm-chunks/chunk-Y3K5Q6FP.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-3NYX5FXN.js";
 import "../../esm-chunks/chunk-MGPEWDDD.js";

package/dist/esm-chunks/{chunk-75UGFPYW.js → chunk-4635LKT6.js}

@@ -4,6 +4,13 @@
         return createRequire(import.meta.url);
       })();
     
+import {
+  wrapTracer
+} from "./chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-Y3K5Q6FP.js";
 import {
   require_out
 } from "./chunk-VZNKO4OO.js";
@@ -15,10 +22,11 @@ import {
 } from "./chunk-5JVNISGM.js";
 
 // src/build/content/prerendered.ts
-var import_fast_glob = __toESM(require_out(), 1);
+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 {
@@ -124,6 +132,7 @@ function pLimit(concurrency) {
 }
 
 // src/build/content/prerendered.ts
+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({
@@ -166,47 +175,49 @@ var buildFetchCacheValue = async (path) => ({
   ...JSON.parse(await readFile(path, "utf-8"))
 });
 var copyPrerenderedContent = async (ctx) => {
-  try {
-    await mkdir(ctx.blobDir, { recursive: true });
-    const manifest = await ctx.getPrerenderManifest();
-    const limitConcurrentPrerenderContentHandling = pLimit(10);
-    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) {
-            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 tracer.withActiveSpan("copyPrerenderedContent", async () => {
+    try {
+      await mkdir(ctx.blobDir, { recursive: true });
+      const manifest = await ctx.getPrerenderManifest();
+      const limitConcurrentPrerenderContentHandling = pLimit(10);
+      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) {
+              case (meta.dataRoute?.endsWith("/default.rsc") && !existsSync(join(ctx.publishDir, "server/app", `${key}.html`))):
                 return;
-              }
-              value = await buildPagesCacheValue(join(ctx.publishDir, "server/pages", key));
-              break;
-            case meta.dataRoute?.endsWith(".rsc"):
-              value = await buildAppCacheValue(join(ctx.publishDir, "server/app", key));
-              break;
-            case meta.dataRoute === null:
-              value = await buildRouteCacheValue(join(ctx.publishDir, "server/app", key));
-              break;
-            default:
-              throw new Error(`Unrecognized content: ${route}`);
-          }
-          await writeCacheEntry(key, value, lastModified, 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"));
-      await writeCacheEntry(key, value, lastModified, ctx);
+              case meta.dataRoute?.endsWith(".json"):
+                if (manifest.notFoundRoutes.includes(route)) {
+                  return;
+                }
+                value = await buildPagesCacheValue(join(ctx.publishDir, "server/pages", key));
+                break;
+              case meta.dataRoute?.endsWith(".rsc"):
+                value = await buildAppCacheValue(join(ctx.publishDir, "server/app", key));
+                break;
+              case meta.dataRoute === null:
+                value = await buildRouteCacheValue(join(ctx.publishDir, "server/app", key));
+                break;
+              default:
+                throw new Error(`Unrecognized content: ${route}`);
+            }
+            await writeCacheEntry(key, value, lastModified, 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"));
+        await writeCacheEntry(key, value, lastModified, ctx);
+      }
+    } catch (error) {
+      ctx.failBuild("Failed assembling prerendered content for upload", error);
     }
-  } catch (error) {
-    ctx.failBuild("Failed assembling prerendered content for upload", error);
-  }
+  });
 };
 var copyFetchContent = async (ctx) => {
   try {

package/dist/esm-chunks/{chunk-W7XTKMHH.js → chunk-757FQQND.js}

@@ -9,7 +9,14 @@ import {
   copyNextServerCode,
   verifyHandlerDirStructure,
   writeTagsManifest
-} from "./chunk-CSTSA3JJ.js";
+} from "./chunk-YSGPGDIG.js";
+import {
+  wrapTracer
+} from "./chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-Y3K5Q6FP.js";
 import {
   require_out
 } from "./chunk-VZNKO4OO.js";
@@ -21,44 +28,49 @@ import {
 } from "./chunk-5JVNISGM.js";
 
 // src/build/functions/server.ts
-var import_fast_glob = __toESM(require_out(), 1);
+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) => {
-  const promises = [];
-  const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
-  if (includedFiles.length !== 0) {
-    const resolvedFiles = await Promise.all(
-      includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
-    );
-    for (const filePath of resolvedFiles.flat()) {
+  await tracer.withActiveSpan("copyHandlerDependencies", async (span) => {
+    const promises = [];
+    const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
+    span.setAttribute("next.includedFiles", includedFiles.join(","));
+    if (includedFiles.length !== 0) {
+      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
+            }
+          )
+        );
+      }
+    }
+    const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+    for (const filePath of fileList) {
       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
-          }
-        )
+        cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerDir, ".netlify", filePath), {
+          recursive: true,
+          force: true
+        })
       );
     }
-  }
-  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.serverHandlerDir, ".netlify", filePath), {
-        recursive: true,
-        force: true
-      })
-    );
-  }
-  await Promise.all(promises);
+    await Promise.all(promises);
+  });
 };
 var writeHandlerManifest = async (ctx) => {
   await writeFile(
@@ -96,18 +108,18 @@ var writeHandlerFile = async (ctx) => {
   await writeFile(join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.mjs`), handler);
 };
 var createServerHandler = async (ctx) => {
-  await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
-  await mkdir(join(ctx.serverHandlerDir, ".netlify"), { recursive: true });
-  await Promise.all([
-    copyNextServerCode(ctx),
-    copyNextDependencies(ctx),
-    writeTagsManifest(ctx),
-    copyHandlerDependencies(ctx),
-    writeHandlerManifest(ctx),
-    writePackageMetadata(ctx),
-    writeHandlerFile(ctx)
-  ]);
-  await verifyHandlerDirStructure(ctx);
+  await tracer.withActiveSpan("createServerHandler", async () => {
+    await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
+    await mkdir(join(ctx.serverHandlerDir, ".netlify"), { recursive: true });
+    await copyNextServerCode(ctx);
+    await copyNextDependencies(ctx);
+    await writeTagsManifest(ctx);
+    await copyHandlerDependencies(ctx);
+    await writeHandlerManifest(ctx);
+    await writePackageMetadata(ctx);
+    await writeHandlerFile(ctx);
+    await verifyHandlerDirStructure(ctx);
+  });
 };
 
 export {

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

@@ -0,0 +1,110 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  wrapTracer
+} from "./chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./chunk-Y3K5Q6FP.js";
+import {
+  require_out
+} from "./chunk-VZNKO4OO.js";
+import {
+  encodeBlobKey
+} from "./chunk-TYCYFZ22.js";
+import {
+  __toESM
+} from "./chunk-5JVNISGM.js";
+
+// src/build/content/static.ts
+init_esm();
+import { existsSync } from "node:fs";
+import { cp, mkdir, rename, rm } from "node:fs/promises";
+import { basename, join } from "node:path";
+var import_fast_glob = __toESM(require_out(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var copyStaticContent = async (ctx) => {
+  return tracer.withActiveSpan("copyStaticContent", async () => {
+    const srcDir = join(ctx.publishDir, "server/pages");
+    const destDir = ctx.blobDir;
+    const paths = await (0, import_fast_glob.default)("**/*.+(html|json)", {
+      cwd: srcDir,
+      extglob: true
+    });
+    try {
+      await Promise.all(
+        paths.filter((path) => !paths.includes(`${path.slice(0, -5)}.json`)).map(async (path) => {
+          await cp(join(srcDir, path), join(destDir, await encodeBlobKey(path)), {
+            recursive: true,
+            force: true
+          });
+        })
+      );
+    } catch (error) {
+      ctx.failBuild("Failed assembling static pages for upload", error);
+    }
+  });
+};
+var copyStaticAssets = async (ctx) => {
+  return tracer.withActiveSpan("copyStaticAssets", async (span) => {
+    try {
+      await rm(ctx.staticDir, { recursive: true, force: true });
+      const { basePath } = await ctx.getRoutesManifest();
+      if (existsSync(ctx.resolveFromSiteDir("public"))) {
+        await cp(ctx.resolveFromSiteDir("public"), join(ctx.staticDir, basePath), {
+          recursive: true
+        });
+      }
+      if (existsSync(join(ctx.publishDir, "static"))) {
+        await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, basePath, "_next/static"), {
+          recursive: true
+        });
+      }
+    } catch (error) {
+      span.end();
+      ctx.failBuild("Failed copying static assets", error);
+    }
+  });
+};
+var copyStaticExport = async (ctx) => {
+  await tracer.withActiveSpan("copyStaticExport", async () => {
+    try {
+      await rm(ctx.staticDir, { recursive: true, force: true });
+      await cp(ctx.resolveFromSiteDir("out"), ctx.staticDir, { recursive: true });
+    } catch (error) {
+      ctx.failBuild("Failed copying static export", error);
+    }
+  });
+};
+var publishStaticDir = async (ctx) => {
+  try {
+    await rm(ctx.tempPublishDir, { recursive: true, force: true });
+    await mkdir(basename(ctx.tempPublishDir), { recursive: true });
+    await rename(ctx.publishDir, ctx.tempPublishDir);
+    await rename(ctx.staticDir, ctx.publishDir);
+  } catch (error) {
+    ctx.failBuild("Failed publishing static content", error instanceof Error ? { error } : {});
+  }
+};
+var unpublishStaticDir = async (ctx) => {
+  try {
+    if (existsSync(ctx.tempPublishDir)) {
+      await rename(ctx.publishDir, ctx.staticDir);
+      await rename(ctx.tempPublishDir, ctx.publishDir);
+    }
+  } catch {
+  }
+};
+
+export {
+  copyStaticContent,
+  copyStaticAssets,
+  copyStaticExport,
+  publishStaticDir,
+  unpublishStaticDir
+};

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

@@ -0,0 +1,89 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  SpanStatusCode,
+  context,
+  init_esm
+} from "./chunk-Y3K5Q6FP.js";
+
+// node_modules/@opentelemetry/api/build/esm/experimental/trace/SugaredTracer.js
+init_esm();
+var defaultOnException = function(e, span) {
+  span.recordException(e);
+  span.setStatus({
+    code: SpanStatusCode.ERROR
+  });
+};
+function wrapTracer(tracer) {
+  return new SugaredTracer(tracer);
+}
+var SugaredTracer = (
+  /** @class */
+  function() {
+    function SugaredTracer2(tracer) {
+      this._tracer = tracer;
+      this.startSpan = tracer.startSpan.bind(this._tracer);
+      this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer);
+    }
+    SugaredTracer2.prototype.withActiveSpan = function(name, arg2, arg3, arg4) {
+      var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+      return this._tracer.startActiveSpan(name, opts, ctx, function(span) {
+        return handleFn(span, opts, fn);
+      });
+    };
+    SugaredTracer2.prototype.withSpan = function(name, arg2, arg3, arg4) {
+      var _a = massageParams(arg2, arg3, arg4), opts = _a.opts, ctx = _a.ctx, fn = _a.fn;
+      var span = this._tracer.startSpan(name, opts, ctx);
+      return handleFn(span, opts, fn);
+    };
+    return SugaredTracer2;
+  }()
+);
+function massageParams(arg, arg2, arg3) {
+  var opts;
+  var ctx;
+  var fn;
+  if (!arg2 && !arg3) {
+    fn = arg;
+  } else if (!arg3) {
+    opts = arg;
+    fn = arg2;
+  } else {
+    opts = arg;
+    ctx = arg2;
+    fn = arg3;
+  }
+  opts = opts !== null && opts !== void 0 ? opts : {};
+  ctx = ctx !== null && ctx !== void 0 ? ctx : context.active();
+  return { opts, ctx, fn };
+}
+function handleFn(span, opts, fn) {
+  var _a;
+  var onException = (_a = opts.onException) !== null && _a !== void 0 ? _a : defaultOnException;
+  var errorHandler = function(e) {
+    onException(e, span);
+    span.end();
+    throw e;
+  };
+  try {
+    var ret = fn(span);
+    if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === "function") {
+      return ret.then(function(val) {
+        span.end();
+        return val;
+      }, errorHandler);
+    }
+    span.end();
+    return ret;
+  } catch (e) {
+    throw errorHandler(e);
+  }
+}
+
+export {
+  wrapTracer
+};