refactor: use concrete error types for node resolution (#24470)

This will help clean up some of the code in the CLI because we'll be
able to tell how the resolution failed (not part of this PR).

1 files changed, 35 insertions, 25 deletions

diff --git a/cli/npm/byonm.rs b/cli/npm/byonm.rs
index bbd5da8ec..4abb6b3b2 100644
--- a/cli/npm/byonm.rs
+++ b/cli/npm/byonm.rs
@@ -11,6 +11,8 @@ use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_runtime::deno_fs::FileSystem;
+use deno_runtime::deno_node::errors::PackageFolderResolveError;
+use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind;
 use deno_runtime::deno_node::load_pkg_json;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NpmResolver;
@@ -168,42 +170,50 @@ impl NpmResolver for ByonmCliNpmResolver {
     &self,
     name: &str,
     referrer: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError> {
+  ) -> Result<PathBuf, PackageFolderResolveError> {
     fn inner(
       fs: &dyn FileSystem,
       name: &str,
       referrer: &ModuleSpecifier,
-    ) -> Result<PathBuf, AnyError> {
-      let referrer_file = specifier_to_file_path(referrer)?;
-      let mut current_folder = referrer_file.parent().unwrap();
-      loop {
-        let node_modules_folder = if current_folder.ends_with("node_modules") {
-          Cow::Borrowed(current_folder)
-        } else {
-          Cow::Owned(current_folder.join("node_modules"))
-        };
-
-        let sub_dir = join_package_name(&node_modules_folder, name);
-        if fs.is_dir_sync(&sub_dir) {
-          return Ok(sub_dir);
-        }
+    ) -> Result<PathBuf, PackageFolderResolveError> {
+      let maybe_referrer_file = specifier_to_file_path(referrer).ok();
+      let maybe_start_folder =
+        maybe_referrer_file.as_ref().and_then(|f| f.parent());
+      if let Some(start_folder) = maybe_start_folder {
+        for current_folder in start_folder.ancestors() {
+          let node_modules_folder = if current_folder.ends_with("node_modules")
+          {
+            Cow::Borrowed(current_folder)
+          } else {
+            Cow::Owned(current_folder.join("node_modules"))
+          };
 
-        if let Some(parent) = current_folder.parent() {
-          current_folder = parent;
-        } else {
-          break;
+          let sub_dir = join_package_name(&node_modules_folder, name);
+          if fs.is_dir_sync(&sub_dir) {
+            return Ok(sub_dir);
+          }
         }
       }
 
-      bail!(
-        "could not find package '{}' from referrer '{}'.",
-        name,
-        referrer
-      );
+      Err(
+        PackageFolderResolveErrorKind::NotFoundPackage {
+          package_name: name.to_string(),
+          referrer: referrer.clone(),
+          referrer_extra: None,
+        }
+        .into(),
+      )
     }
 
     let path = inner(&*self.fs, name, referrer)?;
-    Ok(self.fs.realpath_sync(&path)?)
+    self.fs.realpath_sync(&path).map_err(|err| {
+      PackageFolderResolveErrorKind::Io {
+        package_name: name.to_string(),
+        referrer: referrer.clone(),
+        source: err.into_io_error(),
+      }
+      .into()
+    })
   }
 
   fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {