1 files changed, 34 insertions, 108 deletions

diff --git a/cli/factory.rs b/cli/factory.rs
index 8a58062c7..648d4a87d 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -29,15 +29,12 @@ use crate::module_loader::ModuleLoadPreparer;
 use crate::module_loader::NpmModuleLoader;
 use crate::node::CliCjsCodeAnalyzer;
 use crate::node::CliNodeCodeTranslator;
-use crate::npm::create_npm_fs_resolver;
-use crate::npm::CliNpmRegistryApi;
+use crate::npm::create_cli_npm_resolver;
 use crate::npm::CliNpmResolver;
-use crate::npm::ManagedCliNpmResolver;
-use crate::npm::NpmCache;
-use crate::npm::NpmCacheDir;
-use crate::npm::NpmPackageFsResolver;
-use crate::npm::NpmResolution;
-use crate::npm::PackageJsonDepsInstaller;
+use crate::npm::CliNpmResolverCreateOptions;
+use crate::npm::CliNpmResolverManagedCreateOptions;
+use crate::npm::CliNpmResolverManagedPackageJsonInstallerOption;
+use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::resolver::CliGraphResolver;
 use crate::resolver::CliGraphResolverOptions;
 use crate::standalone::DenoCompileBinaryWriter;
@@ -157,12 +154,8 @@ struct CliFactoryServices {
   module_load_preparer: Deferred<Arc<ModuleLoadPreparer>>,
   node_code_translator: Deferred<Arc<CliNodeCodeTranslator>>,
   node_resolver: Deferred<Arc<NodeResolver>>,
-  npm_api: Deferred<Arc<CliNpmRegistryApi>>,
-  npm_cache: Deferred<Arc<NpmCache>>,
   npm_resolver: Deferred<Arc<dyn CliNpmResolver>>,
-  npm_resolution: Deferred<Arc<NpmResolution>>,
   package_json_deps_provider: Deferred<Arc<PackageJsonDepsProvider>>,
-  package_json_deps_installer: Deferred<Arc<PackageJsonDepsInstaller>>,
   text_only_progress_bar: Deferred<ProgressBar>,
   type_checker: Deferred<Arc<TypeChecker>>,
   cjs_resolutions: Deferred<Arc<CjsResolutionStore>>,
@@ -294,47 +287,6 @@ impl CliFactory {
       .get_or_init(|| self.options.maybe_lockfile())
   }
 
-  pub fn npm_cache(&self) -> Result<&Arc<NpmCache>, AnyError> {
-    self.services.npm_cache.get_or_try_init(|| {
-      Ok(Arc::new(NpmCache::new(
-        NpmCacheDir::new(self.deno_dir()?.npm_folder_path()),
-        self.options.cache_setting(),
-        self.fs().clone(),
-        self.http_client().clone(),
-        self.text_only_progress_bar().clone(),
-      )))
-    })
-  }
-
-  pub fn npm_api(&self) -> Result<&Arc<CliNpmRegistryApi>, AnyError> {
-    self.services.npm_api.get_or_try_init(|| {
-      Ok(Arc::new(CliNpmRegistryApi::new(
-        CliNpmRegistryApi::default_url().to_owned(),
-        self.npm_cache()?.clone(),
-        self.http_client().clone(),
-        self.text_only_progress_bar().clone(),
-      )))
-    })
-  }
-
-  pub async fn npm_resolution(&self) -> Result<&Arc<NpmResolution>, AnyError> {
-    self
-      .services
-      .npm_resolution
-      .get_or_try_init_async(async {
-        let npm_api = self.npm_api()?;
-        Ok(Arc::new(NpmResolution::from_serialized(
-          npm_api.clone(),
-          self
-            .options
-            .resolve_npm_resolution_snapshot(npm_api)
-            .await?,
-          self.maybe_lockfile().as_ref().cloned(),
-        )))
-      })
-      .await
-  }
-
   pub async fn npm_resolver(
     &self,
   ) -> Result<&Arc<dyn CliNpmResolver>, AnyError> {
@@ -342,46 +294,39 @@ impl CliFactory {
       .services
       .npm_resolver
       .get_or_try_init_async(async {
-        let npm_resolution = self.npm_resolution().await?;
-        let fs = self.fs().clone();
-        let npm_fs_resolver = create_npm_fs_resolver(
-          fs.clone(),
-          self.npm_cache()?.clone(),
-          self.text_only_progress_bar(),
-          CliNpmRegistryApi::default_url().to_owned(),
-          npm_resolution.clone(),
-          self.options.node_modules_dir_path(),
-          self.options.npm_system_info(),
-        );
-        Ok(Arc::new(ManagedCliNpmResolver::new(
-          self.npm_api()?.clone(),
-          fs.clone(),
-          npm_resolution.clone(),
-          npm_fs_resolver,
-          self.maybe_lockfile().as_ref().cloned(),
-          self.package_json_deps_installer().await?.clone(),
-        )) as Arc<dyn CliNpmResolver>)
+        create_cli_npm_resolver(CliNpmResolverCreateOptions::Managed(CliNpmResolverManagedCreateOptions {
+          snapshot: match self.options.resolve_npm_resolution_snapshot()? {
+            Some(snapshot) => {
+              CliNpmResolverManagedSnapshotOption::Specified(Some(snapshot))
+            }
+            None => match self.maybe_lockfile() {
+              Some(lockfile) => {
+                CliNpmResolverManagedSnapshotOption::ResolveFromLockfile(
+                  lockfile.clone(),
+                )
+              }
+              None => CliNpmResolverManagedSnapshotOption::Specified(None),
+            },
+          },
+          maybe_lockfile: self.maybe_lockfile().as_ref().cloned(),
+          fs: self.fs().clone(),
+          http_client: self.http_client().clone(),
+          npm_global_cache_dir: self.deno_dir()?.npm_folder_path(),
+          cache_setting: self.options.cache_setting(),
+          text_only_progress_bar: self.text_only_progress_bar().clone(),
+          maybe_node_modules_path: self.options.node_modules_dir_path(),
+          package_json_installer:
+            CliNpmResolverManagedPackageJsonInstallerOption::ConditionalInstall(
+              self.package_json_deps_provider().clone(),
+            ),
+          npm_system_info: self.options.npm_system_info(),
+          npm_registry_url: crate::args::npm_registry_default_url().to_owned(),
+        }))
+        .await
       })
       .await
   }
 
-  pub async fn create_node_modules_npm_fs_resolver(
-    &self,
-    node_modules_dir_path: PathBuf,
-  ) -> Result<Arc<dyn NpmPackageFsResolver>, AnyError> {
-    Ok(create_npm_fs_resolver(
-      self.fs().clone(),
-      self.npm_cache()?.clone(),
-      self.text_only_progress_bar(),
-      CliNpmRegistryApi::default_url().to_owned(),
-      self.npm_resolution().await?.clone(),
-      // when an explicit path is provided here, it will create the
-      // local node_modules variant of an npm fs resolver
-      Some(node_modules_dir_path),
-      self.options.npm_system_info(),
-    ))
-  }
-
   pub fn package_json_deps_provider(&self) -> &Arc<PackageJsonDepsProvider> {
     self.services.package_json_deps_provider.get_or_init(|| {
       Arc::new(PackageJsonDepsProvider::new(
@@ -390,22 +335,6 @@ impl CliFactory {
     })
   }
 
-  pub async fn package_json_deps_installer(
-    &self,
-  ) -> Result<&Arc<PackageJsonDepsInstaller>, AnyError> {
-    self
-      .services
-      .package_json_deps_installer
-      .get_or_try_init_async(async {
-        Ok(Arc::new(PackageJsonDepsInstaller::new(
-          self.package_json_deps_provider().clone(),
-          self.npm_api()?.clone(),
-          self.npm_resolution().await?.clone(),
-        )))
-      })
-      .await
-  }
-
   pub async fn maybe_import_map(
     &self,
   ) -> Result<&Option<Arc<ImportMap>>, AnyError> {
@@ -616,9 +545,6 @@ impl CliFactory {
       self.file_fetcher()?,
       self.http_client(),
       self.deno_dir()?,
-      self.npm_api()?,
-      self.npm_cache()?,
-      self.npm_resolution().await?,
       self.npm_resolver().await?.as_ref(),
       self.options.npm_system_info(),
       self.package_json_deps_provider(),