@vercel/remix-builder 5.0.2 → 5.1.0

package/defaults/server-node.mjs

@@ -8,9 +8,13 @@ import * as build from '@remix-run/dev/server-build';
 
 installGlobals({
   nativeFetch:
+    // Explicit opt-in to native fetch via runtime env var
     (parseInt(process.versions.node, 10) >= 20 &&
       process.env.VERCEL_REMIX_NATIVE_FETCH === '1') ||
-    build.future.unstable_singleFetch,
+    // `unstable_singleFetch` future flag added in Remix v2.9.0
+    build.future.unstable_singleFetch ||
+    // `v3_singleFetch` future flag stabilized in Remix v2.13.0
+    build.future.v3_singleFetch,
 });
 
 const handleRequest = createRemixRequestHandler(

package/defaults/server-react-router.mjs

@@ -0,0 +1,3 @@
+import { createRequestHandler } from 'react-router';
+import * as build from 'ENTRYPOINT_PLACEHOLDER';
+export default createRequestHandler(build.default || build);

package/dist/index.js

@@ -3066,17 +3066,15 @@ function hasScript(scriptName, pkg) {
   const scripts = pkg?.scripts || {};
   return typeof scripts[scriptName] === "string";
 }
-async function getRemixVersion(dir, base) {
-  const resolvedPath = require_.resolve("@remix-run/dev", { paths: [dir] });
+async function getPackageVersion(name, dir, base) {
+  const resolvedPath = require_.resolve(name, { paths: [dir] });
   const pkgPath = await (0, import_build_utils2.walkParentDirs)({
     base,
     start: (0, import_path.dirname)(resolvedPath),
     filename: "package.json"
   });
   if (!pkgPath) {
-    throw new Error(
-      `Failed to find \`package.json\` file for "@remix-run/dev"`
-    );
+    throw new Error(`Failed to find \`package.json\` file for "${name}"`);
   }
   const { version: version2 } = JSON.parse(
     await import_fs.promises.readFile(pkgPath, "utf8")
@@ -3137,6 +3135,80 @@ var nodeServerSrcPromise = import_fs2.promises.readFile(
   (0, import_path2.join)(DEFAULTS_PATH, "server-node.mjs"),
   "utf-8"
 );
+var reactRouterServerSrcPromise = import_fs2.promises.readFile(
+  (0, import_path2.join)(DEFAULTS_PATH, "server-react-router.mjs"),
+  "utf-8"
+);
+var REMIX_FRAMEWORK_SETTINGS = {
+  primaryPackageName: "@remix-run/dev",
+  buildCommand: "remix build",
+  buildResultFilePath: ".vercel/remix-build-result.json",
+  createRenderFunction({
+    nodeVersion,
+    entrypointDir,
+    rootDir,
+    serverBuildPath,
+    serverEntryPoint,
+    frameworkVersion,
+    config
+  }) {
+    if (config.runtime === "edge") {
+      return createRenderEdgeFunction(
+        entrypointDir,
+        rootDir,
+        serverBuildPath,
+        serverEntryPoint,
+        frameworkVersion,
+        config
+      );
+    }
+    return createRenderNodeFunction(
+      nodeVersion,
+      entrypointDir,
+      rootDir,
+      serverBuildPath,
+      serverEntryPoint,
+      frameworkVersion,
+      config
+    );
+  }
+};
+var REACT_ROUTER_FRAMEWORK_SETTINGS = {
+  primaryPackageName: "react-router",
+  buildCommand: "react-router build",
+  buildResultFilePath: ".vercel/react-router-build-result.json",
+  createRenderFunction({
+    nodeVersion,
+    entrypointDir,
+    rootDir,
+    serverBuildPath,
+    serverEntryPoint,
+    frameworkVersion,
+    config
+  }) {
+    return createRenderReactRouterFunction(
+      nodeVersion,
+      entrypointDir,
+      rootDir,
+      serverBuildPath,
+      serverEntryPoint,
+      frameworkVersion,
+      config
+    );
+  }
+};
+function determineFrameworkSettings(workPath) {
+  const isReactRouter = findConfig(workPath, "react-router.config", [
+    ".js",
+    ".ts",
+    ".mjs",
+    ".mts"
+  ]);
+  if (isReactRouter) {
+    return REACT_ROUTER_FRAMEWORK_SETTINGS;
+  }
+  return REMIX_FRAMEWORK_SETTINGS;
+}
 var build = async ({
   entrypoint,
   workPath,
@@ -3147,6 +3219,7 @@ var build = async ({
   const { installCommand, buildCommand } = config;
   const mountpoint = (0, import_path2.dirname)(entrypoint);
   const entrypointFsDirname = (0, import_path2.join)(workPath, mountpoint);
+  const frameworkSettings = determineFrameworkSettings(workPath);
   const nodeVersion = await (0, import_build_utils3.getNodeVersion)(
     entrypointFsDirname,
     void 0,
@@ -3185,7 +3258,11 @@ var build = async ({
   } else {
     await (0, import_build_utils3.runNpmInstall)(entrypointFsDirname, [], spawnOpts, meta, nodeVersion);
   }
-  const remixVersion = await getRemixVersion(entrypointFsDirname, repoRootPath);
+  const frameworkVersion = await getPackageVersion(
+    frameworkSettings.primaryPackageName,
+    entrypointFsDirname,
+    repoRootPath
+  );
   if (buildCommand) {
     (0, import_build_utils3.debug)(`Executing build command "${buildCommand}"`);
     await (0, import_build_utils3.execCommand)(buildCommand, {
@@ -3204,28 +3281,28 @@ var build = async ({
       (0, import_build_utils3.debug)(`Executing "build" script`);
       await (0, import_build_utils3.runPackageJsonScript)(entrypointFsDirname, "build", spawnOpts);
     } else {
-      await (0, import_build_utils3.execCommand)("remix build", {
+      await (0, import_build_utils3.execCommand)(frameworkSettings.buildCommand, {
         ...spawnOpts,
         cwd: entrypointFsDirname
       });
     }
   }
-  const remixBuildResultPath = (0, import_path2.join)(
+  const buildResultJsonPath = (0, import_path2.join)(
     entrypointFsDirname,
-    ".vercel/remix-build-result.json"
+    frameworkSettings.buildResultFilePath
   );
-  let remixBuildResult;
+  let buildResult;
   try {
-    const remixBuildResultContents = (0, import_fs2.readFileSync)(remixBuildResultPath, "utf8");
-    remixBuildResult = JSON.parse(remixBuildResultContents);
+    const buildResultContents = (0, import_fs2.readFileSync)(buildResultJsonPath, "utf8");
+    buildResult = JSON.parse(buildResultContents);
   } catch (err) {
     if (!(0, import_error_utils.isErrnoException)(err) || err.code !== "ENOENT") {
       throw err;
     }
-    const buildDirectory = (0, import_path2.join)(entrypointFsDirname, "build");
-    if ((0, import_fs2.statSync)(buildDirectory).isDirectory()) {
+    const buildDirectory2 = (0, import_path2.join)(entrypointFsDirname, "build");
+    if ((0, import_fs2.statSync)(buildDirectory2).isDirectory()) {
       console.warn("WARN: The `vercelPreset()` Preset was not detected.");
-      remixBuildResult = {
+      buildResult = {
         buildManifest: {
           routes: {
             root: {
@@ -3244,15 +3321,15 @@ var build = async ({
           }
         },
         remixConfig: {
-          buildDirectory
+          buildDirectory: buildDirectory2
         }
       };
       const serverPath = "build/server/index.js";
       if ((0, import_fs2.existsSync)((0, import_path2.join)(entrypointFsDirname, serverPath))) {
-        remixBuildResult.buildManifest.routeIdToServerBundleId = {
+        buildResult.buildManifest.routeIdToServerBundleId = {
           "routes/_index": ""
         };
-        remixBuildResult.buildManifest.serverBundles = {
+        buildResult.buildManifest.serverBundles = {
           "": {
             id: "",
             file: serverPath,
@@ -3262,36 +3339,27 @@ var build = async ({
       }
     }
   }
-  if (!remixBuildResult) {
+  if (!buildResult) {
     throw new Error(
       "Could not determine build output directory. Please configure the `vercelPreset()` Preset from the `@vercel/remix` npm package"
     );
   }
-  const { buildManifest, remixConfig, viteConfig } = remixBuildResult;
-  const staticDir = (0, import_path2.join)(remixConfig.buildDirectory, "client");
+  const { buildManifest, viteConfig } = buildResult;
+  const buildDirectory = "remixConfig" in buildResult ? buildResult.remixConfig.buildDirectory : buildResult.reactRouterConfig.buildDirectory;
+  const staticDir = (0, import_path2.join)(buildDirectory, "client");
   const serverBundles = Object.values(buildManifest.serverBundles ?? {});
   const [staticFiles, ...functions] = await Promise.all([
     (0, import_build_utils3.glob)("**", staticDir),
     ...serverBundles.map((bundle) => {
-      if (bundle.config.runtime === "edge") {
-        return createRenderEdgeFunction(
-          entrypointFsDirname,
-          repoRootPath,
-          (0, import_path2.join)(entrypointFsDirname, bundle.file),
-          void 0,
-          remixVersion,
-          bundle.config
-        );
-      }
-      return createRenderNodeFunction(
+      return frameworkSettings.createRenderFunction({
         nodeVersion,
-        entrypointFsDirname,
-        repoRootPath,
-        (0, import_path2.join)(entrypointFsDirname, bundle.file),
-        void 0,
-        remixVersion,
-        bundle.config
-      );
+        entrypointDir: entrypointFsDirname,
+        rootDir: repoRootPath,
+        serverBuildPath: (0, import_path2.join)(entrypointFsDirname, bundle.file),
+        serverEntryPoint: void 0,
+        frameworkVersion,
+        config: bundle.config
+      });
     })
   ]);
   const functionsMap = /* @__PURE__ */ new Map();
@@ -3335,9 +3403,98 @@ var build = async ({
     src: "/(.*)",
     dest: "/"
   });
-  return { routes, output, framework: { version: remixVersion } };
+  return { routes, output, framework: { version: frameworkVersion } };
 };
-async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderReactRouterFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
+  const isEdgeFunction = config.runtime === "edge";
+  const files = {};
+  let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
+  let handlerPath = (0, import_path2.join)(rootDir, handler);
+  if (!serverEntryPoint) {
+    const baseServerBuildPath = (0, import_path2.basename)(serverBuildPath, ".js");
+    handler = (0, import_path2.join)((0, import_path2.dirname)(handler), `server-${baseServerBuildPath}.mjs`);
+    handlerPath = (0, import_path2.join)(rootDir, handler);
+    const reactRouterServerSrc = await reactRouterServerSrcPromise;
+    await import_fs2.promises.writeFile(
+      handlerPath,
+      reactRouterServerSrc.replace(
+        "ENTRYPOINT_PLACEHOLDER",
+        `./${baseServerBuildPath}.js`
+      )
+    );
+  }
+  let conditions;
+  let readFile;
+  if (isEdgeFunction) {
+    conditions = ["edge-light", "browser", "module", "import", "require"];
+    readFile = async (fsPath) => {
+      let source;
+      try {
+        source = await import_fs2.promises.readFile(fsPath);
+      } catch (err) {
+        if (err.code === "ENOENT" || err.code === "EISDIR") {
+          return null;
+        }
+        throw err;
+      }
+      if ((0, import_path2.basename)(fsPath) === "package.json") {
+        const pkgJson = JSON.parse(source.toString());
+        for (const prop of ["browser", "module"]) {
+          const val = pkgJson[prop];
+          if (typeof val === "string") {
+            pkgJson.main = val;
+            source = JSON.stringify(pkgJson);
+            break;
+          }
+        }
+      }
+      return source;
+    };
+  }
+  const trace = await (0, import_nft.nodeFileTrace)([handlerPath], {
+    base: rootDir,
+    processCwd: entrypointDir,
+    conditions,
+    readFile
+  });
+  logNftWarnings(trace.warnings, "react-router");
+  for (const file of trace.fileList) {
+    files[file] = await import_build_utils3.FileFsRef.fromFsPath({ fsPath: (0, import_path2.join)(rootDir, file) });
+  }
+  let fn;
+  if (isEdgeFunction) {
+    fn = new import_build_utils3.EdgeFunction({
+      files,
+      deploymentTarget: "v8-worker",
+      entrypoint: handler,
+      regions: config.regions,
+      framework: {
+        slug: "react-router",
+        version: frameworkVersion
+      }
+    });
+  } else {
+    fn = new import_build_utils3.NodejsLambda({
+      files,
+      handler,
+      runtime: nodeVersion.runtime,
+      shouldAddHelpers: false,
+      shouldAddSourcemapSupport: false,
+      operationType: "SSR",
+      supportsResponseStreaming: true,
+      useWebApi: true,
+      regions: config.regions,
+      memory: config.memory,
+      maxDuration: config.maxDuration,
+      framework: {
+        slug: "react-router",
+        version: frameworkVersion
+      }
+    });
+  }
+  return fn;
+}
+async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
   const files = {};
   let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path2.join)(rootDir, handler);
@@ -3375,12 +3532,12 @@ async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, ser
     maxDuration: config.maxDuration,
     framework: {
       slug: "remix",
-      version: remixVersion
+      version: frameworkVersion
     }
   });
   return fn;
 }
-async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
   const files = {};
   let handler = (0, import_path2.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path2.join)(rootDir, handler);
@@ -3441,7 +3598,7 @@ async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath,
     regions: config.regions,
     framework: {
       slug: "remix",
-      version: remixVersion
+      version: frameworkVersion
     }
   });
   return fn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/remix-builder",
-  "version": "5.0.2",
+  "version": "5.1.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -24,7 +24,7 @@
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
     "@types/semver": "7.3.13",
-    "@vercel/build-utils": "9.0.1",
+    "@vercel/build-utils": "9.1.0",
     "glob": "10.3.16",
     "jest-junit": "16.0.0",
     "path-to-regexp": "6.2.1",