feat(resolver): support baseUrl in tsconfig.json

.changeset/based-bears-brawl.md

@@ -0,0 +1,27 @@
+---
+"@biomejs/biome": minor
+---
+
+Biome's resolver now supports `baseUrl` if specified in `tsconfig.json`. This
+means that the following now resolves:
+
+**`tsconfig.json`**
+```json
+{
+    "compilerOptions": {
+        "baseUrl": "./src",
+    }
+}
+```
+
+**`index.ts`**
+```ts
+import { foo } from "foo"; // This will now work.
+```
+
+**`src/foo.ts`**
+```ts
+export function foo() {}
+```
+
+Fixes [#6432](https://github.com/biomejs/biome/issues/6432).

crates/biome_package/src/lib.rs

@@ -10,7 +10,7 @@ use biome_fs::FileSystem;
 use camino::Utf8Path;
 pub use license::generated::*;
 pub use node_js_package::{
-    Dependencies, NodeJsPackage, PackageJson, PackageType, TsConfigJson, Version,
+    CompilerOptions, Dependencies, NodeJsPackage, PackageJson, PackageType, TsConfigJson, Version,
 };
 
 use std::any::TypeId;

crates/biome_package/src/node_js_package/mod.rs

@@ -2,7 +2,7 @@ mod package_json;
 mod tsconfig_json;
 
 pub use package_json::{Dependencies, PackageJson, PackageType, Version};
-pub use tsconfig_json::TsConfigJson;
+pub use tsconfig_json::{CompilerOptions, TsConfigJson};
 
 use biome_rowan::Language;
 

crates/biome_package/src/node_js_package/tsconfig_json.rs

@@ -86,14 +86,19 @@ impl TsConfigJson {
 
 #[derive(Clone, Debug, Default, Deserializable)]
 pub struct CompilerOptions {
+    /// https://www.typescriptlang.org/tsconfig/#baseUrl
+    ///
+    /// The base URL is normalised to an absolute path after parsing.
     pub base_url: Option<Utf8PathBuf>,
 
     /// Path aliases.
     pub paths: Option<CompilerOptionsPathsMap>,
 
     /// The actual base from where path aliases are resolved.
+    ///
+    /// The base URL is normalised to an absolute path.
     #[deserializable(skip)]
-    paths_base: Utf8PathBuf,
+    pub paths_base: Utf8PathBuf,
 
     /// See: https://www.typescriptlang.org/tsconfig/#typeRoots
     #[deserializable(rename = "typeRoots")]

crates/biome_resolver/src/lib.rs

@@ -183,9 +183,15 @@ fn resolve_module_with_package_json(
 ) -> Result<Utf8PathBuf, ResolveError> {
     // `tsconfig.json` may only be found in directories containing a
     // `package.json`, so this is the only place we need to attempt to use it.
-    let tsconfig = fs.read_tsconfig_json(&package_path.join("tsconfig.json"));
-    if let Some(path) = tsconfig.as_ref().ok().and_then(|ts_config| {
-        resolve_paths_mapping(specifier, ts_config, package_path, fs, options).ok()
+    let tsconfig = match &options.tsconfig {
+        DiscoverableManifest::Auto => fs
+            .read_tsconfig_json(&package_path.join("tsconfig.json"))
+            .map(Cow::Owned),
+        DiscoverableManifest::Explicit { manifest, .. } => Ok(Cow::Borrowed(*manifest)),
+        DiscoverableManifest::Off => Err(ResolveError::NotFound),
+    };
+    if let Some(path) = tsconfig.as_ref().ok().and_then(|tsconfig| {
+        resolve_paths_mapping(specifier, tsconfig, package_path, fs, options).ok()
     }) {
         return Ok(path);
     }
@@ -222,6 +228,17 @@ fn resolve_module_with_package_json(
         );
     }
 
+    if let Some(base_url) = tsconfig
+        .as_ref()
+        .ok()
+        .and_then(|tsconfig| tsconfig.compiler_options.base_url.as_ref())
+    {
+        match resolve_relative_path(specifier, base_url, fs, options) {
+            Err(ResolveError::NotFound) => { /* continue below */ }
+            result => return result,
+        }
+    }
+
     resolve_dependency(specifier, package_path, fs, options)
 }
 
@@ -337,12 +354,12 @@ fn resolve_paths_mapping(
 
     let resolve_specifier = |specifier: &str| {
         if is_relative_specifier(specifier) {
-            let base_dir = match &tsconfig_json.compiler_options.base_url {
-                Some(base_url) => base_url.as_path(),
-                None => package_path,
-            };
-
-            resolve_relative_path(specifier, base_dir, fs, options)
+            resolve_relative_path(
+                specifier,
+                &tsconfig_json.compiler_options.paths_base,
+                fs,
+                options,
+            )
         } else {
             resolve_dependency(specifier, package_path, fs, options)
         }
@@ -686,6 +703,7 @@ fn strip_query_and_fragment(specifier: &str) -> &str {
 }
 
 /// Options to pass to the resolver.
+#[derive(Clone)]
 pub struct ResolveOptions<'a> {
     /// If `true`, specifiers are assumed to be relative paths. Resolving them
     /// as a package will still be attempted if resolving as a relative path
@@ -898,7 +916,7 @@ impl<'a> ResolveOptions<'a> {
 /// `tsconfig.json` will be automatically discovered, but this enum allows to
 /// turn them off completely, or to provide an explicit manifest to be used
 /// instead.
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub enum DiscoverableManifest<T> {
     #[default]
     Auto,

crates/biome_resolver/tests/fixtures/resolver_cases_7/package.json

@@ -0,0 +1,3 @@
+{
+    "name": "resolver_cases_7"
+}

crates/biome_resolver/tests/fixtures/resolver_cases_7/tsconfig.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "baseUrl": "./src"
+    }
+}

crates/biome_resolver/tests/spec_tests.rs

@@ -1,4 +1,5 @@
 use biome_fs::OsFileSystem;
+use biome_package::{CompilerOptions, TsConfigJson};
 use biome_resolver::*;
 use camino::{Utf8Path, Utf8PathBuf};
 
@@ -533,3 +534,83 @@ fn test_resolve_type_definitions_without_type_specification() {
         )))
     );
 }
+
+#[test]
+fn test_resolve_from_base_url() {
+    let base_dir = get_fixtures_path("resolver_cases_7");
+    let fs = OsFileSystem::new(base_dir.clone());
+
+    let options = ResolveOptions {
+        condition_names: &["default"],
+        extensions: &["js", "ts"],
+        ..Default::default()
+    };
+
+    // Make sure resolution works with explicitly specified `tsconfig.json`.
+    assert_eq!(
+        resolve(
+            "bar",
+            &base_dir.join("src"),
+            &fs,
+            &options
+                .clone()
+                .with_tsconfig(DiscoverableManifest::Explicit {
+                    package_path: Utf8PathBuf::from(format!("{base_dir}/tsconfig.json")),
+                    manifest: &TsConfigJson {
+                        compiler_options: CompilerOptions {
+                            base_url: Some(base_dir.join("src")),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    }
+                })
+        ),
+        Ok(Utf8PathBuf::from(format!("{base_dir}/src/bar.ts")))
+    );
+
+    // Make sure resolution works with auto-discovered `tsconfig.json`.
+    assert_eq!(
+        resolve("bar", &base_dir.join("src"), &fs, &options),
+        Ok(Utf8PathBuf::from(format!("{base_dir}/src/bar.ts")))
+    );
+
+    // It shouldn't matter if we're resolving from a different base directory.
+    assert_eq!(
+        resolve("bar", &base_dir, &fs, &options),
+        Ok(Utf8PathBuf::from(format!("{base_dir}/src/bar.ts")))
+    );
+    assert_eq!(
+        resolve("bar", &base_dir.join("src/foo"), &fs, &options),
+        Ok(Utf8PathBuf::from(format!("{base_dir}/src/bar.ts")))
+    );
+
+    // Resolution should work in subfolders too.
+    assert_eq!(
+        resolve("foo/foo", &base_dir.join("src"), &fs, &options),
+        Ok(Utf8PathBuf::from(format!("{base_dir}/src/foo/foo.ts")))
+    );
+
+    // Make sure resolution falls back to `node_modules/` without `baseUrl`.
+    assert_eq!(
+        resolve(
+            "bar",
+            &base_dir.join("src"),
+            &fs,
+            &options
+                .clone()
+                .with_tsconfig(DiscoverableManifest::Explicit {
+                    package_path: Utf8PathBuf::from(format!("{base_dir}/tsconfig.json")),
+                    manifest: &TsConfigJson {
+                        compiler_options: CompilerOptions {
+                            base_url: None,
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    }
+                })
+        ),
+        Ok(Utf8PathBuf::from(format!(
+            "{base_dir}/node_modules/bar/index.js"
+        )))
+    );
+}