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

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

@@ -0,0 +1,278 @@
+
+      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 {
+  verifyNextVersion
+} from "./chunk-MGPEWDDD.js";
+import {
+  require_semver
+} from "./chunk-PJG75HGC.js";
+import {
+  RUN_CONFIG
+} from "./chunk-UYKENJEU.js";
+import {
+  __toESM
+} from "./chunk-5JVNISGM.js";
+
+// src/build/content/server.ts
+init_esm();
+import { existsSync } from "node:fs";
+import {
+  cp,
+  mkdir,
+  readFile,
+  readdir,
+  readlink,
+  symlink,
+  writeFile,
+  access
+} from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, resolve, sep } from "node:path";
+import { sep as posixSep, join as posixJoin } from "node:path/posix";
+var import_fast_glob = __toESM(require_out(), 1);
+var import_semver = __toESM(require_semver(), 1);
+var tracer = wrapTracer(trace.getTracer("Next runtime"));
+var toPosixPath = (path) => path.split(sep).join(posixSep);
+function isError(error) {
+  return error instanceof Error;
+}
+var copyNextServerCode = async (ctx) => {
+  await tracer.withActiveSpan("copyNextServerCode", async () => {
+    const reqServerFilesPath = join(
+      ctx.standaloneRootDir,
+      ctx.relativeAppDir,
+      ctx.requiredServerFiles.config.distDir,
+      "required-server-files.json"
+    );
+    try {
+      await access(reqServerFilesPath);
+    } catch (error) {
+      if (isError(error) && error.code === "ENOENT") {
+        ctx.failBuild(
+          `Failed creating server handler. required-server-files.json file not found at expected location "${reqServerFilesPath}". Your repository setup is currently not yet supported.`
+        );
+      } else {
+        throw error;
+      }
+    }
+    const reqServerFiles = JSON.parse(await readFile(reqServerFilesPath, "utf-8"));
+    if (toPosixPath(ctx.distDir).replace(new RegExp(`^${ctx.relativeAppDir}/?`), "") !== reqServerFiles.config.distDir) {
+      reqServerFiles.config.distDir = ctx.nextDistDir;
+      await writeFile(reqServerFilesPath, JSON.stringify(reqServerFiles));
+    }
+    await mkdir(ctx.serverHandlerDir, { recursive: true });
+    await writeFile(
+      join(ctx.serverHandlerDir, RUN_CONFIG),
+      JSON.stringify(reqServerFiles.config),
+      "utf-8"
+    );
+    const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
+    const nextFolder = toPosixPath(ctx.distDir) === toPosixPath(ctx.buildConfig.distDir) ? ctx.distDir : ctx.nextDistDir;
+    const destDir = join(ctx.serverHandlerDir, nextFolder);
+    const paths = await (0, import_fast_glob.default)(
+      [`*`, `server/*`, `server/chunks/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
+      {
+        cwd: srcDir,
+        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;
+        }
+        await cp(srcPath, destPath, { recursive: true, force: true });
+      })
+    );
+  });
+};
+async function recreateNodeModuleSymlinks(src, dest, org) {
+  const dirents = await readdir(join(src, org || ""), { withFileTypes: true });
+  await Promise.all(
+    dirents.map(async (dirent) => {
+      if (dirent.name.startsWith("@")) {
+        return recreateNodeModuleSymlinks(src, dest, dirent.name);
+      }
+      if (dirent.isSymbolicLink()) {
+        const symlinkSrc = join(dest, org || "", dirent.name);
+        const symlinkTarget = await readlink(join(src, org || "", dirent.name));
+        const symlinkDest = join(dest, org || "", symlinkTarget);
+        if (existsSync(symlinkDest) && !existsSync(symlinkSrc)) {
+          if (org) {
+            await mkdir(join(dest, org), { recursive: true });
+          }
+          await symlink(symlinkTarget, symlinkSrc);
+        }
+      }
+    })
+  );
+}
+var nextInternalModuleReplacements = [
+  {
+    // standalone is loading expensive Telemetry module that is not actually used
+    // so this replace that module with lightweight no-op shim that doesn't load additional modules
+    // see https://github.com/vercel/next.js/pull/63574 that removed need for this shim
+    ongoing: false,
+    minVersion: "13.5.0-canary.0",
+    // perf released in https://github.com/vercel/next.js/releases/tag/v14.2.0-canary.43
+    maxVersion: "14.2.0-canary.42",
+    nextModule: "next/dist/telemetry/storage.js",
+    shimModule: "./next-shims/telemetry-storage.cjs"
+  }
+];
+function getPatchesToApply(nextVersion, patches = nextInternalModuleReplacements) {
+  return patches.filter((patch) => {
+    if ((0, import_semver.lt)(nextVersion, patch.minVersion)) {
+      return false;
+    }
+    if (patch.ongoing) {
+      if ((0, import_semver.prerelease)(nextVersion) || process.env.NETLIFY_NEXT_FORCE_APPLY_ONGOING_PATCHES) {
+        return true;
+      }
+      return (0, import_semver.lte)(nextVersion, patch.maxStableVersion);
+    }
+    return (0, import_semver.lte)(nextVersion, patch.maxVersion);
+  });
+}
+async function patchNextModules(ctx, nextVersion, serverHandlerRequireResolve) {
+  const moduleReplacementsToApply = getPatchesToApply(nextVersion);
+  if (moduleReplacementsToApply.length !== 0) {
+    await Promise.all(
+      moduleReplacementsToApply.map(async ({ nextModule, shimModule }) => {
+        try {
+          const nextModulePath = serverHandlerRequireResolve(nextModule);
+          const shimModulePath = posixJoin(ctx.pluginDir, "dist", "build", "content", shimModule);
+          await cp(shimModulePath, nextModulePath, { force: true });
+        } catch {
+        }
+      })
+    );
+  }
+}
+var copyNextDependencies = async (ctx) => {
+  await tracer.withActiveSpan("copyNextDependencies", async () => {
+    const entries = await readdir(ctx.standaloneDir);
+    const promises = entries.map(async (entry) => {
+      if (entry === "package.json" || 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 });
+      if (entry === "node_modules") {
+        await recreateNodeModuleSymlinks(ctx.resolveFromSiteDir("node_modules"), dest);
+      }
+    });
+    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 }).then(
+          () => recreateNodeModuleSymlinks(resolve("node_modules"), rootDestDir)
+        )
+      );
+    }
+    await Promise.all(promises);
+    const serverHandlerRequire = createRequire(posixJoin(ctx.serverHandlerDir, ":internal:"));
+    let nextVersion;
+    try {
+      const { version } = serverHandlerRequire("next/package.json");
+      if (version) {
+        nextVersion = version;
+      }
+    } catch {
+    }
+    if (nextVersion) {
+      verifyNextVersion(ctx, nextVersion);
+      await patchNextModules(ctx, nextVersion, serverHandlerRequire.resolve);
+    }
+    try {
+      const nextEntryAbsolutePath = serverHandlerRequire.resolve("next");
+      const nextRequire = createRequire(nextEntryAbsolutePath);
+      nextRequire.resolve("styled-jsx");
+    } catch {
+      throw new Error(
+        "node_modules are not installed correctly, if you are using pnpm please set the public hoist pattern to: `public-hoist-pattern[]=*`.\nRefer to your docs for more details: https://docs.netlify.com/integrations/frameworks/next-js/overview/#pnpm-support"
+      );
+    }
+  });
+};
+var writeTagsManifest = async (ctx) => {
+  const manifest = await ctx.getPrerenderManifest();
+  const routes = Object.entries(manifest.routes).map(async ([route, definition]) => {
+    let tags;
+    if (definition.dataRoute?.endsWith(".rsc")) {
+      const path = join(ctx.publishDir, `server/app/${route === "/" ? "/index" : route}.meta`);
+      try {
+        const file = await readFile(path, "utf-8");
+        const meta = JSON.parse(file);
+        tags = meta.headers["x-next-cache-tags"];
+      } catch {
+        if (!definition.dataRoute?.endsWith("/default.rsc")) {
+          console.log(`Unable to read cache tags for: ${path}`);
+        }
+      }
+    }
+    if (definition.dataRoute?.endsWith(".json")) {
+      tags = `_N_T_${route}`;
+    }
+    if (definition.dataRoute === null) {
+      tags = definition.initialHeaders?.["x-next-cache-tags"];
+    }
+    return [route, tags];
+  });
+  await writeFile(
+    join(ctx.serverHandlerDir, ".netlify/tags-manifest.json"),
+    JSON.stringify(Object.fromEntries(await Promise.all(routes))),
+    "utf-8"
+  );
+};
+var replaceMiddlewareManifest = async (sourcePath, destPath) => {
+  await mkdir(dirname(destPath), { recursive: true });
+  const data = await readFile(sourcePath, "utf8");
+  const manifest = JSON.parse(data);
+  const newManifest = {
+    ...manifest,
+    middleware: {}
+  };
+  const newData = JSON.stringify(newManifest);
+  await writeFile(destPath, newData);
+};
+var verifyHandlerDirStructure = async (ctx) => {
+  const runConfig = JSON.parse(await readFile(join(ctx.serverHandlerDir, RUN_CONFIG), "utf-8"));
+  const expectedBuildIDPath = join(ctx.serverHandlerDir, runConfig.distDir, "BUILD_ID");
+  if (!existsSync(expectedBuildIDPath)) {
+    ctx.failBuild(
+      `Failed creating server handler. BUILD_ID file not found at expected location "${expectedBuildIDPath}".`
+    );
+  }
+};
+
+export {
+  copyNextServerCode,
+  getPatchesToApply,
+  copyNextDependencies,
+  writeTagsManifest,
+  verifyHandlerDirStructure
+};

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

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.0.0-rc.6";
+var version = "5.0.0-rc.8";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -23,7 +23,7 @@ var engines = {
 var scripts = {
   prepack: "clean-package",
   postpack: "clean-package restore",
-  pretest: "node tests/prepare.mjs",
+  pretest: "npm run build && node tests/prepare.mjs",
   build: "node ./tools/build.js",
   "build:watch": "node ./tools/build.js --watch",
   lint: "eslint --cache --format=codeframe --max-warnings=0 --ext .ts,.cts,.js src",
@@ -53,14 +53,14 @@ 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.36.4",
+  "@netlify/build": "^29.37.2",
   "@netlify/edge-bundler": "^11.3.0",
   "@netlify/edge-functions": "^2.3.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",
-  "@opentelemetry/api": "^1.7.0",
+  "@opentelemetry/api": "^1.8.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.49.0",
   "@opentelemetry/resources": "^1.21.0",
   "@opentelemetry/sdk-node": "^0.49.0",

package/dist/index.js

@@ -6,21 +6,28 @@
     
 import {
   copyPrerenderedContent
-} from "./esm-chunks/chunk-75UGFPYW.js";
+} from "./esm-chunks/chunk-4635LKT6.js";
 import {
   copyStaticAssets,
   copyStaticContent,
   copyStaticExport,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-WFVNEURA.js";
+} from "./esm-chunks/chunk-GV3YIJ33.js";
 import {
   createEdgeHandlers
 } from "./esm-chunks/chunk-OBKVBMAL.js";
 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 {
+  wrapTracer
+} from "./esm-chunks/chunk-PDPDW32D.js";
+import {
+  init_esm,
+  trace
+} from "./esm-chunks/chunk-Y3K5Q6FP.js";
 import "./esm-chunks/chunk-VZNKO4OO.js";
 import {
   restoreBuildCache,
@@ -28,7 +35,7 @@ import {
 } from "./esm-chunks/chunk-72ZI2IVI.js";
 import {
   setImageConfig
-} from "./esm-chunks/chunk-FMO6SJ5E.js";
+} from "./esm-chunks/chunk-MCEOSJH6.js";
 import {
   PluginContext
 } from "./esm-chunks/chunk-3NYX5FXN.js";
@@ -42,43 +49,56 @@ import "./esm-chunks/chunk-TYCYFZ22.js";
 import "./esm-chunks/chunk-5JVNISGM.js";
 
 // src/index.ts
+init_esm();
+var tracer = wrapTracer(trace.getTracer("Next.js runtime"));
 var onPreBuild = async (options) => {
-  process.env.NEXT_PRIVATE_STANDALONE = "true";
-  if (!options.constants.IS_LOCAL) {
-    await restoreBuildCache(new PluginContext(options));
-  }
+  await tracer.withActiveSpan("onPreBuild", async () => {
+    process.env.NEXT_PRIVATE_STANDALONE = "true";
+    if (!options.constants.IS_LOCAL) {
+      await restoreBuildCache(new PluginContext(options));
+    }
+  });
 };
 var onBuild = async (options) => {
-  const ctx = new PluginContext(options);
-  verifyPublishDir(ctx);
-  verifyBuildConfig(ctx);
-  if (!options.constants.IS_LOCAL) {
-    await saveBuildCache(ctx);
-  }
-  if (ctx.buildConfig.output === "export") {
-    return copyStaticExport(ctx);
-  }
-  await Promise.all([
-    copyStaticAssets(ctx),
-    copyStaticContent(ctx),
-    copyPrerenderedContent(ctx),
-    createServerHandler(ctx),
-    createEdgeHandlers(ctx),
-    setImageConfig(ctx)
-  ]);
+  await tracer.withActiveSpan("onBuild", async (span) => {
+    const ctx = new PluginContext(options);
+    verifyPublishDir(ctx);
+    verifyBuildConfig(ctx);
+    span.setAttribute("next.buildConfig", JSON.stringify(ctx.buildConfig));
+    if (!options.constants.IS_LOCAL) {
+      await saveBuildCache(ctx);
+    }
+    if (ctx.buildConfig.output === "export") {
+      return copyStaticExport(ctx);
+    }
+    await Promise.all([
+      copyStaticAssets(ctx),
+      copyStaticContent(ctx),
+      copyPrerenderedContent(ctx),
+      createServerHandler(ctx),
+      createEdgeHandlers(ctx),
+      setImageConfig(ctx)
+    ]);
+  });
 };
 var onPostBuild = async (options) => {
-  await publishStaticDir(new PluginContext(options));
+  await tracer.withActiveSpan("onPostBuild", async () => {
+    await publishStaticDir(new PluginContext(options));
+  });
 };
 var onSuccess = async () => {
-  const prewarm = [process.env.DEPLOY_URL, process.env.DEPLOY_PRIME_URL, process.env.URL].filter(
-    // If running locally then the deploy ID is a placeholder value. Filtering for `https://0--` removes it.
-    (url) => Boolean(url && !url.startsWith("https://0--"))
-  );
-  await Promise.allSettled(prewarm.map((url) => fetch(url)));
+  await tracer.withActiveSpan("onSuccess", async () => {
+    const prewarm = [process.env.DEPLOY_URL, process.env.DEPLOY_PRIME_URL, process.env.URL].filter(
+      // If running locally then the deploy ID is a placeholder value. Filtering for `https://0--` removes it.
+      (url) => Boolean(url && !url.startsWith("https://0--"))
+    );
+    await Promise.allSettled(prewarm.map((url) => fetch(url)));
+  });
 };
 var onEnd = async (options) => {
-  await unpublishStaticDir(new PluginContext(options));
+  await tracer.withActiveSpan("onEnd", async () => {
+    await unpublishStaticDir(new PluginContext(options));
+  });
 };
 export {
   onBuild,

package/dist/run/handlers/cache.cjs

@@ -925,12 +925,17 @@ var NetlifyCacheHandler = class {
       const lastModified = Date.now();
       span.setAttributes({ key, lastModified, blobKey });
       console.debug(`[NetlifyCacheHandler.set]: ${key}`);
+      let value = data;
       if (data?.kind === "ROUTE") {
-        data.body = data.body.toString("base64");
+        value = {
+          ...data,
+          // @ts-expect-error gotta find a better solution for this
+          body: data.body.toString("base64")
+        };
       }
       await this.blobStore.setJSON(blobKey, {
         lastModified,
-        value: data
+        value
       });
       if (data?.kind === "PAGE") {
         const requestContext = (0, import_request_context.getRequestContext)();

package/dist/run/handlers/server.js

@@ -3259,6 +3259,7 @@ function toComputeResponse(res) {
 // src/run/handlers/server.ts
 import { createRequestContext, getRequestContext } from "./request-context.cjs";
 import { getTracer } from "./tracer.cjs";
+var nextImportPromise = import("../next.cjs");
 var nextHandler;
 var nextConfig;
 var tagsManifest;
@@ -3292,7 +3293,7 @@ var server_default = async (request) => {
           {}
         )
       );
-      const { getMockedRequestHandlers } = await import("../next.cjs");
+      const { getMockedRequestHandlers } = await nextImportPromise;
       const url = new URL(request.url);
       [nextHandler] = await getMockedRequestHandlers({
         port: Number(url.port) || 443,
@@ -3304,6 +3305,16 @@ var server_default = async (request) => {
   }
   return await tracer.withActiveSpan("generate response", async (span) => {
     const { req, res } = toReqRes(request);
+    Object.defineProperty(req, "connection", {
+      get() {
+        return {};
+      }
+    });
+    Object.defineProperty(req, "socket", {
+      get() {
+        return {};
+      }
+    });
     disableFaultyTransferEncodingHandling(res);
     const requestContext = getRequestContext() ?? createRequestContext();
     const resProxy = nextResponseProxy(res, requestContext);