@netlify/plugin-nextjs 5.0.0-rc.5 → 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-VSH4JS2L.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/build/templates/handler-monorepo.tmpl.js

@@ -1,4 +1,9 @@
-import tracing, { trace } from '{{cwd}}/.netlify/dist/run/handlers/tracing.js'
+import {
+  createRequestContext,
+  runWithRequestContext,
+} from '{{cwd}}/.netlify/dist/run/handlers/request-context.cjs'
+import { getTracer } from '{{cwd}}/.netlify/dist/run/handlers/tracer.cjs'
+import tracing from '{{cwd}}/.netlify/dist/run/handlers/tracing.js'
 
 process.chdir('{{cwd}}')
 
@@ -8,10 +13,13 @@ export default async function (req, context) {
     tracing.start()
   }
 
-  /** @type {import('@opentelemetry/api').Tracer} */
-  const tracer = trace.getTracer('Next.js Runtime')
-  return tracer.startActiveSpan('Next.js Server Handler', async (span) => {
-    try {
+  const requestContext = createRequestContext(
+    req.headers.get('x-nf-debug-logging') || req.headers.get('x-next-debug-logging'),
+  )
+  const tracer = getTracer()
+
+  const handlerResponse = await runWithRequestContext(requestContext, () => {
+    return tracer.withActiveSpan('Next.js Server Handler', async (span) => {
       span.setAttributes({
         'account.id': context.account.id,
         'deploy.id': context.deploy.id,
@@ -31,16 +39,14 @@ export default async function (req, context) {
         'http.status_code': response.status,
       })
       return response
-    } catch (error) {
-      span.recordException(error)
-      if (error instanceof Error) {
-        span.addEvent({ name: error.name, message: error.message })
-      }
-      throw error
-    } finally {
-      span.end()
-    }
+    })
   })
+
+  if (requestContext.serverTiming) {
+    handlerResponse.headers.set('server-timing', requestContext.serverTiming)
+  }
+
+  return handlerResponse
 }
 
 export const config = {

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

@@ -1,15 +1,22 @@
+import {
+  createRequestContext,
+  runWithRequestContext,
+} from './.netlify/dist/run/handlers/request-context.cjs'
 import serverHandler from './.netlify/dist/run/handlers/server.js'
-import tracing, { trace } from './.netlify/dist/run/handlers/tracing.js'
+import { getTracer } from './.netlify/dist/run/handlers/tracer.cjs'
+import tracing from './.netlify/dist/run/handlers/tracing.js'
 
 export default async function handler(req, context) {
   if (process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL) {
     tracing.start()
   }
+  const requestContext = createRequestContext(
+    req.headers.get('x-nf-debug-logging') || req.headers.get('x-next-debug-logging'),
+  )
+  const tracer = getTracer()
 
-  /** @type {import('@opentelemetry/api').Tracer} */
-  const tracer = trace.getTracer('Next.js Runtime')
-  return tracer.startActiveSpan('Next.js Server Handler', async (span) => {
-    try {
+  const handlerResponse = await runWithRequestContext(requestContext, () => {
+    return tracer.withActiveSpan('Next.js Server Handler', async (span) => {
       span.setAttributes({
         'account.id': context.account.id,
         'deploy.id': context.deploy.id,
@@ -25,16 +32,14 @@ export default async function handler(req, context) {
         'http.status_code': response.status,
       })
       return response
-    } catch (error) {
-      span.recordException(error)
-      if (error instanceof Error) {
-        span.addEvent({ name: error.name, message: error.message })
-      }
-      throw error
-    } finally {
-      span.end()
-    }
+    })
   })
+
+  if (requestContext.serverTiming) {
+    handlerResponse.headers.set('server-timing', requestContext.serverTiming)
+  }
+
+  return handlerResponse
 }
 
 export const config = {

package/dist/esm-chunks/chunk-4635LKT6.js

@@ -0,0 +1,244 @@
+
+      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/prerendered.ts
+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 {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+
+// node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// 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({
+    lastModified,
+    value
+  });
+  await writeFile(path, entry, "utf-8");
+};
+var routeToFilePath = (path) => path === "/" ? "/index" : path;
+var buildPagesCacheValue = async (path) => ({
+  kind: "PAGE",
+  html: await readFile(`${path}.html`, "utf-8"),
+  pageData: JSON.parse(await readFile(`${path}.json`, "utf-8")),
+  postponed: void 0,
+  headers: void 0,
+  status: void 0
+});
+var buildAppCacheValue = async (path) => {
+  const meta = JSON.parse(await readFile(`${path}.meta`, "utf-8"));
+  const rsc = await readFile(`${path}.rsc`, "utf-8").catch(
+    () => readFile(`${path}.prefetch.rsc`, "utf-8")
+  );
+  if (!meta.status && rsc.includes("NEXT_NOT_FOUND")) {
+    meta.status = 404;
+  }
+  return {
+    kind: "PAGE",
+    html: await readFile(`${path}.html`, "utf-8"),
+    pageData: rsc,
+    ...meta
+  };
+};
+var buildRouteCacheValue = async (path) => ({
+  kind: "ROUTE",
+  body: await readFile(`${path}.body`, "base64"),
+  ...JSON.parse(await readFile(`${path}.meta`, "utf-8"))
+});
+var buildFetchCacheValue = async (path) => ({
+  kind: "FETCH",
+  ...JSON.parse(await readFile(path, "utf-8"))
+});
+var copyPrerenderedContent = async (ctx) => {
+  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;
+              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);
+    }
+  });
+};
+var copyFetchContent = async (ctx) => {
+  try {
+    const paths = await (0, import_fast_glob.glob)(["!(*.*)"], {
+      cwd: join(ctx.publishDir, "cache/fetch-cache"),
+      extglob: true
+    });
+    await Promise.all(
+      paths.map(async (key) => {
+        const lastModified = Date.now() - 31536e6;
+        const path = join(ctx.publishDir, "cache/fetch-cache", key);
+        const value = await buildFetchCacheValue(path);
+        await writeCacheEntry(key, value, lastModified, ctx);
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling fetch content for upload", error);
+  }
+};
+
+export {
+  copyPrerenderedContent,
+  copyFetchContent
+};

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 {