refactor: decouple node resolution from deno_core (#24724)

cli/npm/byonm.rs

@@ -11,14 +11,18 @@ use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_package_json::PackageJsonDepValue;
 use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::errors::PackageFolderResolveError;
-use deno_runtime::deno_node::errors::PackageFolderResolveIoError;
-use deno_runtime::deno_node::errors::PackageNotFoundError;
-use deno_runtime::deno_node::load_pkg_json;
+use deno_runtime::deno_node::DenoPkgJsonFsAdapter;
 use deno_runtime::deno_node::NodePermissions;
-use deno_runtime::deno_node::NpmResolver;
+use deno_runtime::deno_node::NodeRequireResolver;
+use deno_runtime::deno_node::NpmProcessStateProvider;
 use deno_runtime::deno_node::PackageJson;
 use deno_semver::package::PackageReq;
+use node_resolver::errors::PackageFolderResolveError;
+use node_resolver::errors::PackageFolderResolveIoError;
+use node_resolver::errors::PackageJsonLoadError;
+use node_resolver::errors::PackageNotFoundError;
+use node_resolver::load_pkg_json;
+use node_resolver::NpmResolver;
 
 use crate::args::NpmProcessState;
 use crate::args::NpmProcessStateKind;
@@ -49,6 +53,15 @@ pub struct ByonmCliNpmResolver {
   root_node_modules_dir: Option<PathBuf>,
 }
 
+impl ByonmCliNpmResolver {
+  fn load_pkg_json(
+    &self,
+    path: &Path,
+  ) -> Result<Option<Arc<PackageJson>>, PackageJsonLoadError> {
+    load_pkg_json(&DenoPkgJsonFsAdapter(self.fs.as_ref()), path)
+  }
+}
+
 impl ByonmCliNpmResolver {
   /// Finds the ancestor package.json that contains the specified dependency.
   pub fn find_ancestor_package_json_with_dep(
@@ -60,9 +73,7 @@ impl ByonmCliNpmResolver {
     let mut current_folder = referrer_path.parent()?;
     loop {
       let pkg_json_path = current_folder.join("package.json");
-      if let Ok(Some(pkg_json)) =
-        load_pkg_json(self.fs.as_ref(), &pkg_json_path)
-      {
+      if let Ok(Some(pkg_json)) = self.load_pkg_json(&pkg_json_path) {
         if let Some(deps) = &pkg_json.dependencies {
           if deps.contains_key(dep_name) {
             return Some(pkg_json);
@@ -119,9 +130,7 @@ impl ByonmCliNpmResolver {
       let mut current_path = file_path.as_path();
       while let Some(dir_path) = current_path.parent() {
         let package_json_path = dir_path.join("package.json");
-        if let Some(pkg_json) =
-          load_pkg_json(self.fs.as_ref(), &package_json_path)?
-        {
+        if let Some(pkg_json) = self.load_pkg_json(&package_json_path)? {
           if let Some(alias) =
             resolve_alias_from_pkg_json(req, pkg_json.as_ref())
           {
@@ -136,9 +145,7 @@ impl ByonmCliNpmResolver {
     if let Some(root_node_modules_dir) = &self.root_node_modules_dir {
       let root_pkg_json_path =
         root_node_modules_dir.parent().unwrap().join("package.json");
-      if let Some(pkg_json) =
-        load_pkg_json(self.fs.as_ref(), &root_pkg_json_path)?
-      {
+      if let Some(pkg_json) = self.load_pkg_json(&root_pkg_json_path)? {
         if let Some(alias) = resolve_alias_from_pkg_json(req, pkg_json.as_ref())
         {
           return Ok((pkg_json, alias));
@@ -158,17 +165,6 @@ impl ByonmCliNpmResolver {
 }
 
 impl NpmResolver for ByonmCliNpmResolver {
-  fn get_npm_process_state(&self) -> String {
-    serde_json::to_string(&NpmProcessState {
-      kind: NpmProcessStateKind::Byonm,
-      local_node_modules_path: self
-        .root_node_modules_dir
-        .as_ref()
-        .map(|p| p.to_string_lossy().to_string()),
-    })
-    .unwrap()
-  }
-
   fn resolve_package_folder_from_package(
     &self,
     name: &str,
@@ -226,7 +222,9 @@ impl NpmResolver for ByonmCliNpmResolver {
         .to_ascii_lowercase()
         .contains("/node_modules/")
   }
+}
 
+impl NodeRequireResolver for ByonmCliNpmResolver {
   fn ensure_read_permission(
     &self,
     permissions: &mut dyn NodePermissions,
@@ -242,11 +240,34 @@ impl NpmResolver for ByonmCliNpmResolver {
   }
 }
 
+impl NpmProcessStateProvider for ByonmCliNpmResolver {
+  fn get_npm_process_state(&self) -> String {
+    serde_json::to_string(&NpmProcessState {
+      kind: NpmProcessStateKind::Byonm,
+      local_node_modules_path: self
+        .root_node_modules_dir
+        .as_ref()
+        .map(|p| p.to_string_lossy().to_string()),
+    })
+    .unwrap()
+  }
+}
+
 impl CliNpmResolver for ByonmCliNpmResolver {
   fn into_npm_resolver(self: Arc<Self>) -> Arc<dyn NpmResolver> {
     self
   }
 
+  fn into_require_resolver(self: Arc<Self>) -> Arc<dyn NodeRequireResolver> {
+    self
+  }
+
+  fn into_process_state_provider(
+    self: Arc<Self>,
+  ) -> Arc<dyn NpmProcessStateProvider> {
+    self
+  }
+
   fn clone_snapshotted(&self) -> Arc<dyn CliNpmResolver> {
     Arc::new(Self {
       fs: self.fs.clone(),

cli/npm/managed/mod.rs

@@ -20,12 +20,14 @@ use deno_npm::NpmPackageId;
 use deno_npm::NpmResolutionPackage;
 use deno_npm::NpmSystemInfo;
 use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::errors::PackageFolderResolveError;
-use deno_runtime::deno_node::errors::PackageFolderResolveIoError;
 use deno_runtime::deno_node::NodePermissions;
-use deno_runtime::deno_node::NpmResolver;
+use deno_runtime::deno_node::NodeRequireResolver;
+use deno_runtime::deno_node::NpmProcessStateProvider;
 use deno_semver::package::PackageNv;
 use deno_semver::package::PackageReq;
+use node_resolver::errors::PackageFolderResolveError;
+use node_resolver::errors::PackageFolderResolveIoError;
+use node_resolver::NpmResolver;
 use resolution::AddPkgReqsResult;
 
 use crate::args::CliLockfile;
@@ -531,14 +533,6 @@ fn npm_process_state(
 }
 
 impl NpmResolver for ManagedCliNpmResolver {
-  /// Gets the state of npm for the process.
-  fn get_npm_process_state(&self) -> String {
-    npm_process_state(
-      self.resolution.serialized_valid_snapshot(),
-      self.fs_resolver.node_modules_path().map(|p| p.as_path()),
-    )
-  }
-
   fn resolve_package_folder_from_package(
     &self,
     name: &str,
@@ -563,7 +557,9 @@ impl NpmResolver for ManagedCliNpmResolver {
     debug_assert!(root_dir_url.as_str().ends_with('/'));
     specifier.as_ref().starts_with(root_dir_url.as_str())
   }
+}
 
+impl NodeRequireResolver for ManagedCliNpmResolver {
   fn ensure_read_permission(
     &self,
     permissions: &mut dyn NodePermissions,
@@ -573,11 +569,30 @@ impl NpmResolver for ManagedCliNpmResolver {
   }
 }
 
+impl NpmProcessStateProvider for ManagedCliNpmResolver {
+  fn get_npm_process_state(&self) -> String {
+    npm_process_state(
+      self.resolution.serialized_valid_snapshot(),
+      self.fs_resolver.node_modules_path().map(|p| p.as_path()),
+    )
+  }
+}
+
 impl CliNpmResolver for ManagedCliNpmResolver {
   fn into_npm_resolver(self: Arc<Self>) -> Arc<dyn NpmResolver> {
     self
   }
 
+  fn into_require_resolver(self: Arc<Self>) -> Arc<dyn NodeRequireResolver> {
+    self
+  }
+
+  fn into_process_state_provider(
+    self: Arc<Self>,
+  ) -> Arc<dyn NpmProcessStateProvider> {
+    self
+  }
+
   fn clone_snapshotted(&self) -> Arc<dyn CliNpmResolver> {
     // create a new snapshotted npm resolution and resolver
     let npm_resolution = Arc::new(NpmResolution::new(

cli/npm/managed/resolvers/common.rs

@@ -18,8 +18,8 @@ use deno_npm::NpmPackageCacheFolderId;
 use deno_npm::NpmPackageId;
 use deno_npm::NpmResolutionPackage;
 use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::errors::PackageFolderResolveError;
 use deno_runtime::deno_node::NodePermissions;
+use node_resolver::errors::PackageFolderResolveError;
 
 use crate::npm::managed::cache::TarballCache;
 

cli/npm/managed/resolvers/global.rs

@@ -14,10 +14,10 @@ use deno_npm::NpmPackageCacheFolderId;
 use deno_npm::NpmPackageId;
 use deno_npm::NpmSystemInfo;
 use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::errors::PackageFolderResolveError;
-use deno_runtime::deno_node::errors::PackageNotFoundError;
-use deno_runtime::deno_node::errors::ReferrerNotFoundError;
 use deno_runtime::deno_node::NodePermissions;
+use node_resolver::errors::PackageFolderResolveError;
+use node_resolver::errors::PackageNotFoundError;
+use node_resolver::errors::ReferrerNotFoundError;
 
 use super::super::cache::NpmCache;
 use super::super::cache::TarballCache;

cli/npm/managed/resolvers/local.rs

@@ -32,12 +32,12 @@ use deno_npm::NpmPackageId;
 use deno_npm::NpmResolutionPackage;
 use deno_npm::NpmSystemInfo;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node::errors::PackageFolderResolveError;
-use deno_runtime::deno_node::errors::PackageFolderResolveIoError;
-use deno_runtime::deno_node::errors::PackageNotFoundError;
-use deno_runtime::deno_node::errors::ReferrerNotFoundError;
 use deno_runtime::deno_node::NodePermissions;
 use deno_semver::package::PackageNv;
+use node_resolver::errors::PackageFolderResolveError;
+use node_resolver::errors::PackageFolderResolveIoError;
+use node_resolver::errors::PackageNotFoundError;
+use node_resolver::errors::ReferrerNotFoundError;
 use serde::Deserialize;
 use serde::Serialize;
 

cli/npm/mod.rs

@@ -13,10 +13,12 @@ use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_npm::registry::NpmPackageInfo;
-use deno_runtime::deno_node::NpmResolver;
+use deno_runtime::deno_node::NodeRequireResolver;
+use deno_runtime::deno_node::NpmProcessStateProvider;
 use deno_runtime::deno_permissions::PermissionsContainer;
 use deno_semver::package::PackageNv;
 use deno_semver::package::PackageReq;
+use node_resolver::NpmResolver;
 
 use crate::args::npm_registry_url;
 use crate::file_fetcher::FileFetcher;
@@ -63,6 +65,10 @@ pub enum InnerCliNpmResolverRef<'a> {
 
 pub trait CliNpmResolver: NpmResolver {
   fn into_npm_resolver(self: Arc<Self>) -> Arc<dyn NpmResolver>;
+  fn into_require_resolver(self: Arc<Self>) -> Arc<dyn NodeRequireResolver>;
+  fn into_process_state_provider(
+    self: Arc<Self>,
+  ) -> Arc<dyn NpmProcessStateProvider>;
 
   fn clone_snapshotted(&self) -> Arc<dyn CliNpmResolver>;