feat(unstable/npm): support peer dependencies

cli/Cargo.toml

@@ -57,7 +57,7 @@ deno_emit = "0.10.0"
 deno_graph = "0.37.1"
 deno_lint = { version = "0.34.0", features = ["docs"] }
 deno_runtime = { version = "0.83.0", path = "../runtime" }
-deno_task_shell = "0.7.0"
+deno_task_shell = "0.7.2"
 napi_sym = { path = "./napi_sym", version = "0.5.0" }
 
 atty = "=0.2.14"
@@ -86,7 +86,7 @@ libc = "=0.2.126"
 log = { version = "=0.4.17", features = ["serde"] }
 lsp-types = "=0.93.2" # used by tower-lsp and "proposed" feature is unstable in patch releases
 mitata = "=0.0.7"
-monch = "=0.2.1"
+monch = "=0.4.0"
 notify = "=5.0.0"
 once_cell = "=1.14.0"
 os_pipe = "=1.0.1"

cli/fs_util.rs

@@ -15,6 +15,7 @@ use std::io::ErrorKind;
 use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
+use std::time::Duration;
 use walkdir::WalkDir;
 
 pub fn atomic_write_file<T: AsRef<[u8]>>(
@@ -357,6 +358,84 @@ pub fn copy_dir_recursive(from: &Path, to: &Path) -> Result<(), AnyError> {
   Ok(())
 }
 
+/// Hardlinks the files in one directory to another directory.
+///
+/// Note: Does not handle symlinks.
+pub fn hard_link_dir_recursive(from: &Path, to: &Path) -> Result<(), AnyError> {
+  std::fs::create_dir_all(&to)
+    .with_context(|| format!("Creating {}", to.display()))?;
+  let read_dir = std::fs::read_dir(&from)
+    .with_context(|| format!("Reading {}", from.display()))?;
+
+  for entry in read_dir {
+    let entry = entry?;
+    let file_type = entry.file_type()?;
+    let new_from = from.join(entry.file_name());
+    let new_to = to.join(entry.file_name());
+
+    if file_type.is_dir() {
+      hard_link_dir_recursive(&new_from, &new_to).with_context(|| {
+        format!("Dir {} to {}", new_from.display(), new_to.display())
+      })?;
+    } else if file_type.is_file() {
+      // note: chance for race conditions here between attempting to create,
+      // then removing, then attempting to create. There doesn't seem to be
+      // a way to hard link with overwriting in Rust, but maybe there is some
+      // way with platform specific code. The workaround here is to handle
+      // scenarios where something else might create or remove files.
+      if let Err(err) = std::fs::hard_link(&new_from, &new_to) {
+        if err.kind() == ErrorKind::AlreadyExists {
+          if let Err(err) = std::fs::remove_file(&new_to) {
+            if err.kind() == ErrorKind::NotFound {
+              // Assume another process/thread created this hard link to the file we are wanting
+              // to remove then sleep a little bit to let the other process/thread move ahead
+              // faster to reduce contention.
+              std::thread::sleep(Duration::from_millis(10));
+            } else {
+              return Err(err).with_context(|| {
+                format!(
+                  "Removing file to hard link {} to {}",
+                  new_from.display(),
+                  new_to.display()
+                )
+              });
+            }
+          }
+
+          // Always attempt to recreate the hardlink. In contention scenarios, the other process
+          // might have been killed or exited after removing the file, but before creating the hardlink
+          if let Err(err) = std::fs::hard_link(&new_from, &new_to) {
+            // Assume another process/thread created this hard link to the file we are wanting
+            // to now create then sleep a little bit to let the other process/thread move ahead
+            // faster to reduce contention.
+            if err.kind() == ErrorKind::AlreadyExists {
+              std::thread::sleep(Duration::from_millis(10));
+            } else {
+              return Err(err).with_context(|| {
+                format!(
+                  "Hard linking {} to {}",
+                  new_from.display(),
+                  new_to.display()
+                )
+              });
+            }
+          }
+        } else {
+          return Err(err).with_context(|| {
+            format!(
+              "Hard linking {} to {}",
+              new_from.display(),
+              new_to.display()
+            )
+          });
+        }
+      }
+    }
+  }
+
+  Ok(())
+}
+
 pub fn symlink_dir(oldpath: &Path, newpath: &Path) -> Result<(), AnyError> {
   let err_mapper = |err: Error| {
     Error::new(

cli/lockfile.rs

@@ -16,6 +16,7 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 use crate::args::ConfigFile;
+use crate::npm::NpmPackageId;
 use crate::npm::NpmPackageReq;
 use crate::npm::NpmResolutionPackage;
 use crate::tools::fmt::format_json;
@@ -40,7 +41,7 @@ pub struct NpmPackageInfo {
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct NpmContent {
-  /// Mapping between requests for npm packages and resolved specifiers, eg.
+  /// Mapping between requests for npm packages and resolved packages, eg.
   /// {
   ///   "chalk": "[email protected]"
   ///   "react@17": "[email protected]"
@@ -269,7 +270,7 @@ impl Lockfile {
     &mut self,
     package: &NpmResolutionPackage,
   ) -> Result<(), LockfileError> {
-    let specifier = package.id.serialize_for_lock_file();
+    let specifier = package.id.as_serialized();
     if let Some(package_info) = self.content.npm.packages.get(&specifier) {
       let integrity = package
         .dist
@@ -286,7 +287,7 @@ This could be caused by:
   * the source itself may be corrupt
 
 Use \"--lock-write\" flag to regenerate the lockfile at \"{}\".",
-          package.id, self.filename.display()
+          package.id.display(), self.filename.display()
         )));
       }
     } else {
@@ -300,7 +301,7 @@ Use \"--lock-write\" flag to regenerate the lockfile at \"{}\".",
     let dependencies = package
       .dependencies
       .iter()
-      .map(|(name, id)| (name.to_string(), id.serialize_for_lock_file()))
+      .map(|(name, id)| (name.to_string(), id.as_serialized()))
       .collect::<BTreeMap<String, String>>();
 
     let integrity = package
@@ -309,7 +310,7 @@ Use \"--lock-write\" flag to regenerate the lockfile at \"{}\".",
       .as_ref()
       .unwrap_or(&package.dist.shasum);
     self.content.npm.packages.insert(
-      package.id.serialize_for_lock_file(),
+      package.id.as_serialized(),
       NpmPackageInfo {
         integrity: integrity.to_string(),
         dependencies,
@@ -321,12 +322,13 @@ Use \"--lock-write\" flag to regenerate the lockfile at \"{}\".",
   pub fn insert_npm_specifier(
     &mut self,
     package_req: &NpmPackageReq,
-    version: String,
+    package_id: &NpmPackageId,
   ) {
-    self.content.npm.specifiers.insert(
-      package_req.to_string(),
-      format!("{}@{}", package_req.name, version),
-    );
+    self
+      .content
+      .npm
+      .specifiers
+      .insert(package_req.to_string(), package_id.as_serialized());
     self.has_content_changed = true;
   }
 }
@@ -559,10 +561,12 @@ mod tests {
       id: NpmPackageId {
         name: "nanoid".to_string(),
         version: NpmVersion::parse("3.3.4").unwrap(),
+        peer_dependencies: Vec::new(),
       },
+      copy_index: 0,
       dist: NpmPackageVersionDistInfo {
-        tarball: "foo".to_string(), 
-        shasum: "foo".to_string(), 
+        tarball: "foo".to_string(),
+        shasum: "foo".to_string(),
         integrity: Some("sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==".to_string())
       },
       dependencies: HashMap::new(),
@@ -574,10 +578,12 @@ mod tests {
       id: NpmPackageId {
         name: "picocolors".to_string(),
         version: NpmVersion::parse("1.0.0").unwrap(),
+        peer_dependencies: Vec::new(),
       },
+      copy_index: 0,
       dist: NpmPackageVersionDistInfo {
-        tarball: "foo".to_string(), 
-        shasum: "foo".to_string(), 
+        tarball: "foo".to_string(),
+        shasum: "foo".to_string(),
         integrity: Some("sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==".to_string())
       },
       dependencies: HashMap::new(),
@@ -590,10 +596,12 @@ mod tests {
       id: NpmPackageId {
         name: "source-map-js".to_string(),
         version: NpmVersion::parse("1.0.2").unwrap(),
+        peer_dependencies: Vec::new(),
       },
+      copy_index: 0,
       dist: NpmPackageVersionDistInfo {
-        tarball: "foo".to_string(), 
-        shasum: "foo".to_string(), 
+        tarball: "foo".to_string(),
+        shasum: "foo".to_string(),
         integrity: Some("sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==".to_string())
       },
       dependencies: HashMap::new(),
@@ -606,7 +614,9 @@ mod tests {
       id: NpmPackageId {
         name: "source-map-js".to_string(),
         version: NpmVersion::parse("1.0.2").unwrap(),
+        peer_dependencies: Vec::new(),
       },
+      copy_index: 0,
       dist: NpmPackageVersionDistInfo {
         tarball: "foo".to_string(),
         shasum: "foo".to_string(),

cli/lsp/language_server.rs

@@ -71,7 +71,7 @@ use crate::fs_util;
 use crate::graph_util::graph_valid;
 use crate::npm::NpmCache;
 use crate::npm::NpmPackageResolver;
-use crate::npm::NpmRegistryApi;
+use crate::npm::RealNpmRegistryApi;
 use crate::proc_state::import_map_from_text;
 use crate::proc_state::ProcState;
 use crate::progress_bar::ProgressBar;
@@ -258,7 +258,7 @@ impl Inner {
       ts_server.clone(),
     );
     let assets = Assets::new(ts_server.clone());
-    let registry_url = NpmRegistryApi::default_url();
+    let registry_url = RealNpmRegistryApi::default_url();
     // Use an "only" cache setting in order to make the
     // user do an explicit "cache" command and prevent
     // the cache from being filled with lots of packages while
@@ -270,7 +270,7 @@ impl Inner {
       cache_setting.clone(),
       progress_bar.clone(),
     );
-    let api = NpmRegistryApi::new(
+    let api = RealNpmRegistryApi::new(
       registry_url,
       npm_cache.clone(),
       cache_setting,