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

package/dist/build/content/prerendered.js

@@ -7,7 +7,7 @@
 import {
   copyFetchContent,
   copyPrerenderedContent
-} from "../../esm-chunks/chunk-VSH4JS2L.js";
+} from "../../esm-chunks/chunk-75UGFPYW.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import "../../esm-chunks/chunk-5JVNISGM.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-75UGFPYW.js

@@ -0,0 +1,233 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-VZNKO4OO.js";
+import {
+  encodeBlobKey
+} from "./chunk-TYCYFZ22.js";
+import {
+  __toESM
+} from "./chunk-5JVNISGM.js";
+
+// src/build/content/prerendered.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// 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 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) => {
+  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-637Y3P2U.js → chunk-M2ZKGJAI.js}

@@ -617,7 +617,7 @@ var adjustDateHeader = async ({
     });
     const blobKey = await encodeBlobKey(key);
     const blobStore = getDeployStore({ fetch: fetchBeforeNextPatchedIt, consistency: "strong" });
-    lastModified = await tracer.startActiveSpan(
+    lastModified = await tracer.withActiveSpan(
       "get cache to calculate date header",
       async (getBlobForDateSpan) => {
         getBlobForDateSpan.setAttributes({
@@ -626,7 +626,6 @@ var adjustDateHeader = async ({
         });
         const blob = await blobStore.get(blobKey, { type: "json" }) ?? {};
         getBlobForDateSpan.addEvent(blob ? "Cache hit" : "Cache miss");
-        getBlobForDateSpan.end();
         return blob.lastModified;
       }
     );

package/dist/esm-chunks/{package-67C5TREY.js → package-ZWSB2JUJ.js}

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.0.0-rc.5";
+var version = "5.0.0-rc.6";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";

package/dist/index.js

@@ -6,7 +6,7 @@
     
 import {
   copyPrerenderedContent
-} from "./esm-chunks/chunk-VSH4JS2L.js";
+} from "./esm-chunks/chunk-75UGFPYW.js";
 import {
   copyStaticAssets,
   copyStaticContent,