@vercel/remix-builder 5.3.0 → 5.3.2

package/dist/index.js

@@ -2811,21 +2811,38 @@ var reactRouterServerSrcPromise = import_fs2.promises.readFile(
   (0, import_path2.join)(DEFAULTS_PATH, "server-react-router.mjs"),
   "utf-8"
 );
+var COMMON_NODE_RUNTIME_SETTINGS = {
+  traceFunction: traceNodeFiles,
+  createRuntimeFunction: createNodeFunction
+};
+var COMMON_EDGE_RUNTIME_SETTINGS = {
+  traceFunction: traceEdgeFiles,
+  createRuntimeFunction: createEdgeFunction
+};
 var REMIX_FRAMEWORK_SETTINGS = {
   primaryPackageName: "@remix-run/dev",
   buildCommand: "remix build",
   buildResultFilePath: ".vercel/remix-build-result.json",
+  presetDocumentationLink: "https://vercel.com/docs/frameworks/remix#vercel-vite-preset",
   slug: "remix",
   sourceSearchValue: "@remix-run/dev/server-build",
   edge: {
+    ...COMMON_EDGE_RUNTIME_SETTINGS,
     serverSourcePromise: edgeServerSrcPromise,
     traceWarningTag: "@remix-run/server-runtime"
   },
   node: {
+    ...COMMON_NODE_RUNTIME_SETTINGS,
     serverSourcePromise: nodeServerSrcPromise,
     traceWarningTag: "@remix-run/node",
     options: {}
   },
+  getRuntimeSettings(runtime) {
+    if (runtime === "edge") {
+      return this.edge;
+    }
+    return this.node;
+  },
   createRenderFunction({
     nodeVersion,
     entrypointDir,
@@ -2835,43 +2852,45 @@ var REMIX_FRAMEWORK_SETTINGS = {
     frameworkVersion,
     config
   }) {
-    if (config.runtime === "edge") {
-      return createRenderEdgeFunction(
-        entrypointDir,
-        rootDir,
-        serverBuildPath,
-        serverEntryPoint,
-        frameworkVersion,
-        config
-      );
-    }
-    return createRenderNodeFunction(
-      nodeVersion,
+    return createRenderFunction({
       entrypointDir,
       rootDir,
       serverBuildPath,
       serverEntryPoint,
       frameworkVersion,
-      config
-    );
+      config,
+      frameworkRuntimeSettings: this.getRuntimeSettings(config),
+      sourceSearchValue: this.sourceSearchValue,
+      frameworkSlug: this.slug,
+      nodeVersion
+    });
   }
 };
 var REACT_ROUTER_FRAMEWORK_SETTINGS = {
   primaryPackageName: "react-router",
   buildCommand: "react-router build",
   buildResultFilePath: ".vercel/react-router-build-result.json",
+  presetDocumentationLink: "https://vercel.com/docs/frameworks/react-router#vercel-react-router-preset",
   slug: "react-router",
   sourceSearchValue: "virtual:react-router/server-build",
   // React Router uses the same server source for both node and edge
   edge: {
+    ...COMMON_EDGE_RUNTIME_SETTINGS,
     serverSourcePromise: reactRouterServerSrcPromise,
     traceWarningTag: "react-router"
   },
   node: {
+    ...COMMON_NODE_RUNTIME_SETTINGS,
     serverSourcePromise: reactRouterServerSrcPromise,
     traceWarningTag: "react-router",
     options: { useWebApi: true }
   },
+  getRuntimeSettings(runtime) {
+    if (runtime === "edge") {
+      return this.edge;
+    }
+    return this.node;
+  },
   createRenderFunction({
     nodeVersion,
     entrypointDir,
@@ -2881,29 +2900,20 @@ var REACT_ROUTER_FRAMEWORK_SETTINGS = {
     frameworkVersion,
     config
   }) {
-    return createRenderReactRouterFunction(
-      nodeVersion,
+    return createRenderFunction({
       entrypointDir,
       rootDir,
       serverBuildPath,
       serverEntryPoint,
       frameworkVersion,
-      config
-    );
+      config,
+      frameworkRuntimeSettings: this.getRuntimeSettings(config),
+      sourceSearchValue: this.sourceSearchValue,
+      frameworkSlug: this.slug,
+      nodeVersion
+    });
   }
 };
-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;
-}
 async function determineHandler({
   rootDir,
   serverBuildPath,
@@ -2935,7 +2945,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 frameworkSettings = config.framework === "react-router" ? REACT_ROUTER_FRAMEWORK_SETTINGS : REMIX_FRAMEWORK_SETTINGS;
   const nodeVersion = await (0, import_build_utils3.getNodeVersion)(
     entrypointFsDirname,
     void 0,
@@ -3040,6 +3050,9 @@ var build = async ({
     const buildDirectory2 = (0, import_path2.join)(entrypointFsDirname, "build");
     if ((0, import_fs2.statSync)(buildDirectory2).isDirectory()) {
       console.warn("WARN: The `vercelPreset()` Preset was not detected.");
+      console.warn(
+        `See ${frameworkSettings.presetDocumentationLink} for more information`
+      );
       buildResult = {
         buildManifest: {
           routes: {
@@ -3143,171 +3156,150 @@ var build = async ({
   });
   return { routes, output, framework: { version: frameworkVersion } };
 };
-async function edgeReadFile(fsPath) {
-  let source;
-  try {
-    source = await import_fs2.promises.readFile(fsPath);
-  } catch (err) {
-    if (err.code === "ENOENT" || err.code === "EISDIR") {
-      return null;
+async function traceEdgeFiles({
+  handlerPath,
+  rootDir,
+  entrypointDir
+}) {
+  const EDGE_TRACE_CONDITIONS = [
+    "edge-light",
+    "browser",
+    "module",
+    "import",
+    "require"
+  ];
+  async function edgeReadFile(fsPath) {
+    let source;
+    try {
+      source = await import_fs2.promises.readFile(fsPath);
+    } catch (err) {
+      if (err.code === "ENOENT" || err.code === "EISDIR") {
+        return null;
+      }
+      throw err;
     }
-    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;
+    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;
   }
-  return source;
-}
-var EDGE_TRACE_CONDITIONS = [
-  "edge-light",
-  "browser",
-  "module",
-  "import",
-  "require"
-];
-var COMMON_NODE_FUNCTION_OPTIONS = {
-  shouldAddHelpers: false,
-  shouldAddSourcemapSupport: false,
-  operationType: "SSR",
-  supportsResponseStreaming: true
-};
-var COMMON_EDGE_FUNCTION_OPTIONS = { deploymentTarget: "v8-worker" };
-async function createRenderReactRouterFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
-  const isEdgeFunction = config.runtime === "edge";
-  const { handler, handlerPath } = await determineHandler({
-    rootDir,
-    serverBuildPath,
-    serverEntryPoint,
-    serverSourcePromise: (
-      // React Router has the same promise for both edge and node
-      // so this chooses edge out of convenience
-      REACT_ROUTER_FRAMEWORK_SETTINGS.edge.serverSourcePromise
-    ),
-    sourceSearchValue: REACT_ROUTER_FRAMEWORK_SETTINGS.sourceSearchValue
-  });
-  let conditions;
-  let readFile;
-  if (isEdgeFunction) {
-    conditions = EDGE_TRACE_CONDITIONS;
-    readFile = edgeReadFile;
-  }
-  const trace = await (0, import_nft.nodeFileTrace)([handlerPath], {
+  return await (0, import_nft.nodeFileTrace)([handlerPath], {
     base: rootDir,
     processCwd: entrypointDir,
-    conditions,
-    readFile
+    conditions: EDGE_TRACE_CONDITIONS,
+    readFile: edgeReadFile
   });
-  logNftWarnings(
-    trace.warnings,
-    REACT_ROUTER_FRAMEWORK_SETTINGS.edge.traceWarningTag
-  );
-  const files = await getFilesFromTrace({ fileList: trace.fileList, rootDir });
-  let fn;
-  if (isEdgeFunction) {
-    fn = new import_build_utils3.EdgeFunction({
-      ...COMMON_EDGE_FUNCTION_OPTIONS,
-      files,
-      entrypoint: handler,
-      regions: config.regions,
-      framework: {
-        slug: REACT_ROUTER_FRAMEWORK_SETTINGS.slug,
-        version: frameworkVersion
-      }
-    });
-  } else {
-    fn = new import_build_utils3.NodejsLambda({
-      ...COMMON_NODE_FUNCTION_OPTIONS,
-      files,
-      handler,
-      runtime: nodeVersion.runtime,
-      useWebApi: REACT_ROUTER_FRAMEWORK_SETTINGS.node.options.useWebApi,
-      regions: config.regions,
-      memory: config.memory,
-      maxDuration: config.maxDuration,
-      framework: {
-        slug: REACT_ROUTER_FRAMEWORK_SETTINGS.slug,
-        version: frameworkVersion
-      }
-    });
-  }
-  return fn;
 }
-async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
-  const { handler, handlerPath } = await determineHandler({
-    rootDir,
-    serverBuildPath,
-    serverEntryPoint,
-    serverSourcePromise: REMIX_FRAMEWORK_SETTINGS.node.serverSourcePromise,
-    sourceSearchValue: REMIX_FRAMEWORK_SETTINGS.sourceSearchValue
-  });
-  const trace = await (0, import_nft.nodeFileTrace)([handlerPath], {
+async function traceNodeFiles({
+  handlerPath,
+  rootDir,
+  entrypointDir
+}) {
+  return await (0, import_nft.nodeFileTrace)([handlerPath], {
     base: rootDir,
     processCwd: entrypointDir
   });
-  logNftWarnings(trace.warnings, REMIX_FRAMEWORK_SETTINGS.node.traceWarningTag);
-  const files = await getFilesFromTrace({ fileList: trace.fileList, rootDir });
-  const fn = new import_build_utils3.NodejsLambda({
-    ...COMMON_NODE_FUNCTION_OPTIONS,
+}
+async function getFilesFromTrace({
+  fileList,
+  rootDir
+}) {
+  const files = {};
+  for (const file of fileList) {
+    files[file] = await import_build_utils3.FileFsRef.fromFsPath({ fsPath: (0, import_path2.join)(rootDir, file) });
+  }
+  return files;
+}
+function createEdgeFunction({
+  files,
+  handler,
+  config,
+  frameworkSlug,
+  frameworkVersion
+}) {
+  return new import_build_utils3.EdgeFunction({
+    deploymentTarget: "v8-worker",
+    files,
+    entrypoint: handler,
+    regions: config.regions,
+    framework: {
+      slug: frameworkSlug,
+      version: frameworkVersion
+    }
+  });
+}
+function createNodeFunction({
+  files,
+  handler,
+  config,
+  frameworkSlug,
+  frameworkVersion,
+  nodeVersion,
+  useWebApi
+}) {
+  return new import_build_utils3.NodejsLambda({
+    shouldAddHelpers: false,
+    shouldAddSourcemapSupport: false,
+    operationType: "SSR",
+    supportsResponseStreaming: true,
     files,
     handler,
     runtime: nodeVersion.runtime,
     regions: config.regions,
     memory: config.memory,
     maxDuration: config.maxDuration,
-    useWebApi: REMIX_FRAMEWORK_SETTINGS.node.options.useWebApi,
+    useWebApi,
     framework: {
-      slug: REMIX_FRAMEWORK_SETTINGS.slug,
+      slug: frameworkSlug,
       version: frameworkVersion
     }
   });
-  return fn;
 }
-async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, frameworkVersion, config) {
+async function createRenderFunction({
+  rootDir,
+  serverBuildPath,
+  serverEntryPoint,
+  entrypointDir,
+  config,
+  frameworkVersion,
+  frameworkRuntimeSettings,
+  sourceSearchValue,
+  frameworkSlug,
+  nodeVersion
+}) {
   const { handler, handlerPath } = await determineHandler({
     rootDir,
     serverBuildPath,
     serverEntryPoint,
-    serverSourcePromise: REMIX_FRAMEWORK_SETTINGS.edge.serverSourcePromise,
-    sourceSearchValue: REMIX_FRAMEWORK_SETTINGS.sourceSearchValue
+    serverSourcePromise: frameworkRuntimeSettings.serverSourcePromise,
+    sourceSearchValue
   });
-  const trace = await (0, import_nft.nodeFileTrace)([handlerPath], {
-    base: rootDir,
-    processCwd: entrypointDir,
-    conditions: EDGE_TRACE_CONDITIONS,
-    readFile: edgeReadFile
+  const trace = await frameworkRuntimeSettings.traceFunction({
+    handlerPath,
+    rootDir,
+    entrypointDir
   });
-  logNftWarnings(trace.warnings, REMIX_FRAMEWORK_SETTINGS.edge.traceWarningTag);
+  logNftWarnings(trace.warnings, frameworkRuntimeSettings.traceWarningTag);
   const files = await getFilesFromTrace({ fileList: trace.fileList, rootDir });
-  const fn = new import_build_utils3.EdgeFunction({
-    ...COMMON_EDGE_FUNCTION_OPTIONS,
+  const fn = frameworkRuntimeSettings.createRuntimeFunction({
     files,
-    entrypoint: handler,
-    regions: config.regions,
-    framework: {
-      slug: REMIX_FRAMEWORK_SETTINGS.slug,
-      version: frameworkVersion
-    }
+    handler,
+    config,
+    frameworkSlug,
+    frameworkVersion,
+    nodeVersion,
+    useWebApi: frameworkRuntimeSettings.options?.useWebApi
   });
   return fn;
 }
-async function getFilesFromTrace({
-  fileList,
-  rootDir
-}) {
-  const files = {};
-  for (const file of fileList) {
-    files[file] = await import_build_utils3.FileFsRef.fromFsPath({ fsPath: (0, import_path2.join)(rootDir, file) });
-  }
-  return files;
-}
 
 // src/build-legacy.ts
 var import_ts_morph2 = require("ts-morph");
@@ -3733,7 +3725,7 @@ module.exports = config;`;
       };
       const serverBuildPath = (0, import_path4.join)(entrypointFsDirname, bundle.serverBuildPath);
       if (config2.runtime === "edge") {
-        return createRenderEdgeFunction2(
+        return createRenderEdgeFunction(
           entrypointFsDirname,
           repoRootPath,
           serverBuildPath,
@@ -3742,7 +3734,7 @@ module.exports = config;`;
           config2
         );
       }
-      return createRenderNodeFunction2(
+      return createRenderNodeFunction(
         nodeVersion,
         entrypointFsDirname,
         repoRootPath,
@@ -3813,7 +3805,7 @@ function hasScript2(scriptName, pkg) {
   const scripts = pkg && pkg.scripts || {};
   return typeof scripts[scriptName] === "string";
 }
-async function createRenderNodeFunction2(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderNodeFunction(nodeVersion, entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
   const files = {};
   let handler = (0, import_path4.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path4.join)(rootDir, handler);
@@ -3859,7 +3851,7 @@ async function createRenderNodeFunction2(nodeVersion, entrypointDir, rootDir, se
   });
   return fn;
 }
-async function createRenderEdgeFunction2(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
+async function createRenderEdgeFunction(entrypointDir, rootDir, serverBuildPath, serverEntryPoint, remixVersion, config) {
   const files = {};
   let handler = (0, import_path4.relative)(rootDir, serverBuildPath);
   let handlerPath = (0, import_path4.join)(rootDir, handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/remix-builder",
-  "version": "5.3.0",
+  "version": "5.3.2",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -26,7 +26,7 @@
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
     "@types/semver": "7.3.13",
-    "@vercel/build-utils": "9.3.0",
+    "@vercel/build-utils": "10.0.1",
     "glob": "10.3.16",
     "jest-junit": "16.0.0",
     "semver": "7.5.2",