refactor: break up ProcState (#18707)

1. Breaks up functionality within `ProcState` into several other structs
to break out the responsibilities (`ProcState` is only a data struct
now).
2. Moves towards being able to inject dependencies more easily and have
functionality only require what it needs.
3. Exposes `Arc<T>` around the "service structs" instead of it being
embedded within them. The idea behind embedding them was to reduce the
verbosity of needing to pass around `Arc<...>`, but I don't think it was
exactly working and as we move more of these structs to be more
injectable I don't think the extra verbosity will be a big deal.

cli/npm/resolvers/common.rs

@@ -3,6 +3,7 @@
 use std::io::ErrorKind;
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use async_trait::async_trait;
 use deno_ast::ModuleSpecifier;
@@ -26,11 +27,10 @@ pub trait NpmPackageFsResolver: Send + Sync {
   /// The local node_modules folder if it is applicable to the implementation.
   fn node_modules_path(&self) -> Option<PathBuf>;
 
-  fn resolve_package_folder_from_deno_module(
+  fn package_folder(
     &self,
-    id: &NpmPackageId,
+    package_id: &NpmPackageId,
   ) -> Result<PathBuf, AnyError>;
-
   fn resolve_package_folder_from_package(
     &self,
     name: &str,
@@ -43,8 +43,6 @@ pub trait NpmPackageFsResolver: Send + Sync {
     specifier: &ModuleSpecifier,
   ) -> Result<PathBuf, AnyError>;
 
-  fn package_size(&self, package_id: &NpmPackageId) -> Result<u64, AnyError>;
-
   async fn cache_packages(&self) -> Result<(), AnyError>;
 
   fn ensure_read_permission(
@@ -57,7 +55,7 @@ pub trait NpmPackageFsResolver: Send + Sync {
 /// Caches all the packages in parallel.
 pub async fn cache_packages(
   mut packages: Vec<NpmResolutionPackage>,
-  cache: &NpmCache,
+  cache: &Arc<NpmCache>,
   registry_url: &Url,
 ) -> Result<(), AnyError> {
   let sync_download = should_sync_download();

cli/npm/resolvers/global.rs

@@ -4,6 +4,7 @@
 
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use async_trait::async_trait;
 use deno_ast::ModuleSpecifier;
@@ -25,18 +26,18 @@ use super::common::types_package_name;
 use super::common::NpmPackageFsResolver;
 
 /// Resolves packages from the global npm cache.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct GlobalNpmPackageResolver {
-  cache: NpmCache,
-  resolution: NpmResolution,
+  cache: Arc<NpmCache>,
+  resolution: Arc<NpmResolution>,
   registry_url: Url,
 }
 
 impl GlobalNpmPackageResolver {
   pub fn new(
-    cache: NpmCache,
+    cache: Arc<NpmCache>,
     registry_url: Url,
-    resolution: NpmResolution,
+    resolution: Arc<NpmResolution>,
   ) -> Self {
     Self {
       cache,
@@ -45,16 +46,6 @@ impl GlobalNpmPackageResolver {
     }
   }
 
-  fn package_folder(&self, id: &NpmPackageId) -> PathBuf {
-    let folder_id = self
-      .resolution
-      .resolve_package_cache_folder_id_from_id(id)
-      .unwrap();
-    self
-      .cache
-      .package_folder_for_id(&folder_id, &self.registry_url)
-  }
-
   fn resolve_types_package(
     &self,
     package_name: &str,
@@ -77,11 +68,16 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
     None
   }
 
-  fn resolve_package_folder_from_deno_module(
-    &self,
-    id: &NpmPackageId,
-  ) -> Result<PathBuf, AnyError> {
-    Ok(self.package_folder(id))
+  fn package_folder(&self, id: &NpmPackageId) -> Result<PathBuf, AnyError> {
+    let folder_id = self
+      .resolution
+      .resolve_package_cache_folder_id_from_id(id)
+      .unwrap();
+    Ok(
+      self
+        .cache
+        .package_folder_for_id(&folder_id, &self.registry_url),
+    )
   }
 
   fn resolve_package_folder_from_package(
@@ -106,7 +102,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
         .resolution
         .resolve_package_from_package(name, &referrer_pkg_id)?
     };
-    Ok(self.package_folder(&pkg.pkg_id))
+    self.package_folder(&pkg.pkg_id)
   }
 
   fn resolve_package_folder_from_specifier(
@@ -124,11 +120,6 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
     )
   }
 
-  fn package_size(&self, id: &NpmPackageId) -> Result<u64, AnyError> {
-    let package_folder = self.package_folder(id);
-    Ok(crate::util::fs::dir_size(&package_folder)?)
-  }
-
   async fn cache_packages(&self) -> Result<(), AnyError> {
     cache_packages_in_resolver(self).await
   }

cli/npm/resolvers/local.rs

@@ -8,6 +8,7 @@ use std::collections::VecDeque;
 use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use crate::util::fs::symlink_dir;
 use crate::util::fs::LaxSingleProcessFsFlag;
@@ -41,11 +42,11 @@ use super::common::NpmPackageFsResolver;
 
 /// Resolver that creates a local node_modules directory
 /// and resolves packages from it.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct LocalNpmPackageResolver {
-  cache: NpmCache,
+  cache: Arc<NpmCache>,
   progress_bar: ProgressBar,
-  resolution: NpmResolution,
+  resolution: Arc<NpmResolution>,
   registry_url: Url,
   root_node_modules_path: PathBuf,
   root_node_modules_url: Url,
@@ -53,11 +54,11 @@ pub struct LocalNpmPackageResolver {
 
 impl LocalNpmPackageResolver {
   pub fn new(
-    cache: NpmCache,
+    cache: Arc<NpmCache>,
     progress_bar: ProgressBar,
     registry_url: Url,
     node_modules_folder: PathBuf,
-    resolution: NpmResolution,
+    resolution: Arc<NpmResolution>,
   ) -> Self {
     Self {
       cache,
@@ -103,11 +104,19 @@ impl LocalNpmPackageResolver {
     // it's within the directory, so use it
     specifier.to_file_path().ok()
   }
+}
 
-  fn get_package_id_folder(
-    &self,
-    id: &NpmPackageId,
-  ) -> Result<PathBuf, AnyError> {
+#[async_trait]
+impl NpmPackageFsResolver for LocalNpmPackageResolver {
+  fn root_dir_url(&self) -> &Url {
+    &self.root_node_modules_url
+  }
+
+  fn node_modules_path(&self) -> Option<PathBuf> {
+    Some(self.root_node_modules_path.clone())
+  }
+
+  fn package_folder(&self, id: &NpmPackageId) -> Result<PathBuf, AnyError> {
     match self.resolution.resolve_package_cache_folder_id_from_id(id) {
       // package is stored at:
       // node_modules/.deno/<package_cache_folder_id_folder_name>/node_modules/<package_name>
@@ -125,24 +134,6 @@ impl LocalNpmPackageResolver {
       ),
     }
   }
-}
-
-#[async_trait]
-impl NpmPackageFsResolver for LocalNpmPackageResolver {
-  fn root_dir_url(&self) -> &Url {
-    &self.root_node_modules_url
-  }
-
-  fn node_modules_path(&self) -> Option<PathBuf> {
-    Some(self.root_node_modules_path.clone())
-  }
-
-  fn resolve_package_folder_from_deno_module(
-    &self,
-    node_id: &NpmPackageId,
-  ) -> Result<PathBuf, AnyError> {
-    self.get_package_id_folder(node_id)
-  }
 
   fn resolve_package_folder_from_package(
     &self,
@@ -198,12 +189,6 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
     Ok(package_root_path)
   }
 
-  fn package_size(&self, id: &NpmPackageId) -> Result<u64, AnyError> {
-    let package_folder_path = self.get_package_id_folder(id)?;
-
-    Ok(crate::util::fs::dir_size(&package_folder_path)?)
-  }
-
   async fn cache_packages(&self) -> Result<(), AnyError> {
     sync_resolution_with_fs(
       &self.resolution.snapshot(),
@@ -231,7 +216,7 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
 /// Creates a pnpm style folder structure.
 async fn sync_resolution_with_fs(
   snapshot: &NpmResolutionSnapshot,
-  cache: &NpmCache,
+  cache: &Arc<NpmCache>,
   progress_bar: &ProgressBar,
   registry_url: &Url,
   root_node_modules_dir_path: &Path,

cli/npm/resolvers/mod.rs

@@ -47,10 +47,9 @@ pub struct NpmProcessState {
 }
 
 /// Brings together the npm resolution with the file system.
-#[derive(Clone)]
 pub struct NpmPackageResolver {
   fs_resolver: Arc<dyn NpmPackageFsResolver>,
-  resolution: NpmResolution,
+  resolution: Arc<NpmResolution>,
   maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
 }
 
@@ -66,7 +65,7 @@ impl std::fmt::Debug for NpmPackageResolver {
 
 impl NpmPackageResolver {
   pub fn new(
-    resolution: NpmResolution,
+    resolution: Arc<NpmResolution>,
     fs_resolver: Arc<dyn NpmPackageFsResolver>,
     maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
   ) -> Self {
@@ -108,9 +107,7 @@ impl NpmPackageResolver {
     &self,
     pkg_id: &NpmPackageId,
   ) -> Result<PathBuf, AnyError> {
-    let path = self
-      .fs_resolver
-      .resolve_package_folder_from_deno_module(pkg_id)?;
+    let path = self.fs_resolver.package_folder(pkg_id)?;
     let path = canonicalize_path_maybe_not_exists(&path)?;
     log::debug!(
       "Resolved package folder of {} to {}",
@@ -157,7 +154,8 @@ impl NpmPackageResolver {
     &self,
     package_id: &NpmPackageId,
   ) -> Result<u64, AnyError> {
-    self.fs_resolver.package_size(package_id)
+    let package_folder = self.fs_resolver.package_folder(package_id)?;
+    Ok(crate::util::fs::dir_size(&package_folder)?)
   }
 
   /// Gets if the provided specifier is in an npm package.
@@ -239,9 +237,17 @@ impl NpmPackageResolver {
     self.fs_resolver.cache_packages().await?;
     Ok(())
   }
+
+  pub fn as_require_npm_resolver(
+    self: &Arc<Self>,
+  ) -> RequireNpmPackageResolver {
+    RequireNpmPackageResolver(self.clone())
+  }
 }
 
-impl RequireNpmResolver for NpmPackageResolver {
+pub struct RequireNpmPackageResolver(Arc<NpmPackageResolver>);
+
+impl RequireNpmResolver for RequireNpmPackageResolver {
   fn resolve_package_folder_from_package(
     &self,
     specifier: &str,
@@ -249,7 +255,9 @@ impl RequireNpmResolver for NpmPackageResolver {
     mode: NodeResolutionMode,
   ) -> Result<PathBuf, AnyError> {
     let referrer = path_to_specifier(referrer)?;
-    self.resolve_package_folder_from_package(specifier, &referrer, mode)
+    self
+      .0
+      .resolve_package_folder_from_package(specifier, &referrer, mode)
   }
 
   fn resolve_package_folder_from_path(
@@ -257,7 +265,7 @@ impl RequireNpmResolver for NpmPackageResolver {
     path: &Path,
   ) -> Result<PathBuf, AnyError> {
     let specifier = path_to_specifier(path)?;
-    self.resolve_package_folder_from_specifier(&specifier)
+    self.0.resolve_package_folder_from_specifier(&specifier)
   }
 
   fn in_npm_package(&self, path: &Path) -> bool {
@@ -267,6 +275,7 @@ impl RequireNpmResolver for NpmPackageResolver {
         Err(_) => return false,
       };
     self
+      .0
       .resolve_package_folder_from_specifier(&specifier)
       .is_ok()
   }
@@ -276,15 +285,15 @@ impl RequireNpmResolver for NpmPackageResolver {
     permissions: &mut dyn NodePermissions,
     path: &Path,
   ) -> Result<(), AnyError> {
-    self.fs_resolver.ensure_read_permission(permissions, path)
+    self.0.fs_resolver.ensure_read_permission(permissions, path)
   }
 }
 
 pub fn create_npm_fs_resolver(
-  cache: NpmCache,
+  cache: Arc<NpmCache>,
   progress_bar: &ProgressBar,
   registry_url: Url,
-  resolution: NpmResolution,
+  resolution: Arc<NpmResolution>,
   maybe_node_modules_path: Option<PathBuf>,
 ) -> Arc<dyn NpmPackageFsResolver> {
   match maybe_node_modules_path {