refactor(npm): break up NpmModuleLoader and move more methods into the managed CliNpmResolver (#20777)

Part of https://github.com/denoland/deno/issues/18967

cli/npm/common.rs

@@ -0,0 +1,23 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/// Gets the corresponding @types package for the provided package name.
+pub fn types_package_name(package_name: &str) -> String {
+  debug_assert!(!package_name.starts_with("@types/"));
+  // Scoped packages will get two underscores for each slash
+  // https://github.com/DefinitelyTyped/DefinitelyTyped/tree/15f1ece08f7b498f4b9a2147c2a46e94416ca777#what-about-scoped-packages
+  format!("@types/{}", package_name.replace('/', "__"))
+}
+
+#[cfg(test)]
+mod test {
+  use super::types_package_name;
+
+  #[test]
+  fn test_types_package_name() {
+    assert_eq!(types_package_name("name"), "@types/name");
+    assert_eq!(
+      types_package_name("@scoped/package"),
+      "@types/@scoped__package"
+    );
+  }
+}

cli/npm/managed/mod.rs

@@ -1,6 +1,5 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-use std::collections::HashMap;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -23,15 +22,13 @@ use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NpmResolver;
-use deno_semver::npm::NpmPackageNvReference;
-use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageNv;
-use deno_semver::package::PackageNvReference;
 use deno_semver::package::PackageReq;
 
 use crate::args::Lockfile;
 use crate::args::NpmProcessState;
 use crate::args::PackageJsonDepsProvider;
+use crate::cache::FastInsecureHasher;
 use crate::util::fs::canonicalize_path_maybe_not_exists_with_fs;
 use crate::util::progress_bar::ProgressBar;
 
@@ -345,6 +342,16 @@ impl ManagedCliNpmResolver {
     self.resolution.all_system_packages(system_info)
   }
 
+  /// Checks if the provided package req's folder is cached.
+  pub fn is_pkg_req_folder_cached(&self, req: &PackageReq) -> bool {
+    self
+      .resolve_pkg_id_from_pkg_req(req)
+      .ok()
+      .and_then(|id| self.fs_resolver.package_folder(&id).ok())
+      .map(|folder| folder.exists())
+      .unwrap_or(false)
+  }
+
   /// Adds package requirements to the resolver and ensures everything is setup.
   pub async fn add_package_reqs(
     &self,
@@ -413,6 +420,35 @@ impl ManagedCliNpmResolver {
     self.fs_resolver.cache_packages().await
   }
 
+  /// Resolves a package requirement for deno graph. This should only be
+  /// called by deno_graph's NpmResolver or for resolving packages in
+  /// a package.json
+  pub fn resolve_npm_for_deno_graph(
+    &self,
+    pkg_req: &PackageReq,
+  ) -> NpmPackageReqResolution {
+    let result = self.resolution.resolve_pkg_req_as_pending(pkg_req);
+    match result {
+      Ok(nv) => NpmPackageReqResolution::Ok(nv),
+      Err(err) => {
+        if self.api.mark_force_reload() {
+          log::debug!("Restarting npm specifier resolution to check for new registry information. Error: {:#}", err);
+          NpmPackageReqResolution::ReloadRegistryInfo(err.into())
+        } else {
+          NpmPackageReqResolution::Err(err.into())
+        }
+      }
+    }
+  }
+
+  pub fn resolve_pkg_folder_from_deno_module(
+    &self,
+    nv: &PackageNv,
+  ) -> Result<PathBuf, AnyError> {
+    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(nv)?;
+    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
+  }
+
   fn resolve_pkg_id_from_pkg_req(
     &self,
     req: &PackageReq,
@@ -513,7 +549,7 @@ impl CliNpmResolver for ManagedCliNpmResolver {
         &self.progress_bar,
         self.api.base_url().clone(),
         npm_resolution,
-        self.node_modules_path(),
+        self.root_node_modules_path(),
         self.npm_system_info.clone(),
       ),
       self.global_npm_cache.clone(),
@@ -524,59 +560,14 @@ impl CliNpmResolver for ManagedCliNpmResolver {
     ))
   }
 
-  fn root_dir_url(&self) -> &Url {
-    self.fs_resolver.root_dir_url()
-  }
-
   fn as_inner(&self) -> InnerCliNpmResolverRef {
     InnerCliNpmResolverRef::Managed(self)
   }
 
-  fn node_modules_path(&self) -> Option<PathBuf> {
+  fn root_node_modules_path(&self) -> Option<PathBuf> {
     self.fs_resolver.node_modules_path()
   }
 
-  /// Checks if the provided package req's folder is cached.
-  fn is_pkg_req_folder_cached(&self, req: &PackageReq) -> bool {
-    self
-      .resolve_pkg_id_from_pkg_req(req)
-      .ok()
-      .and_then(|id| self.fs_resolver.package_folder(&id).ok())
-      .map(|folder| folder.exists())
-      .unwrap_or(false)
-  }
-
-  fn resolve_npm_for_deno_graph(
-    &self,
-    pkg_req: &PackageReq,
-  ) -> NpmPackageReqResolution {
-    let result = self.resolution.resolve_pkg_req_as_pending(pkg_req);
-    match result {
-      Ok(nv) => NpmPackageReqResolution::Ok(nv),
-      Err(err) => {
-        if self.api.mark_force_reload() {
-          log::debug!("Restarting npm specifier resolution to check for new registry information. Error: {:#}", err);
-          NpmPackageReqResolution::ReloadRegistryInfo(err.into())
-        } else {
-          NpmPackageReqResolution::Err(err.into())
-        }
-      }
-    }
-  }
-
-  fn resolve_pkg_nv_ref_from_pkg_req_ref(
-    &self,
-    req_ref: &NpmPackageReqReference,
-  ) -> Result<NpmPackageNvReference, PackageReqNotFoundError> {
-    let pkg_nv = self
-      .resolve_pkg_id_from_pkg_req(req_ref.req())
-      .map(|id| id.nv)?;
-    Ok(NpmPackageNvReference::new(PackageNvReference {
-      nv: pkg_nv,
-      sub_path: req_ref.sub_path().map(|s| s.to_string()),
-    }))
-  }
-
   /// Resolve the root folder of the package the provided specifier is in.
   ///
   /// This will error when the provided specifier is not in an npm package.
@@ -601,19 +592,12 @@ impl CliNpmResolver for ManagedCliNpmResolver {
   fn resolve_pkg_folder_from_deno_module_req(
     &self,
     req: &PackageReq,
+    _referrer: &ModuleSpecifier,
   ) -> Result<PathBuf, AnyError> {
     let pkg_id = self.resolve_pkg_id_from_pkg_req(req)?;
     self.resolve_pkg_folder_from_pkg_id(&pkg_id)
   }
 
-  fn resolve_pkg_folder_from_deno_module(
-    &self,
-    nv: &PackageNv,
-  ) -> Result<PathBuf, AnyError> {
-    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(nv)?;
-    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
-  }
-
   /// Gets the state of npm for the process.
   fn get_npm_process_state(&self) -> String {
     serde_json::to_string(&NpmProcessState {
@@ -629,7 +613,20 @@ impl CliNpmResolver for ManagedCliNpmResolver {
     .unwrap()
   }
 
-  fn package_reqs(&self) -> HashMap<PackageReq, PackageNv> {
-    self.resolution.package_reqs()
+  fn check_state_hash(&self) -> Option<u64> {
+    // We could go further and check all the individual
+    // npm packages, but that's probably overkill.
+    let mut package_reqs = self
+      .resolution
+      .package_reqs()
+      .into_iter()
+      .collect::<Vec<_>>();
+    package_reqs.sort_by(|a, b| a.0.cmp(&b.0)); // determinism
+    let mut hasher = FastInsecureHasher::new();
+    for (pkg_req, pkg_nv) in package_reqs {
+      hasher.write_hashable(&pkg_req);
+      hasher.write_hashable(&pkg_nv);
+    }
+    Some(hasher.finish())
   }
 }

cli/npm/managed/resolvers/common.rs

@@ -149,25 +149,3 @@ pub async fn cache_packages(
   }
   Ok(())
 }
-
-/// Gets the corresponding @types package for the provided package name.
-pub fn types_package_name(package_name: &str) -> String {
-  debug_assert!(!package_name.starts_with("@types/"));
-  // Scoped packages will get two underscores for each slash
-  // https://github.com/DefinitelyTyped/DefinitelyTyped/tree/15f1ece08f7b498f4b9a2147c2a46e94416ca777#what-about-scoped-packages
-  format!("@types/{}", package_name.replace('/', "__"))
-}
-
-#[cfg(test)]
-mod test {
-  use super::types_package_name;
-
-  #[test]
-  fn test_types_package_name() {
-    assert_eq!(types_package_name("name"), "@types/name");
-    assert_eq!(
-      types_package_name("@scoped/package"),
-      "@types/@scoped__package"
-    );
-  }
-}

cli/npm/managed/resolvers/global.rs

@@ -20,10 +20,10 @@ use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 
+use super::super::super::common::types_package_name;
 use super::super::cache::NpmCache;
 use super::super::resolution::NpmResolution;
 use super::common::cache_packages;
-use super::common::types_package_name;
 use super::common::NpmPackageFsResolver;
 use super::common::RegistryReadPermissionChecker;
 

cli/npm/managed/resolvers/local.rs

@@ -45,9 +45,9 @@ use crate::npm::cache_dir::mixed_case_package_name_encode;
 use crate::util::fs::copy_dir_recursive;
 use crate::util::fs::hard_link_dir_recursive;
 
+use super::super::super::common::types_package_name;
 use super::super::cache::NpmCache;
 use super::super::resolution::NpmResolution;
-use super::common::types_package_name;
 use super::common::NpmPackageFsResolver;
 use super::common::RegistryReadPermissionChecker;
 

cli/npm/mod.rs

@@ -1,21 +1,15 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
 mod cache_dir;
+mod common;
 mod managed;
 
-use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
 
 use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
-use deno_core::url::Url;
-use deno_graph::NpmPackageReqResolution;
-use deno_npm::resolution::PackageReqNotFoundError;
 use deno_runtime::deno_node::NpmResolver;
-use deno_semver::npm::NpmPackageNvReference;
-use deno_semver::npm::NpmPackageReqReference;
-use deno_semver::package::PackageNv;
 use deno_semver::package::PackageReq;
 
 pub use self::cache_dir::NpmCacheDir;
@@ -64,8 +58,6 @@ pub trait CliNpmResolver: NpmResolver {
 
   fn clone_snapshotted(&self) -> Arc<dyn CliNpmResolver>;
 
-  fn root_dir_url(&self) -> &Url;
-
   fn as_inner(&self) -> InnerCliNpmResolverRef;
 
   fn as_managed(&self) -> Option<&ManagedCliNpmResolver> {
@@ -75,27 +67,16 @@ pub trait CliNpmResolver: NpmResolver {
     }
   }
 
-  fn node_modules_path(&self) -> Option<PathBuf>;
+  fn as_byonm(&self) -> Option<&ByonmCliNpmResolver> {
+    match self.as_inner() {
+      InnerCliNpmResolverRef::Managed(_) => None,
+      InnerCliNpmResolverRef::Byonm(inner) => Some(inner),
+    }
+  }
 
-  /// Checks if the provided package req's folder is cached.
-  fn is_pkg_req_folder_cached(&self, req: &PackageReq) -> bool;
-
-  /// Resolves a package requirement for deno graph. This should only be
-  /// called by deno_graph's NpmResolver or for resolving packages in
-  /// a package.json
-  fn resolve_npm_for_deno_graph(
-    &self,
-    pkg_req: &PackageReq,
-  ) -> NpmPackageReqResolution;
-
-  fn resolve_pkg_nv_ref_from_pkg_req_ref(
-    &self,
-    req_ref: &NpmPackageReqReference,
-  ) -> Result<NpmPackageNvReference, PackageReqNotFoundError>;
+  fn root_node_modules_path(&self) -> Option<PathBuf>;
 
   /// Resolve the root folder of the package the provided specifier is in.
-  ///
-  /// This will error when the provided specifier is not in an npm package.
   fn resolve_pkg_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
@@ -104,19 +85,15 @@ pub trait CliNpmResolver: NpmResolver {
   fn resolve_pkg_folder_from_deno_module_req(
     &self,
     req: &PackageReq,
-  ) -> Result<PathBuf, AnyError>;
-
-  fn resolve_pkg_folder_from_deno_module(
-    &self,
-    nv: &PackageNv,
+    referrer: &ModuleSpecifier,
   ) -> Result<PathBuf, AnyError>;
 
   /// Gets the state of npm for the process.
   fn get_npm_process_state(&self) -> String;
 
-  // todo(#18967): should instead return a hash state of the resolver
-  // or perhaps this could be non-BYONM only and byonm always runs deno check
-  fn package_reqs(&self) -> HashMap<PackageReq, PackageNv>;
+  /// Returns a hash returning the state of the npm resolver
+  /// or `None` if the state currently can't be determined.
+  fn check_state_hash(&self) -> Option<u64>;
 }
 
 // todo(#18967): implement this