@netlify/plugin-nextjs 5.15.1 → 5.15.2

package/dist/build/content/server.js

@@ -31,13 +31,13 @@ import {
   writeFile
 } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { dirname, join, resolve, sep } from "node:path";
-import { join as posixJoin, sep as posixSep } from "node:path/posix";
+import { dirname, join, sep } from "node:path";
+import { join as posixJoin, relative as posixRelative, sep as posixSep } from "node:path/posix";
 var import_fast_glob = __toESM(require_out(), 1);
 var import_semver = __toESM(require_semver(), 1);
 import { RUN_CONFIG_FILE } from "../../run/constants.js";
 var tracer = wrapTracer(trace.getTracer("Next runtime"));
-var toPosixPath = (path) => path.split(sep).join(posixSep);
+var toPosixPath = (path) => path.replace(/^\\+\?\\+/, "").split(sep).join(posixSep);
 function isError(error) {
   return error instanceof Error;
 }
@@ -98,29 +98,39 @@ var copyNextServerCode = async (ctx) => {
         extglob: true
       }
     );
-    await Promise.all(
-      paths.map(async (path) => {
-        const srcPath = join(srcDir, path);
-        const destPath = join(destDir, path);
-        if (path === "server/middleware-manifest.json") {
-          try {
-            await replaceMiddlewareManifest(srcPath, destPath);
-          } catch (error) {
-            throw new Error("Could not patch middleware manifest file", { cause: error });
-          }
-          return;
+    const promises = paths.map(async (path) => {
+      const srcPath = join(srcDir, path);
+      const destPath = join(destDir, path);
+      if (path === "server/middleware-manifest.json") {
+        try {
+          await replaceMiddlewareManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch middleware manifest file", { cause: error });
         }
-        if (path === "server/functions-config-manifest.json") {
-          try {
-            await replaceFunctionsConfigManifest(srcPath, destPath);
-          } catch (error) {
-            throw new Error("Could not patch functions config manifest file", { cause: error });
-          }
-          return;
+        return;
+      }
+      if (path === "server/functions-config-manifest.json") {
+        try {
+          await replaceFunctionsConfigManifest(srcPath, destPath);
+        } catch (error) {
+          throw new Error("Could not patch functions config manifest file", { cause: error });
         }
-        await cp(srcPath, destPath, { recursive: true, force: true });
-      })
-    );
+        return;
+      }
+      await cp(srcPath, destPath, { recursive: true, force: true });
+    });
+    if (existsSync(join(srcDir, "node_modules"))) {
+      const filter = ctx.constants.IS_LOCAL ? void 0 : nodeModulesFilter;
+      const src = join(srcDir, "node_modules");
+      const dest = join(destDir, "node_modules");
+      await cp(src, dest, {
+        recursive: true,
+        verbatimSymlinks: true,
+        force: true,
+        filter
+      });
+    }
+    await Promise.all(promises);
   });
 };
 async function recreateNodeModuleSymlinks(src, dest, org) {
@@ -188,32 +198,37 @@ async function patchNextModules(ctx, nextVersion, serverHandlerRequireResolve) {
 }
 var copyNextDependencies = async (ctx) => {
   await tracer.withActiveSpan("copyNextDependencies", async () => {
-    const entries = await readdir(ctx.standaloneDir);
-    const filter = ctx.constants.IS_LOCAL ? void 0 : nodeModulesFilter;
-    const promises = entries.map(async (entry) => {
-      if (entry === ctx.nextDistDir) {
-        return;
-      }
-      const src = join(ctx.standaloneDir, entry);
-      const dest = join(ctx.serverHandlerDir, entry);
-      await cp(src, dest, {
-        recursive: true,
-        verbatimSymlinks: true,
-        force: true,
-        filter
-      });
-      if (entry === "node_modules") {
-        await recreateNodeModuleSymlinks(ctx.resolveFromSiteDir("node_modules"), dest);
+    const promises = [];
+    const nodeModulesLocations = /* @__PURE__ */ new Set();
+    const commonFilter = ctx.constants.IS_LOCAL ? void 0 : nodeModulesFilter;
+    const dotNextDir = toPosixPath(join(ctx.standaloneDir, ctx.nextDistDir));
+    const standaloneRootDir = toPosixPath(ctx.standaloneRootDir);
+    const outputFileTracingRoot = toPosixPath(ctx.outputFileTracingRoot);
+    await cp(ctx.standaloneRootDir, ctx.serverHandlerRootDir, {
+      recursive: true,
+      verbatimSymlinks: true,
+      force: true,
+      filter: async (sourcePath, destination) => {
+        const posixSourcePath = toPosixPath(sourcePath);
+        if (posixSourcePath === dotNextDir) {
+          return false;
+        }
+        if (sourcePath.endsWith("node_modules")) {
+          nodeModulesLocations.add({
+            source: posixSourcePath,
+            destination: toPosixPath(destination)
+          });
+        }
+        return commonFilter?.(sourcePath) ?? true;
       }
     });
-    const rootSrcDir = join(ctx.standaloneRootDir, "node_modules");
-    const rootDestDir = join(ctx.serverHandlerRootDir, "node_modules");
-    if (existsSync(rootSrcDir) && ctx.standaloneRootDir !== ctx.standaloneDir) {
-      promises.push(
-        cp(rootSrcDir, rootDestDir, { recursive: true, verbatimSymlinks: true, filter }).then(
-          () => recreateNodeModuleSymlinks(resolve("node_modules"), rootDestDir)
-        )
-      );
+    for (const {
+      source: nodeModulesLocationInStandalone,
+      destination: locationInServerHandler
+    } of nodeModulesLocations) {
+      const relativeToRoot = posixRelative(standaloneRootDir, nodeModulesLocationInStandalone);
+      const locationInProject = posixJoin(outputFileTracingRoot, relativeToRoot);
+      promises.push(recreateNodeModuleSymlinks(locationInProject, locationInServerHandler));
     }
     await Promise.all(promises);
     const serverHandlerRequire = createRequire(posixJoin(ctx.serverHandlerDir, ":internal:"));
@@ -301,7 +316,7 @@ var verifyHandlerDirStructure = async (ctx) => {
     );
   }
 };
-var nodeModulesFilter = async (sourcePath) => {
+var nodeModulesFilter = (sourcePath) => {
   if (sourcePath.includes(".pnpm") && (sourcePath.includes("linuxmusl-x64") || sourcePath.includes("linux-x64-musl"))) {
     return false;
   }

package/dist/build/plugin-context.js

@@ -16,7 +16,7 @@ var import_semver = __toESM(require_semver(), 1);
 import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { join, relative, resolve } from "node:path";
+import { join, relative, resolve, sep } from "node:path";
 import { join as posixJoin, relative as posixRelative } from "node:path/posix";
 import { fileURLToPath } from "node:url";
 var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
@@ -54,6 +54,25 @@ var PluginContext = class {
   get relativeAppDir() {
     return this.requiredServerFiles.relativeAppDir ?? "";
   }
+  /**
+   * The root directory for output file tracing. Paths inside standalone directory preserve paths of project, relative to this directory.
+   */
+  get outputFileTracingRoot() {
+    const outputFileTracingRootFromRequiredServerFiles = this.requiredServerFiles.config.outputFileTracingRoot ?? // fallback for older Next.js versions that don't have outputFileTracingRoot in the config, but had it in config.experimental
+    this.requiredServerFiles.config.experimental.outputFileTracingRoot;
+    if (outputFileTracingRootFromRequiredServerFiles) {
+      return outputFileTracingRootFromRequiredServerFiles;
+    }
+    if (!this.relativeAppDir.includes("..")) {
+      const depth = this.relativeAppDir === "" ? 0 : this.relativeAppDir.split(sep).length;
+      const computedOutputFileTracingRoot = resolve(
+        this.requiredServerFiles.appDir,
+        ...Array.from({ length: depth }).fill("..")
+      );
+      return computedOutputFileTracingRoot;
+    }
+    return process.cwd();
+  }
   /**
    * The working directory inside the lambda that is used for monorepos to execute the serverless function
    */

package/dist/run/handlers/tags-handler.cjs

@@ -86,7 +86,7 @@ var pipeline = (0, import_util.promisify)(import_stream.pipeline);
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.15.1";
+var version = "5.15.2";
 
 // src/run/handlers/tags-handler.cts
 var import_storage = require("../storage/storage.cjs");

package/dist/run/storage/regional-blob-store.cjs

@@ -30,7 +30,23 @@ var getString = (input) => typeof input === "string" ? input : JSON.stringify(in
 var base64Decode = globalThis.Buffer ? (input) => Buffer.from(input, "base64").toString() : (input) => atob(input);
 var base64Encode = globalThis.Buffer ? (input) => Buffer.from(getString(input)).toString("base64") : (input) => btoa(getString(input));
 
-// node_modules/@netlify/blobs/dist/chunk-HN33TXZT.js
+// node_modules/@netlify/otel/dist/main.js
+var GET_TRACER = "__netlify__getTracer";
+var getTracer = (name, version) => {
+  return globalThis[GET_TRACER]?.(name, version);
+};
+function withActiveSpan(tracer, name, optionsOrFn, contextOrFn, fn) {
+  const func = typeof contextOrFn === "function" ? contextOrFn : typeof optionsOrFn === "function" ? optionsOrFn : fn;
+  if (!func) {
+    throw new Error("function to execute with active span is missing");
+  }
+  if (!tracer) {
+    return func();
+  }
+  return tracer.withActiveSpan(name, optionsOrFn, contextOrFn, func);
+}
+
+// node_modules/@netlify/blobs/dist/chunk-3OMJJ4EG.js
 var getEnvironment = () => {
   const { Deno, Netlify, process: process2 } = globalThis;
   return Netlify?.env ?? Deno?.env ?? {
@@ -123,6 +139,12 @@ var collectIterator = async (iterator) => {
   }
   return result;
 };
+function withSpan(span, name, fn) {
+  if (span) return fn(span);
+  return withActiveSpan(getTracer(), name, (span2) => {
+    return fn(span2);
+  });
+}
 var BlobsConsistencyError = class extends Error {
   constructor() {
     super(
@@ -337,22 +359,6 @@ var getClientOptions = (options, contextOverride) => {
   return clientOptions;
 };
 
-// node_modules/@netlify/otel/dist/main.js
-var GET_TRACER = "__netlify__getTracer";
-var getTracer = (name, version) => {
-  return globalThis[GET_TRACER]?.(name, version);
-};
-function withActiveSpan(tracer, name, optionsOrFn, contextOrFn, fn) {
-  const func = typeof contextOrFn === "function" ? contextOrFn : typeof optionsOrFn === "function" ? optionsOrFn : fn;
-  if (!func) {
-    throw new Error("function to execute with active span is missing");
-  }
-  if (!tracer) {
-    return func();
-  }
-  return tracer.withActiveSpan(name, optionsOrFn, contextOrFn, func);
-}
-
 // node_modules/@netlify/blobs/dist/main.js
 var DEPLOY_STORE_PREFIX = "deploy:";
 var LEGACY_STORE_INTERNAL_PREFIX = "netlify-internal/legacy-namespace/";
@@ -404,7 +410,7 @@ var Store = class _Store {
     };
   }
   async get(key, options) {
-    return withActiveSpan(getTracer(), "blobs.get", async (span) => {
+    return withSpan(options?.span, "blobs.get", async (span) => {
       const { consistency, type } = options ?? {};
       span?.setAttributes({
         "blobs.store": this.name,
@@ -447,15 +453,20 @@ var Store = class _Store {
       throw new BlobsInternalError(res);
     });
   }
-  async getMetadata(key, { consistency } = {}) {
-    return withActiveSpan(getTracer(), "blobs.getMetadata", async (span) => {
+  async getMetadata(key, options = {}) {
+    return withSpan(options?.span, "blobs.getMetadata", async (span) => {
       span?.setAttributes({
         "blobs.store": this.name,
         "blobs.key": key,
         "blobs.method": "HEAD",
-        "blobs.consistency": consistency
+        "blobs.consistency": options.consistency
+      });
+      const res = await this.client.makeRequest({
+        consistency: options.consistency,
+        key,
+        method: "head",
+        storeName: this.name
       });
-      const res = await this.client.makeRequest({ consistency, key, method: "head", storeName: this.name });
       span?.setAttributes({
         "blobs.response.status": res.status
       });
@@ -475,7 +486,7 @@ var Store = class _Store {
     });
   }
   async getWithMetadata(key, options) {
-    return withActiveSpan(getTracer(), "blobs.getWithMetadata", async (span) => {
+    return withSpan(options?.span, "blobs.getWithMetadata", async (span) => {
       const { consistency, etag: requestETag, type } = options ?? {};
       const headers = requestETag ? { "if-none-match": requestETag } : void 0;
       span?.setAttributes({
@@ -532,7 +543,7 @@ var Store = class _Store {
     });
   }
   list(options = {}) {
-    return withActiveSpan(getTracer(), "blobs.list", (span) => {
+    return withSpan(options.span, "blobs.list", (span) => {
       span?.setAttributes({
         "blobs.store": this.name,
         "blobs.method": "GET",
@@ -554,7 +565,7 @@ var Store = class _Store {
     });
   }
   async set(key, data, options = {}) {
-    return withActiveSpan(getTracer(), "blobs.set", async (span) => {
+    return withSpan(options.span, "blobs.set", async (span) => {
       span?.setAttributes({
         "blobs.store": this.name,
         "blobs.key": key,
@@ -591,7 +602,7 @@ var Store = class _Store {
     });
   }
   async setJSON(key, data, options = {}) {
-    return withActiveSpan(getTracer(), "blobs.setJSON", async (span) => {
+    return withSpan(options.span, "blobs.setJSON", async (span) => {
       span?.setAttributes({
         "blobs.store": this.name,
         "blobs.key": key,
@@ -707,7 +718,7 @@ var Store = class _Store {
         let done = false;
         return {
           async next() {
-            return withActiveSpan(getTracer(), "blobs.list.next", async (span) => {
+            return withSpan(options?.span, "blobs.list.next", async (span) => {
               span?.setAttributes({
                 "blobs.store": storeName,
                 "blobs.method": "GET",

package/dist/run/storage/storage.cjs

@@ -57,10 +57,11 @@ var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
       const blobKey = await encodeBlobKey(key);
       const getPromise = (0, import_tracer.withActiveSpan)(tracer, otelSpanTitle, async (span) => {
         const { etag: previousEtag, globalValue: previousBlob } = memoizedValue?.conditional ? memoizedValue : {};
-        span?.setAttributes({ key, blobKey, previousEtag });
+        span?.setAttributes({ key });
         const result = await store.getWithMetadata(blobKey, {
           type: "json",
-          etag: previousEtag
+          etag: previousEtag,
+          span
         });
         const shouldReuseMemoizedBlob = result?.etag && previousEtag === result?.etag;
         const blob = shouldReuseMemoizedBlob ? previousBlob : result?.data;
@@ -72,11 +73,6 @@ var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
         } else {
           inMemoryCache.set(key, blob);
         }
-        span?.setAttributes({
-          etag: result?.etag,
-          reusingPreviouslyFetchedBlob: shouldReuseMemoizedBlob,
-          status: blob ? shouldReuseMemoizedBlob ? "Hit, no change" : "Hit" : "Miss"
-        });
         return blob;
       });
       inMemoryCache.set(key, getPromise);
@@ -87,8 +83,8 @@ var getMemoizedKeyValueStoreBackedByRegionalBlobStore = (...args) => {
       inMemoryCache.set(key, value);
       const blobKey = await encodeBlobKey(key);
       return (0, import_tracer.withActiveSpan)(tracer, otelSpanTitle, async (span) => {
-        span?.setAttributes({ key, blobKey });
-        const writeResult = await store.setJSON(blobKey, value);
+        span?.setAttributes({ key });
+        const writeResult = await store.setJSON(blobKey, value, { span });
         if (writeResult?.etag) {
           inMemoryCache.set(key, {
             data: value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.15.1",
+  "version": "5.15.2",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",