From a615eb3b56545960ec9684991442dd34a8b2abfc Mon Sep 17 00:00:00 2001
From: David Sherret <dsherret@users.noreply.github.com>
Date: Fri, 21 Apr 2023 21:02:46 -0400
Subject: refactor(node): move most of cli/node to ext/node (#18797)

This is just a straight refactor and I didn't do any cleanup in
ext/node. After this PR we can start to clean it up and make things
private that don't need to be public anymore.
---
 cli/npm/resolvers/mod.rs | 91 +++++++++++++++++++++---------------------------
 1 file changed, 40 insertions(+), 51 deletions(-)

(limited to 'cli/npm/resolvers')

diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index f693d3d23..8b871beaf 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -20,10 +20,12 @@ use deno_npm::resolution::SerializedNpmResolutionSnapshot;
 use deno_npm::NpmPackageId;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
+use deno_runtime::deno_node::NpmResolver;
 use deno_runtime::deno_node::PathClean;
-use deno_runtime::deno_node::RequireNpmResolver;
 use deno_semver::npm::NpmPackageNv;
+use deno_semver::npm::NpmPackageNvReference;
 use deno_semver::npm::NpmPackageReq;
+use deno_semver::npm::NpmPackageReqReference;
 use global::GlobalNpmPackageResolver;
 use serde::Deserialize;
 use serde::Serialize;
@@ -45,13 +47,13 @@ pub struct NpmProcessState {
 }
 
 /// Brings together the npm resolution with the file system.
-pub struct NpmPackageResolver {
+pub struct CliNpmResolver {
   fs_resolver: Arc<dyn NpmPackageFsResolver>,
   resolution: Arc<NpmResolution>,
   maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
 }
 
-impl std::fmt::Debug for NpmPackageResolver {
+impl std::fmt::Debug for CliNpmResolver {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     f.debug_struct("NpmPackageResolver")
       .field("fs_resolver", &"<omitted>")
@@ -61,7 +63,7 @@ impl std::fmt::Debug for NpmPackageResolver {
   }
 }
 
-impl NpmPackageResolver {
+impl CliNpmResolver {
   pub fn new(
     resolution: Arc<NpmResolution>,
     fs_resolver: Arc<dyn NpmPackageFsResolver>,
@@ -85,15 +87,6 @@ impl NpmPackageResolver {
     self.resolution.resolve_pkg_id_from_pkg_req(req)
   }
 
-  /// Resolves an npm package folder path from a Deno module.
-  pub fn resolve_package_folder_from_deno_module(
-    &self,
-    pkg_nv: &NpmPackageNv,
-  ) -> Result<PathBuf, AnyError> {
-    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(pkg_nv)?;
-    self.resolve_pkg_folder_from_deno_module_at_pkg_id(&pkg_id)
-  }
-
   fn resolve_pkg_folder_from_deno_module_at_pkg_id(
     &self,
     pkg_id: &NpmPackageId,
@@ -108,20 +101,6 @@ impl NpmPackageResolver {
     Ok(path)
   }
 
-  /// Resolves an npm package folder path from an npm package referrer.
-  pub fn resolve_package_folder_from_package(
-    &self,
-    name: &str,
-    referrer: &ModuleSpecifier,
-    mode: NodeResolutionMode,
-  ) -> Result<PathBuf, AnyError> {
-    let path = self
-      .fs_resolver
-      .resolve_package_folder_from_package(name, referrer, mode)?;
-    log::debug!("Resolved {} from {} to {}", name, referrer, path.display());
-    Ok(path)
-  }
-
   /// 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.
@@ -228,26 +207,20 @@ impl NpmPackageResolver {
     self.fs_resolver.cache_packages().await?;
     Ok(())
   }
-
-  pub fn as_require_npm_resolver(self: &Arc<Self>) -> CliRequireNpmResolver {
-    CliRequireNpmResolver(self.clone())
-  }
 }
 
-#[derive(Debug)]
-pub struct CliRequireNpmResolver(Arc<NpmPackageResolver>);
-
-impl RequireNpmResolver for CliRequireNpmResolver {
+impl NpmResolver for CliNpmResolver {
   fn resolve_package_folder_from_package(
     &self,
-    specifier: &str,
-    referrer: &std::path::Path,
+    name: &str,
+    referrer: &ModuleSpecifier,
     mode: NodeResolutionMode,
   ) -> Result<PathBuf, AnyError> {
-    let referrer = path_to_specifier(referrer)?;
-    self
-      .0
-      .resolve_package_folder_from_package(specifier, &referrer, mode)
+    let path = self
+      .fs_resolver
+      .resolve_package_folder_from_package(name, referrer, mode)?;
+    log::debug!("Resolved {} from {} to {}", name, referrer, path.display());
+    Ok(path)
   }
 
   fn resolve_package_folder_from_path(
@@ -255,18 +228,34 @@ impl RequireNpmResolver for CliRequireNpmResolver {
     path: &Path,
   ) -> Result<PathBuf, AnyError> {
     let specifier = path_to_specifier(path)?;
-    self.0.resolve_package_folder_from_specifier(&specifier)
+    self.resolve_package_folder_from_specifier(&specifier)
+  }
+
+  fn resolve_package_folder_from_deno_module(
+    &self,
+    pkg_nv: &NpmPackageNv,
+  ) -> Result<PathBuf, AnyError> {
+    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(pkg_nv)?;
+    self.resolve_pkg_folder_from_deno_module_at_pkg_id(&pkg_id)
+  }
+
+  fn resolve_pkg_id_from_pkg_req(
+    &self,
+    req: &NpmPackageReq,
+  ) -> Result<NpmPackageId, PackageReqNotFoundError> {
+    self.resolution.resolve_pkg_id_from_pkg_req(req)
+  }
+
+  fn resolve_nv_ref_from_pkg_req_ref(
+    &self,
+    req_ref: &NpmPackageReqReference,
+  ) -> Result<NpmPackageNvReference, PackageReqNotFoundError> {
+    self.resolution.resolve_nv_ref_from_pkg_req_ref(req_ref)
   }
 
-  fn in_npm_package(&self, path: &Path) -> bool {
-    let specifier =
-      match ModuleSpecifier::from_file_path(path.to_path_buf().clean()) {
-        Ok(p) => p,
-        Err(_) => return false,
-      };
+  fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
     self
-      .0
-      .resolve_package_folder_from_specifier(&specifier)
+      .resolve_package_folder_from_specifier(specifier)
       .is_ok()
   }
 
@@ -275,7 +264,7 @@ impl RequireNpmResolver for CliRequireNpmResolver {
     permissions: &mut dyn NodePermissions,
     path: &Path,
   ) -> Result<(), AnyError> {
-    self.0.fs_resolver.ensure_read_permission(permissions, path)
+    self.fs_resolver.ensure_read_permission(permissions, path)
   }
 }
 
-- 
cgit v1.2.3