feat(compile): support "bring your own node_modules" in deno compile (#21377)

Not tested thoroughly. This is a good start.

Closes #21350

1 files changed, 64 insertions, 27 deletions

diff --git a/cli/standalone/binary.rs b/cli/standalone/binary.rs
index 38ef3648e..d1a5863ee 100644
--- a/cli/standalone/binary.rs
+++ b/cli/standalone/binary.rs
@@ -123,6 +123,18 @@ impl SerializablePackageJsonDeps {
 }
 
 #[derive(Deserialize, Serialize)]
+pub enum NodeModules {
+  Managed {
+    /// Whether this uses a node_modules directory (true) or the global cache (false).
+    node_modules_dir: bool,
+    package_json_deps: Option<SerializablePackageJsonDeps>,
+  },
+  Byonm {
+    package_json_deps: Option<SerializablePackageJsonDeps>,
+  },
+}
+
+#[derive(Deserialize, Serialize)]
 pub struct Metadata {
   pub argv: Vec<String>,
   pub unstable: bool,
@@ -136,9 +148,7 @@ pub struct Metadata {
   pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
   pub maybe_import_map: Option<(Url, String)>,
   pub entrypoint: ModuleSpecifier,
-  /// Whether this uses a node_modules directory (true) or the global cache (false).
-  pub node_modules_dir: bool,
-  pub package_json_deps: Option<SerializablePackageJsonDeps>,
+  pub node_modules: Option<NodeModules>,
 }
 
 pub fn load_npm_vfs(root_dir_path: PathBuf) -> Result<FileBackedVfs, AnyError> {
@@ -490,23 +500,44 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       .resolve_import_map(self.file_fetcher)
       .await?
       .map(|import_map| (import_map.base_url().clone(), import_map.to_json()));
-    let (npm_vfs, npm_files) = match self.npm_resolver.as_inner() {
-      InnerCliNpmResolverRef::Managed(managed) => {
-        let snapshot =
-          managed.serialized_valid_snapshot_for_system(&self.npm_system_info);
-        if !snapshot.as_serialized().packages.is_empty() {
+    let (npm_vfs, npm_files, node_modules) =
+      match self.npm_resolver.as_inner() {
+        InnerCliNpmResolverRef::Managed(managed) => {
+          let snapshot =
+            managed.serialized_valid_snapshot_for_system(&self.npm_system_info);
+          if !snapshot.as_serialized().packages.is_empty() {
+            let (root_dir, files) = self.build_vfs()?.into_dir_and_files();
+            eszip.add_npm_snapshot(snapshot);
+            (
+              Some(root_dir),
+              files,
+              Some(NodeModules::Managed {
+                node_modules_dir: self
+                  .npm_resolver
+                  .root_node_modules_path()
+                  .is_some(),
+                package_json_deps: self.package_json_deps_provider.deps().map(
+                  |deps| SerializablePackageJsonDeps::from_deps(deps.clone()),
+                ),
+              }),
+            )
+          } else {
+            (None, Vec::new(), None)
+          }
+        }
+        InnerCliNpmResolverRef::Byonm(_) => {
           let (root_dir, files) = self.build_vfs()?.into_dir_and_files();
-          eszip.add_npm_snapshot(snapshot);
-          (Some(root_dir), files)
-        } else {
-          (None, Vec::new())
+          (
+            Some(root_dir),
+            files,
+            Some(NodeModules::Byonm {
+              package_json_deps: self.package_json_deps_provider.deps().map(
+                |deps| SerializablePackageJsonDeps::from_deps(deps.clone()),
+              ),
+            }),
+          )
         }
-      }
-      InnerCliNpmResolverRef::Byonm(_) => {
-        let (root_dir, files) = self.build_vfs()?.into_dir_and_files();
-        (Some(root_dir), files)
-      }
-    };
+      };
 
     let metadata = Metadata {
       argv: compile_flags.args.clone(),
@@ -523,11 +554,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       ca_data,
       entrypoint: entrypoint.clone(),
       maybe_import_map,
-      node_modules_dir: self.npm_resolver.root_node_modules_path().is_some(),
-      package_json_deps: self
-        .package_json_deps_provider
-        .deps()
-        .map(|deps| SerializablePackageJsonDeps::from_deps(deps.clone())),
+      node_modules,
     };
 
     write_binary_bytes(
@@ -545,7 +572,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       InnerCliNpmResolverRef::Managed(npm_resolver) => {
         if let Some(node_modules_path) = npm_resolver.root_node_modules_path() {
           let mut builder = VfsBuilder::new(node_modules_path.clone())?;
-          builder.add_dir_recursive(&node_modules_path)?;
+          builder.add_dir_recursive(node_modules_path)?;
           Ok(builder)
         } else {
           // DO NOT include the user's registry url as it may contain credentials,
@@ -565,9 +592,19 @@ impl<'a> DenoCompileBinaryWriter<'a> {
           Ok(builder)
         }
       }
-      InnerCliNpmResolverRef::Byonm(_) => {
-        // todo(#18967): should use the node_modules directory
-        todo!()
+      InnerCliNpmResolverRef::Byonm(npm_resolver) => {
+        // the root_node_modules directory will always exist for byonm
+        let node_modules_path = npm_resolver.root_node_modules_path().unwrap();
+        let parent_path = node_modules_path.parent().unwrap();
+        let mut builder = VfsBuilder::new(parent_path.to_path_buf())?;
+        let package_json_path = parent_path.join("package.json");
+        if package_json_path.exists() {
+          builder.add_file_at_path(&package_json_path)?;
+        }
+        if node_modules_path.exists() {
+          builder.add_dir_recursive(node_modules_path)?;
+        }
+        Ok(builder)
       }
     }
   }