refactor: decouple node resolution from deno_core (#24724)

Author: dsherret

Cargo.lock

@@ -21,6 +21,7 @@ members = [
   "ext/napi",
   "ext/net",
   "ext/node",
+  "ext/node_resolver",
   "ext/url",
   "ext/web",
   "ext/webgpu",
@@ -83,6 +84,7 @@ deno_webgpu = { version = "0.129.0", path = "./ext/webgpu" }
 deno_webidl = { version = "0.162.0", path = "./ext/webidl" }
 deno_websocket = { version = "0.167.0", path = "./ext/websocket" }
 deno_webstorage = { version = "0.157.0", path = "./ext/webstorage" }
+node_resolver = { version = "0.1.0", path = "./ext/node_resolver" }
 
 aes = "=0.8.3"
 anyhow = "1.0.57"

Cargo.toml

@@ -80,6 +80,7 @@ deno_task_shell = "=0.17.0"
 deno_terminal.workspace = true
 eszip = "=0.72.2"
 napi_sym.workspace = true
+node_resolver.workspace = true
 
 async-trait.workspace = true
 base32.workspace = true

cli/Cargo.toml

@@ -820,9 +820,7 @@ impl CliOptions {
       WorkspaceDiscoverOptions {
         fs: Default::default(), // use real fs
         deno_json_cache: None,
-        pkg_json_cache: Some(
-          &deno_runtime::deno_node::PackageJsonThreadLocalCache,
-        ),
+        pkg_json_cache: Some(&node_resolver::PackageJsonThreadLocalCache),
         workspace_cache: None,
         config_parse_options,
         additional_config_file_names,

cli/args/mod.rs

@@ -62,13 +62,14 @@ use deno_core::futures::FutureExt;
 use deno_core::FeatureChecker;
 
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node::analyze::NodeCodeTranslator;
+use deno_runtime::deno_node::DenoFsNodeResolverEnv;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::rustls::RootCertStore;
 use deno_runtime::deno_tls::RootCertStoreProvider;
 use deno_runtime::deno_web::BlobStore;
 use deno_runtime::inspector_server::InspectorServer;
 use log::warn;
+use node_resolver::analyze::NodeCodeTranslator;
 use once_cell::sync::OnceCell;
 use std::future::Future;
 use std::sync::Arc;
@@ -553,7 +554,7 @@ impl CliFactory {
       .get_or_try_init_async(
         async {
           Ok(Arc::new(NodeResolver::new(
-            self.fs().clone(),
+            DenoFsNodeResolverEnv::new(self.fs().clone()),
             self.npm_resolver().await?.clone().into_npm_resolver(),
           )))
         }
@@ -577,7 +578,7 @@ impl CliFactory {
 
         Ok(Arc::new(NodeCodeTranslator::new(
           cjs_esm_analyzer,
-          self.fs().clone(),
+          DenoFsNodeResolverEnv::new(self.fs().clone()),
           self.node_resolver().await?.clone(),
           self.npm_resolver().await?.clone().into_npm_resolver(),
         )))

cli/factory.rs

@@ -23,7 +23,6 @@ use deno_core::serde::Serialize;
 use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::ModuleSpecifier;
-use deno_runtime::deno_node::NpmResolver;
 use deno_runtime::deno_node::PathClean;
 use deno_semver::jsr::JsrPackageNvReference;
 use deno_semver::jsr::JsrPackageReqReference;
@@ -34,6 +33,7 @@ use deno_semver::package::PackageReq;
 use deno_semver::package::PackageReqReference;
 use deno_semver::Version;
 use import_map::ImportMap;
+use node_resolver::NpmResolver;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use std::cmp::Ordering;

cli/lsp/analysis.rs

@@ -35,18 +35,18 @@ use deno_graph::GraphImport;
 use deno_graph::ModuleSpecifier;
 use deno_npm::NpmSystemInfo;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node::errors::ClosestPkgJsonError;
-use deno_runtime::deno_node::NodeResolution;
-use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NodeResolver;
-use deno_runtime::deno_node::NpmResolver;
 use deno_runtime::deno_node::PackageJson;
 use deno_runtime::fs_util::specifier_to_file_path;
 use deno_semver::jsr::JsrPackageReqReference;
 use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageNv;
 use deno_semver::package::PackageReq;
 use indexmap::IndexMap;
+use node_resolver::errors::ClosestPkgJsonError;
+use node_resolver::NodeResolution;
+use node_resolver::NodeResolutionMode;
+use node_resolver::NpmResolver;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
@@ -496,7 +496,7 @@ fn create_node_resolver(
   let npm_resolver = npm_resolver?;
   let fs = Arc::new(deno_fs::RealFs);
   let node_resolver_inner = Arc::new(NodeResolver::new(
-    fs.clone(),
+    deno_runtime::deno_node::DenoFsNodeResolverEnv::new(fs.clone()),
     npm_resolver.clone().into_npm_resolver(),
   ));
   Some(Arc::new(CliNodeResolver::new(

cli/lsp/resolver.rs

@@ -64,9 +64,9 @@ use deno_graph::Module;
 use deno_graph::ModuleGraph;
 use deno_graph::Resolution;
 use deno_runtime::code_cache;
-use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReqReference;
+use node_resolver::NodeResolutionMode;
 
 pub async fn load_top_level_deps(factory: &CliFactory) -> Result<(), AnyError> {
   let npm_resolver = factory.npm_resolver().await?;

cli/module_loader.rs

@@ -6,18 +6,20 @@ use deno_ast::MediaType;
 use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
 use deno_runtime::deno_fs;
-use deno_runtime::deno_node::analyze::CjsAnalysis as ExtNodeCjsAnalysis;
-use deno_runtime::deno_node::analyze::CjsAnalysisExports;
-use deno_runtime::deno_node::analyze::CjsCodeAnalyzer;
-use deno_runtime::deno_node::analyze::NodeCodeTranslator;
+use deno_runtime::deno_node::DenoFsNodeResolverEnv;
+use node_resolver::analyze::CjsAnalysis as ExtNodeCjsAnalysis;
+use node_resolver::analyze::CjsAnalysisExports;
+use node_resolver::analyze::CjsCodeAnalyzer;
+use node_resolver::analyze::NodeCodeTranslator;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::cache::CacheDBHash;
 use crate::cache::NodeAnalysisCache;
 use crate::util::fs::canonicalize_path_maybe_not_exists;
 
-pub type CliNodeCodeTranslator = NodeCodeTranslator<CliCjsCodeAnalyzer>;
+pub type CliNodeCodeTranslator =
+  NodeCodeTranslator<CliCjsCodeAnalyzer, DenoFsNodeResolverEnv>;
 
 /// Resolves a specifier that is pointing into a node_modules folder.
 ///

cli/node.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(),