foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-24 15:19:26 -05:00
Code Issues Packages 1 Wiki Activity

fix(node): better detection for when to surface node resolution errors (#24653)

Browse source
This commit is contained in:
David Sherret 2024-07-23 20:22:24 -04:00 committed by GitHub
parent 445e05a39d
commit 52ababc4bf
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
35 changed files with 678 additions and 519 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
cli/module_loader.rs
View file

@ -446,15 +446,14 @@ impl<TGraphContainer: ModuleGraphContainer>
specifier: &str, specifier: &str,
referrer: &ModuleSpecifier, referrer: &ModuleSpecifier,
) -> Result<ModuleSpecifier, AnyError> { ) -> Result<ModuleSpecifier, AnyError> {
if let Some(result) = self.shared.node_resolver.resolve_if_in_npm_package( if self.shared.node_resolver.in_npm_package(referrer) {
specifier, return Ok(
referrer, self
NodeResolutionMode::Execution, .shared
) { .node_resolver
return match result? { .resolve(specifier, referrer, NodeResolutionMode::Execution)?
Some(res) => Ok(res.into_url()), .into_url(),
None => Err(generic_error("not found")), );
};
} }
let graph = self.graph_container.graph(); let graph = self.graph_container.graph();

7
cli/npm/byonm.rs
View file

@ -12,7 +12,8 @@ use deno_core::serde_json;
use deno_package_json::PackageJsonDepValue; use deno_package_json::PackageJsonDepValue;
use deno_runtime::deno_fs::FileSystem; use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::errors::PackageFolderResolveError; use deno_runtime::deno_node::errors::PackageFolderResolveError;
use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind; 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::load_pkg_json;
use deno_runtime::deno_node::NodePermissions; use deno_runtime::deno_node::NodePermissions;
use deno_runtime::deno_node::NpmResolver; use deno_runtime::deno_node::NpmResolver;
@ -198,7 +199,7 @@ impl NpmResolver for ByonmCliNpmResolver {
} }
Err( Err(
PackageFolderResolveErrorKind::NotFoundPackage { PackageNotFoundError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: None, referrer_extra: None,
@ -209,7 +210,7 @@ impl NpmResolver for ByonmCliNpmResolver {
let path = inner(&*self.fs, name, referrer)?; let path = inner(&*self.fs, name, referrer)?;
self.fs.realpath_sync(&path).map_err(|err| { self.fs.realpath_sync(&path).map_err(|err| {
PackageFolderResolveErrorKind::Io { PackageFolderResolveIoError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
source: err.into_io_error(), source: err.into_io_error(),

4
cli/npm/managed/mod.rs
View file

@ -21,7 +21,7 @@ use deno_npm::NpmResolutionPackage;
use deno_npm::NpmSystemInfo; use deno_npm::NpmSystemInfo;
use deno_runtime::deno_fs::FileSystem; use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::errors::PackageFolderResolveError; use deno_runtime::deno_node::errors::PackageFolderResolveError;
use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind; use deno_runtime::deno_node::errors::PackageFolderResolveIoError;
use deno_runtime::deno_node::NodePermissions; use deno_runtime::deno_node::NodePermissions;
use deno_runtime::deno_node::NpmResolver; use deno_runtime::deno_node::NpmResolver;
use deno_semver::package::PackageNv; use deno_semver::package::PackageNv;
@ -549,7 +549,7 @@ impl NpmResolver for ManagedCliNpmResolver {
.resolve_package_folder_from_package(name, referrer)?; .resolve_package_folder_from_package(name, referrer)?;
let path = let path =
canonicalize_path_maybe_not_exists_with_fs(&path, self.fs.as_ref()) canonicalize_path_maybe_not_exists_with_fs(&path, self.fs.as_ref())
.map_err(|err| PackageFolderResolveErrorKind::Io { .map_err(|err| PackageFolderResolveIoError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
source: err, source: err,

11
cli/npm/managed/resolvers/global.rs
View file

@ -15,7 +15,8 @@ use deno_npm::NpmPackageId;
use deno_npm::NpmSystemInfo; use deno_npm::NpmSystemInfo;
use deno_runtime::deno_fs::FileSystem; use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::errors::PackageFolderResolveError; use deno_runtime::deno_node::errors::PackageFolderResolveError;
use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind; use deno_runtime::deno_node::errors::PackageNotFoundError;
use deno_runtime::deno_node::errors::ReferrerNotFoundError;
use deno_runtime::deno_node::NodePermissions; use deno_runtime::deno_node::NodePermissions;
use super::super::cache::NpmCache; use super::super::cache::NpmCache;
@ -84,7 +85,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
.resolve_package_folder_id_from_specifier(referrer) .resolve_package_folder_id_from_specifier(referrer)
else { else {
return Err( return Err(
PackageFolderResolveErrorKind::NotFoundReferrer { ReferrerNotFoundError {
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: None, referrer_extra: None,
} }
@ -98,7 +99,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
Ok(pkg) => match self.maybe_package_folder(&pkg.id) { Ok(pkg) => match self.maybe_package_folder(&pkg.id) {
Some(folder) => Ok(folder), Some(folder) => Ok(folder),
None => Err( None => Err(
PackageFolderResolveErrorKind::NotFoundPackage { PackageNotFoundError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: Some(format!( referrer_extra: Some(format!(
@ -112,7 +113,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
}, },
Err(err) => match *err { Err(err) => match *err {
PackageNotFoundFromReferrerError::Referrer(cache_folder_id) => Err( PackageNotFoundFromReferrerError::Referrer(cache_folder_id) => Err(
PackageFolderResolveErrorKind::NotFoundReferrer { ReferrerNotFoundError {
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: Some(cache_folder_id.to_string()), referrer_extra: Some(cache_folder_id.to_string()),
} }
@ -122,7 +123,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
name, name,
referrer: cache_folder_id_referrer, referrer: cache_folder_id_referrer,
} => Err( } => Err(
PackageFolderResolveErrorKind::NotFoundPackage { PackageNotFoundError {
package_name: name, package_name: name,
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: Some(cache_folder_id_referrer.to_string()), referrer_extra: Some(cache_folder_id_referrer.to_string()),

10
cli/npm/managed/resolvers/local.rs
View file

@ -33,7 +33,9 @@ use deno_npm::NpmResolutionPackage;
use deno_npm::NpmSystemInfo; use deno_npm::NpmSystemInfo;
use deno_runtime::deno_fs; use deno_runtime::deno_fs;
use deno_runtime::deno_node::errors::PackageFolderResolveError; use deno_runtime::deno_node::errors::PackageFolderResolveError;
use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind; 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_runtime::deno_node::NodePermissions;
use deno_semver::package::PackageNv; use deno_semver::package::PackageNv;
use serde::Deserialize; use serde::Deserialize;
@ -185,14 +187,14 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
) -> Result<PathBuf, PackageFolderResolveError> { ) -> Result<PathBuf, PackageFolderResolveError> {
let maybe_local_path = self let maybe_local_path = self
.resolve_folder_for_specifier(referrer) .resolve_folder_for_specifier(referrer)
.map_err(|err| PackageFolderResolveErrorKind::Io { .map_err(|err| PackageFolderResolveIoError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
source: err, source: err,
})?; })?;
let Some(local_path) = maybe_local_path else { let Some(local_path) = maybe_local_path else {
return Err( return Err(
PackageFolderResolveErrorKind::NotFoundReferrer { ReferrerNotFoundError {
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: None, referrer_extra: None,
} }
@ -220,7 +222,7 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
} }
Err( Err(
PackageFolderResolveErrorKind::NotFoundPackage { PackageNotFoundError {
package_name: name.to_string(), package_name: name.to_string(),
referrer: referrer.clone(), referrer: referrer.clone(),
referrer_extra: None, referrer_extra: None,

355
cli/resolver.rs
View file

@ -25,15 +25,17 @@ use deno_runtime::deno_fs;
use deno_runtime::deno_fs::FileSystem; use deno_runtime::deno_fs::FileSystem;
use deno_runtime::deno_node::errors::ClosestPkgJsonError; use deno_runtime::deno_node::errors::ClosestPkgJsonError;
use deno_runtime::deno_node::errors::NodeResolveError; use deno_runtime::deno_node::errors::NodeResolveError;
use deno_runtime::deno_node::errors::ResolvePkgSubpathFromDenoModuleError; use deno_runtime::deno_node::errors::NodeResolveErrorKind;
use deno_runtime::deno_node::errors::PackageFolderResolveErrorKind;
use deno_runtime::deno_node::errors::PackageFolderResolveIoError;
use deno_runtime::deno_node::errors::PackageNotFoundError;
use deno_runtime::deno_node::errors::PackageResolveErrorKind;
use deno_runtime::deno_node::errors::UrlToNodeResolutionError; use deno_runtime::deno_node::errors::UrlToNodeResolutionError;
use deno_runtime::deno_node::is_builtin_node_module; use deno_runtime::deno_node::is_builtin_node_module;
use deno_runtime::deno_node::parse_npm_pkg_name;
use deno_runtime::deno_node::NodeModuleKind; use deno_runtime::deno_node::NodeModuleKind;
use deno_runtime::deno_node::NodeResolution; use deno_runtime::deno_node::NodeResolution;
use deno_runtime::deno_node::NodeResolutionMode; use deno_runtime::deno_node::NodeResolutionMode;
use deno_runtime::deno_node::NodeResolver; use deno_runtime::deno_node::NodeResolver;
use deno_runtime::deno_node::NpmResolver as DenoNodeNpmResolver;
use deno_runtime::deno_node::PackageJson; use deno_runtime::deno_node::PackageJson;
use deno_runtime::fs_util::specifier_to_file_path; use deno_runtime::fs_util::specifier_to_file_path;
use deno_semver::npm::NpmPackageReqReference; use deno_semver::npm::NpmPackageReqReference;
@ -47,7 +49,6 @@ use crate::args::JsxImportSourceConfig;
use crate::args::DENO_DISABLE_PEDANTIC_NODE_WARNINGS; use crate::args::DENO_DISABLE_PEDANTIC_NODE_WARNINGS;
use crate::colors; use crate::colors;
use crate::node::CliNodeCodeTranslator; use crate::node::CliNodeCodeTranslator;
use crate::npm::ByonmCliNpmResolver;
use crate::npm::CliNpmResolver; use crate::npm::CliNpmResolver;
use crate::npm::InnerCliNpmResolverRef; use crate::npm::InnerCliNpmResolverRef;
use crate::util::sync::AtomicFlag; use crate::util::sync::AtomicFlag;
@ -102,17 +103,77 @@ impl CliNodeResolver {
self.node_resolver.get_closest_package_json(referrer) self.node_resolver.get_closest_package_json(referrer)
} }
pub fn resolve_if_in_npm_package( pub fn resolve_if_for_npm_pkg(
&self, &self,
specifier: &str, specifier: &str,
referrer: &ModuleSpecifier, referrer: &ModuleSpecifier,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Option<Result<Option<NodeResolution>, NodeResolveError>> { ) -> Result<Option<NodeResolution>, AnyError> {
if self.in_npm_package(referrer) { let resolution_result = self.resolve(specifier, referrer, mode);
// we're in an npm package, so use node resolution match resolution_result {
Some(self.resolve(specifier, referrer, mode)) Ok(res) => Ok(Some(res)),
} else { Err(err) => {
None let err = err.into_kind();
match err {
NodeResolveErrorKind::RelativeJoin(_)
| NodeResolveErrorKind::PackageImportsResolve(_)
| NodeResolveErrorKind::UnsupportedEsmUrlScheme(_)
| NodeResolveErrorKind::DataUrlReferrer(_)
| NodeResolveErrorKind::TypesNotFound(_)
| NodeResolveErrorKind::FinalizeResolution(_)
| NodeResolveErrorKind::UrlToNodeResolution(_) => Err(err.into()),
NodeResolveErrorKind::PackageResolve(err) => {
let err = err.into_kind();
match err {
PackageResolveErrorKind::ClosestPkgJson(_)
| PackageResolveErrorKind::InvalidModuleSpecifier(_)
| PackageResolveErrorKind::ExportsResolve(_)
| PackageResolveErrorKind::SubpathResolve(_) => Err(err.into()),
PackageResolveErrorKind::PackageFolderResolve(err) => {
match err.as_kind() {
PackageFolderResolveErrorKind::Io(
PackageFolderResolveIoError { package_name, .. },
)
| PackageFolderResolveErrorKind::PackageNotFound(
PackageNotFoundError { package_name, .. },
) => {
if self.in_npm_package(referrer) {
return Err(err.into());
}
if let Some(byonm_npm_resolver) =
self.npm_resolver.as_byonm()
{
if byonm_npm_resolver
.find_ancestor_package_json_with_dep(
package_name,
referrer,
)
.is_some()
{
return Err(anyhow!(
concat!(
"Could not resolve \"{}\", but found it in a package.json. ",
"Deno expects the node_modules/ directory to be up to date. ",
"Did you forget to run `npm install`?"
),
specifier
));
}
}
Ok(None)
}
PackageFolderResolveErrorKind::ReferrerNotFound(_) => {
if self.in_npm_package(referrer) {
return Err(err.into());
}
Ok(None)
}
}
}
}
}
}
}
} }
} }
@ -121,18 +182,18 @@ impl CliNodeResolver {
specifier: &str, specifier: &str,
referrer: &ModuleSpecifier, referrer: &ModuleSpecifier,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<NodeResolution>, NodeResolveError> { ) -> Result<NodeResolution, NodeResolveError> {
let referrer_kind = if self.cjs_resolutions.contains(referrer) { let referrer_kind = if self.cjs_resolutions.contains(referrer) {
NodeModuleKind::Cjs NodeModuleKind::Cjs
} else { } else {
NodeModuleKind::Esm NodeModuleKind::Esm
}; };
let maybe_res = let res =
self self
.node_resolver .node_resolver
.resolve(specifier, referrer, referrer_kind, mode)?; .resolve(specifier, referrer, referrer_kind, mode)?;
Ok(self.handle_node_resolution(maybe_res)) Ok(self.handle_node_resolution(res))
} }
pub fn resolve_req_reference( pub fn resolve_req_reference(
@ -159,16 +220,15 @@ impl CliNodeResolver {
let package_folder = self let package_folder = self
.npm_resolver .npm_resolver
.resolve_pkg_folder_from_deno_module_req(req, referrer)?; .resolve_pkg_folder_from_deno_module_req(req, referrer)?;
let maybe_resolution = self let resolution_result = self.resolve_package_sub_path_from_deno_module(
.maybe_resolve_package_sub_path_from_deno_module( &package_folder,
&package_folder, sub_path,
sub_path, Some(referrer),
Some(referrer), mode,
mode, );
)?; match resolution_result {
match maybe_resolution { Ok(resolution) => Ok(resolution),
Some(resolution) => Ok(resolution), Err(err) => {
None => {
if self.npm_resolver.as_byonm().is_some() { if self.npm_resolver.as_byonm().is_some() {
let package_json_path = package_folder.join("package.json"); let package_json_path = package_folder.join("package.json");
if !self.fs.exists_sync(&package_json_path) { if !self.fs.exists_sync(&package_json_path) {
@ -178,12 +238,7 @@ impl CliNodeResolver {
)); ));
} }
} }
Err(anyhow!( Err(err)
"Failed resolving '{}{}' in '{}'.",
req,
sub_path.map(|s| format!("/{}", s)).unwrap_or_default(),
package_folder.display()
))
} }
} }
} }
@ -195,32 +250,7 @@ impl CliNodeResolver {
maybe_referrer: Option<&ModuleSpecifier>, maybe_referrer: Option<&ModuleSpecifier>,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<NodeResolution, AnyError> { ) -> Result<NodeResolution, AnyError> {
self let res = self
.maybe_resolve_package_sub_path_from_deno_module(
package_folder,
sub_path,
maybe_referrer,
mode,
)?
.ok_or_else(|| {
anyhow!(
"Failed resolving '{}' in '{}'.",
sub_path
.map(|s| format!("/{}", s))
.unwrap_or_else(|| ".".to_string()),
package_folder.display(),
)
})
}
pub fn maybe_resolve_package_sub_path_from_deno_module(
&self,
package_folder: &Path,
sub_path: Option<&str>,
maybe_referrer: Option<&ModuleSpecifier>,
mode: NodeResolutionMode,
) -> Result<Option<NodeResolution>, ResolvePkgSubpathFromDenoModuleError> {
let maybe_res = self
.node_resolver .node_resolver
.resolve_package_subpath_from_deno_module( .resolve_package_subpath_from_deno_module(
package_folder, package_folder,
@ -228,7 +258,7 @@ impl CliNodeResolver {
maybe_referrer, maybe_referrer,
mode, mode,
)?; )?;
Ok(self.handle_node_resolution(maybe_res)) Ok(self.handle_node_resolution(res))
} }
pub fn handle_if_in_node_modules( pub fn handle_if_in_node_modules(
@ -267,13 +297,13 @@ impl CliNodeResolver {
fn handle_node_resolution( fn handle_node_resolution(
&self, &self,
maybe_resolution: Option<NodeResolution>, resolution: NodeResolution,
) -> Option<NodeResolution> { ) -> NodeResolution {
if let Some(NodeResolution::CommonJs(specifier)) = &maybe_resolution { if let NodeResolution::CommonJs(specifier) = &resolution {
// remember that this was a common js resolution // remember that this was a common js resolution
self.cjs_resolutions.insert(specifier.clone()); self.cjs_resolutions.insert(specifier.clone());
} }
maybe_resolution resolution
} }
} }
@ -458,39 +488,6 @@ impl CliGraphResolver {
bare_node_builtins_enabled: self.bare_node_builtins_enabled, bare_node_builtins_enabled: self.bare_node_builtins_enabled,
} }
} }
// todo(dsherret): update this and the surrounding code to handle the structured errors from NodeResolver
fn check_surface_byonm_node_error(
&self,
specifier: &str,
referrer: &ModuleSpecifier,
original_err: AnyError,
resolver: &ByonmCliNpmResolver,
) -> Result<(), AnyError> {
if let Ok((pkg_name, _, _)) = parse_npm_pkg_name(specifier, referrer) {
match resolver.resolve_package_folder_from_package(&pkg_name, referrer) {
Ok(_) => {
return Err(original_err);
}
Err(_) => {
if resolver
.find_ancestor_package_json_with_dep(&pkg_name, referrer)
.is_some()
{
return Err(anyhow!(
concat!(
"Could not resolve \"{}\", but found it in a package.json. ",
"Deno expects the node_modules/ directory to be up to date. ",
"Did you forget to run `npm install`?"
),
specifier
));
}
}
}
}
Ok(())
}
} }
impl Resolver for CliGraphResolver { impl Resolver for CliGraphResolver {
@ -523,6 +520,18 @@ impl Resolver for CliGraphResolver {
} }
let referrer = &referrer_range.specifier; let referrer = &referrer_range.specifier;
// Use node resolution if we're in an npm package
if let Some(node_resolver) = self.node_resolver.as_ref() {
if referrer.scheme() == "file" && node_resolver.in_npm_package(referrer) {
return node_resolver
.resolve(specifier, referrer, to_node_mode(mode))
.map(|res| res.into_url())
.map_err(|e| ResolveError::Other(e.into()));
}
}
// Attempt to resolve with the workspace resolver
let result: Result<_, ResolveError> = self let result: Result<_, ResolveError> = self
.workspace_resolver .workspace_resolver
.resolve(specifier, referrer) .resolve(specifier, referrer)
@ -535,7 +544,19 @@ impl Resolver for CliGraphResolver {
let result = match result { let result = match result {
Ok(resolution) => match resolution { Ok(resolution) => match resolution {
MappedResolution::Normal(specifier) MappedResolution::Normal(specifier)
| MappedResolution::ImportMap(specifier) => Ok(specifier), | MappedResolution::ImportMap(specifier) => {
// do sloppy imports resolution if enabled
if let Some(sloppy_imports_resolver) = &self.sloppy_imports_resolver {
Ok(sloppy_imports_resolve(
sloppy_imports_resolver,
specifier,
referrer_range,
mode,
))
} else {
Ok(specifier)
}
}
MappedResolution::WorkspaceNpmPackage { MappedResolution::WorkspaceNpmPackage {
target_pkg_json: pkg_json, target_pkg_json: pkg_json,
sub_path, sub_path,
@ -552,8 +573,6 @@ impl Resolver for CliGraphResolver {
) )
.map_err(ResolveError::Other) .map_err(ResolveError::Other)
.map(|res| res.into_url()), .map(|res| res.into_url()),
// todo(dsherret): for byonm it should do resolution solely based on
// the referrer and not the package.json
MappedResolution::PackageJson { MappedResolution::PackageJson {
dep_result, dep_result,
alias, alias,
@ -604,44 +623,6 @@ impl Resolver for CliGraphResolver {
Err(err) => Err(err), Err(err) => Err(err),
}; };
// check if it's an npm specifier that resolves to a workspace member
if let Some(node_resolver) = &self.node_resolver {
if let Ok(specifier) = &result {
if let Ok(req_ref) = NpmPackageReqReference::from_specifier(specifier) {
if let Some(pkg_folder) = self
.workspace_resolver
.resolve_workspace_pkg_json_folder_for_npm_specifier(req_ref.req())
{
return Ok(
node_resolver
.resolve_package_sub_path_from_deno_module(
pkg_folder,
req_ref.sub_path(),
Some(referrer),
to_node_mode(mode),
)?
.into_url(),
);
}
}
}
}
// do sloppy imports resolution if enabled
let result =
if let Some(sloppy_imports_resolver) = &self.sloppy_imports_resolver {
result.map(|specifier| {
sloppy_imports_resolve(
sloppy_imports_resolver,
specifier,
referrer_range,
mode,
)
})
} else {
result
};
// When the user is vendoring, don't allow them to import directly from the vendor/ directory // When the user is vendoring, don't allow them to import directly from the vendor/ directory
// as it might cause them confusion or duplicate dependencies. Additionally, this folder has // as it might cause them confusion or duplicate dependencies. Additionally, this folder has
// special treatment in the language server so it will definitely cause issues/confusion there // special treatment in the language server so it will definitely cause issues/confusion there
@ -654,77 +635,63 @@ impl Resolver for CliGraphResolver {
} }
} }
if let Some(resolver) = let Some(node_resolver) = &self.node_resolver else {
self.npm_resolver.as_ref().and_then(|r| r.as_byonm()) return result;
{ };
match &result {
Ok(specifier) => { let is_byonm = self
if let Ok(npm_req_ref) = .npm_resolver
NpmPackageReqReference::from_specifier(specifier) .as_ref()
.is_some_and(|r| r.as_byonm().is_some());
match result {
Ok(specifier) => {
if let Ok(npm_req_ref) =
NpmPackageReqReference::from_specifier(&specifier)
{
// check if the npm specifier resolves to a workspace member
if let Some(pkg_folder) = self
.workspace_resolver
.resolve_workspace_pkg_json_folder_for_npm_specifier(
npm_req_ref.req(),
)
{ {
let node_resolver = self.node_resolver.as_ref().unwrap(); return Ok(
node_resolver
.resolve_package_sub_path_from_deno_module(
pkg_folder,
npm_req_ref.sub_path(),
Some(referrer),
to_node_mode(mode),
)?
.into_url(),
);
}
// do npm resolution for byonm
if is_byonm {
return node_resolver return node_resolver
.resolve_req_reference(&npm_req_ref, referrer, to_node_mode(mode)) .resolve_req_reference(&npm_req_ref, referrer, to_node_mode(mode))
.map(|res| res.into_url()) .map(|res| res.into_url())
.map_err(|err| err.into()); .map_err(|err| err.into());
} }
} }
Err(_) => {
if referrer.scheme() == "file" { Ok(node_resolver.handle_if_in_node_modules(specifier)?)
if let Some(node_resolver) = &self.node_resolver { }
let node_result = Err(err) => {
node_resolver.resolve(specifier, referrer, to_node_mode(mode)); // If byonm, check if the bare specifier resolves to an npm package
match node_result { if is_byonm && referrer.scheme() == "file" {
Ok(Some(res)) => { let maybe_resolution = node_resolver
return Ok(res.into_url()); .resolve_if_for_npm_pkg(specifier, referrer, to_node_mode(mode))
} .map_err(ResolveError::Other)?;
Ok(None) => { if let Some(res) = maybe_resolution {
self return Ok(res.into_url());
.check_surface_byonm_node_error(
specifier,
referrer,
anyhow!("Cannot find \"{}\"", specifier),
resolver,
)
.map_err(ResolveError::Other)?;
}
Err(err) => {
self
.check_surface_byonm_node_error(
specifier,
referrer,
err.into(),
resolver,
)
.map_err(ResolveError::Other)?;
}
}
}
} }
} }
}
}
if referrer.scheme() == "file" { Err(err)
if let Some(node_resolver) = &self.node_resolver {
let node_result = node_resolver.resolve_if_in_npm_package(
specifier,
referrer,
to_node_mode(mode),
);
if let Some(Ok(Some(res))) = node_result {
return Ok(res.into_url());
}
} }
} }
let specifier = result?;
match &self.node_resolver {
Some(node_resolver) => node_resolver
.handle_if_in_node_modules(specifier)
.map_err(|e| e.into()),
None => Ok(specifier),
}
} }
} }

25
cli/standalone/mod.rs
View file

@ -151,15 +151,14 @@ impl ModuleLoader for EmbeddedModuleLoader {
})? })?
}; };
if let Some(result) = self.shared.node_resolver.resolve_if_in_npm_package( if self.shared.node_resolver.in_npm_package(&referrer) {
specifier, return Ok(
&referrer, self
NodeResolutionMode::Execution, .shared
) { .node_resolver
return match result? { .resolve(specifier, &referrer, NodeResolutionMode::Execution)?
Some(res) => Ok(res.into_url()), .into_url(),
None => Err(generic_error("not found")), );
};
} }
let mapped_resolution = let mapped_resolution =
@ -250,14 +249,12 @@ impl ModuleLoader for EmbeddedModuleLoader {
Err(err) Err(err)
if err.is_unmapped_bare_specifier() && referrer.scheme() == "file" => if err.is_unmapped_bare_specifier() && referrer.scheme() == "file" =>
{ {
// todo(dsherret): return a better error from node resolution so that let maybe_res = self.shared.node_resolver.resolve_if_for_npm_pkg(
// we can more easily tell whether to surface it or not
let node_result = self.shared.node_resolver.resolve(
specifier, specifier,
&referrer, &referrer,
NodeResolutionMode::Execution, NodeResolutionMode::Execution,
); )?;
if let Ok(Some(res)) = node_result { if let Some(res) = maybe_res {
return Ok(res.into_url()); return Ok(res.into_url());
} }
Err(err.into()) Err(err.into())

38
cli/tsc/mod.rs
View file

@ -30,6 +30,8 @@ use deno_graph::GraphKind;
use deno_graph::Module; use deno_graph::Module;
use deno_graph::ModuleGraph; use deno_graph::ModuleGraph;
use deno_graph::ResolutionResolved; use deno_graph::ResolutionResolved;
use deno_runtime::deno_node::errors::NodeJsErrorCode;
use deno_runtime::deno_node::errors::NodeJsErrorCoded;
use deno_runtime::deno_node::NodeModuleKind; use deno_runtime::deno_node::NodeModuleKind;
use deno_runtime::deno_node::NodeResolution; use deno_runtime::deno_node::NodeResolution;
use deno_runtime::deno_node::NodeResolutionMode; use deno_runtime::deno_node::NodeResolutionMode;
@ -756,13 +758,21 @@ fn resolve_graph_specifier_types(
.as_managed() .as_managed()
.unwrap() // should never be byonm because it won't create Module::Npm .unwrap() // should never be byonm because it won't create Module::Npm
.resolve_pkg_folder_from_deno_module(module.nv_reference.nv())?; .resolve_pkg_folder_from_deno_module(module.nv_reference.nv())?;
let maybe_resolution = let res_result =
npm.node_resolver.resolve_package_subpath_from_deno_module( npm.node_resolver.resolve_package_subpath_from_deno_module(
&package_folder, &package_folder,
module.nv_reference.sub_path(), module.nv_reference.sub_path(),
Some(referrer), Some(referrer),
NodeResolutionMode::Types, NodeResolutionMode::Types,
)?; );
let maybe_resolution = match res_result {
Ok(res) => Some(res),
Err(err) => match err.code() {
NodeJsErrorCode::ERR_TYPES_NOT_FOUND
| NodeJsErrorCode::ERR_MODULE_NOT_FOUND => None,
_ => return Err(err.into()),
},
};
Ok(Some(NodeResolution::into_specifier_and_media_type( Ok(Some(NodeResolution::into_specifier_and_media_type(
maybe_resolution, maybe_resolution,
))) )))
@ -805,8 +815,7 @@ fn resolve_non_graph_specifier_types(
referrer_kind, referrer_kind,
NodeResolutionMode::Types, NodeResolutionMode::Types,
) )
.ok() .ok(),
.flatten(),
))) )))
} else if let Ok(npm_req_ref) = NpmPackageReqReference::from_str(specifier) { } else if let Ok(npm_req_ref) = NpmPackageReqReference::from_str(specifier) {
debug_assert_eq!(referrer_kind, NodeModuleKind::Esm); debug_assert_eq!(referrer_kind, NodeModuleKind::Esm);
@ -817,13 +826,20 @@ fn resolve_non_graph_specifier_types(
let package_folder = npm let package_folder = npm
.npm_resolver .npm_resolver
.resolve_pkg_folder_from_deno_module_req(npm_req_ref.req(), referrer)?; .resolve_pkg_folder_from_deno_module_req(npm_req_ref.req(), referrer)?;
let maybe_resolution = node_resolver let res_result = node_resolver.resolve_package_subpath_from_deno_module(
.resolve_package_subpath_from_deno_module( &package_folder,
&package_folder, npm_req_ref.sub_path(),
npm_req_ref.sub_path(), Some(referrer),
Some(referrer), NodeResolutionMode::Types,
NodeResolutionMode::Types, );
)?; let maybe_resolution = match res_result {
Ok(res) => Some(res),
Err(err) => match err.code() {
NodeJsErrorCode::ERR_TYPES_NOT_FOUND
| NodeJsErrorCode::ERR_MODULE_NOT_FOUND => None,
_ => return Err(err.into()),
},
};
Ok(Some(NodeResolution::into_specifier_and_media_type( Ok(Some(NodeResolution::into_specifier_and_media_type(
maybe_resolution, maybe_resolution,
))) )))

7
cli/worker.rs
View file

@ -687,7 +687,7 @@ impl CliMainWorkerFactory {
return Ok(None); return Ok(None);
} }
let Some(resolution) = self let resolution = self
.shared .shared
.node_resolver .node_resolver
.resolve_package_subpath_from_deno_module( .resolve_package_subpath_from_deno_module(
@ -695,10 +695,7 @@ impl CliMainWorkerFactory {
sub_path, sub_path,
/* referrer */ None, /* referrer */ None,
NodeResolutionMode::Execution, NodeResolutionMode::Execution,
)? )?;
else {
return Ok(None);
};
match &resolution { match &resolution {
NodeResolution::BuiltIn(_) => Ok(None), NodeResolution::BuiltIn(_) => Ok(None),
NodeResolution::CommonJs(specifier) | NodeResolution::Esm(specifier) => { NodeResolution::CommonJs(specifier) | NodeResolution::Esm(specifier) => {

210
ext/node/errors.rs
View file

@ -49,6 +49,8 @@ pub enum NodeJsErrorCode {
ERR_UNKNOWN_FILE_EXTENSION, ERR_UNKNOWN_FILE_EXTENSION,
ERR_UNSUPPORTED_DIR_IMPORT, ERR_UNSUPPORTED_DIR_IMPORT,
ERR_UNSUPPORTED_ESM_URL_SCHEME, ERR_UNSUPPORTED_ESM_URL_SCHEME,
/// Deno specific since Node doesn't support TypeScript.
ERR_TYPES_NOT_FOUND,
} }
impl std::fmt::Display for NodeJsErrorCode { impl std::fmt::Display for NodeJsErrorCode {
@ -70,6 +72,7 @@ impl NodeJsErrorCode {
ERR_UNKNOWN_FILE_EXTENSION => "ERR_UNKNOWN_FILE_EXTENSION", ERR_UNKNOWN_FILE_EXTENSION => "ERR_UNKNOWN_FILE_EXTENSION",
ERR_UNSUPPORTED_DIR_IMPORT => "ERR_UNSUPPORTED_DIR_IMPORT", ERR_UNSUPPORTED_DIR_IMPORT => "ERR_UNSUPPORTED_DIR_IMPORT",
ERR_UNSUPPORTED_ESM_URL_SCHEME => "ERR_UNSUPPORTED_ESM_URL_SCHEME", ERR_UNSUPPORTED_ESM_URL_SCHEME => "ERR_UNSUPPORTED_ESM_URL_SCHEME",
ERR_TYPES_NOT_FOUND => "ERR_TYPES_NOT_FOUND",
} }
} }
} }
@ -122,65 +125,98 @@ impl NodeJsErrorCoded for InvalidModuleSpecifierError {
} }
} }
kinded_err!(LegacyResolveError, LegacyResolveErrorKind);
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum LegacyMainResolveError { pub enum LegacyResolveErrorKind {
#[error(transparent)] #[error(transparent)]
PathToDeclarationUrl(PathToDeclarationUrlError), TypesNotFound(#[from] TypesNotFoundError),
#[error(transparent)]
ModuleNotFound(#[from] ModuleNotFoundError),
} }
impl NodeJsErrorCoded for LegacyMainResolveError { impl NodeJsErrorCoded for LegacyResolveError {
fn code(&self) -> NodeJsErrorCode { fn code(&self) -> NodeJsErrorCode {
match self { match self.as_kind() {
Self::PathToDeclarationUrl(e) => e.code(), LegacyResolveErrorKind::TypesNotFound(e) => e.code(),
LegacyResolveErrorKind::ModuleNotFound(e) => e.code(),
} }
} }
} }
kinded_err!(PackageFolderResolveError, PackageFolderResolveErrorKind); kinded_err!(PackageFolderResolveError, PackageFolderResolveErrorKind);
#[derive(Debug, Error)]
#[error(
"Could not find package '{}' from referrer '{}'{}.",
package_name,
referrer,
referrer_extra.as_ref().map(|r| format!(" ({})", r)).unwrap_or_default()
)]
pub struct PackageNotFoundError {
pub package_name: String,
pub referrer: ModuleSpecifier,
/// Extra information about the referrer.
pub referrer_extra: Option<String>,
}
impl NodeJsErrorCoded for PackageNotFoundError {
fn code(&self) -> NodeJsErrorCode {
NodeJsErrorCode::ERR_MODULE_NOT_FOUND
}
}
#[derive(Debug, Error)]
#[error(
"Could not find referrer npm package '{}'{}.",
referrer,
referrer_extra.as_ref().map(|r| format!(" ({})", r)).unwrap_or_default()
)]
pub struct ReferrerNotFoundError {
pub referrer: ModuleSpecifier,
/// Extra information about the referrer.
pub referrer_extra: Option<String>,
}
impl NodeJsErrorCoded for ReferrerNotFoundError {
fn code(&self) -> NodeJsErrorCode {
NodeJsErrorCode::ERR_MODULE_NOT_FOUND
}
}
#[derive(Debug, Error)]
#[error("Failed resolving '{package_name}' from referrer '{referrer}'.")]
pub struct PackageFolderResolveIoError {
pub package_name: String,
pub referrer: ModuleSpecifier,
#[source]
pub source: std::io::Error,
}
impl NodeJsErrorCoded for PackageFolderResolveIoError {
fn code(&self) -> NodeJsErrorCode {
NodeJsErrorCode::ERR_MODULE_NOT_FOUND
}
}
impl NodeJsErrorCoded for PackageFolderResolveError { impl NodeJsErrorCoded for PackageFolderResolveError {
fn code(&self) -> NodeJsErrorCode { fn code(&self) -> NodeJsErrorCode {
match self.as_kind() { match self.as_kind() {
PackageFolderResolveErrorKind::NotFoundPackage { .. } PackageFolderResolveErrorKind::PackageNotFound(e) => e.code(),
| PackageFolderResolveErrorKind::NotFoundReferrer { .. } PackageFolderResolveErrorKind::ReferrerNotFound(e) => e.code(),
| PackageFolderResolveErrorKind::Io { .. } => { PackageFolderResolveErrorKind::Io(e) => e.code(),
NodeJsErrorCode::ERR_MODULE_NOT_FOUND
}
} }
} }
} }
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum PackageFolderResolveErrorKind { pub enum PackageFolderResolveErrorKind {
#[error( #[error(transparent)]
"Could not find package '{}' from referrer '{}'{}.", PackageNotFound(#[from] PackageNotFoundError),
package_name, #[error(transparent)]
referrer, ReferrerNotFound(#[from] ReferrerNotFoundError),
referrer_extra.as_ref().map(|r| format!(" ({})", r)).unwrap_or_default() #[error(transparent)]
)] Io(#[from] PackageFolderResolveIoError),
NotFoundPackage {
package_name: String,
referrer: ModuleSpecifier,
/// Extra information about the referrer.
referrer_extra: Option<String>,
},
#[error(
"Could not find referrer npm package '{}'{}.",
referrer,
referrer_extra.as_ref().map(|r| format!(" ({})", r)).unwrap_or_default()
)]
NotFoundReferrer {
referrer: ModuleSpecifier,
/// Extra information about the referrer.
referrer_extra: Option<String>,
},
#[error("Failed resolving '{package_name}' from referrer '{referrer}'.")]
Io {
package_name: String,
referrer: ModuleSpecifier,
#[source]
source: std::io::Error,
},
} }
kinded_err!(PackageSubpathResolveError, PackageSubpathResolveErrorKind); kinded_err!(PackageSubpathResolveError, PackageSubpathResolveErrorKind);
@ -189,10 +225,8 @@ impl NodeJsErrorCoded for PackageSubpathResolveError {
fn code(&self) -> NodeJsErrorCode { fn code(&self) -> NodeJsErrorCode {
match self.as_kind() { match self.as_kind() {
PackageSubpathResolveErrorKind::PkgJsonLoad(e) => e.code(), PackageSubpathResolveErrorKind::PkgJsonLoad(e) => e.code(),
PackageSubpathResolveErrorKind::PackageFolderResolve(e) => e.code(),
PackageSubpathResolveErrorKind::Exports(e) => e.code(), PackageSubpathResolveErrorKind::Exports(e) => e.code(),
PackageSubpathResolveErrorKind::LegacyMain(e) => e.code(), PackageSubpathResolveErrorKind::LegacyResolve(e) => e.code(),
PackageSubpathResolveErrorKind::LegacyExact(e) => e.code(),
} }
} }
} }
@ -202,13 +236,9 @@ pub enum PackageSubpathResolveErrorKind {
#[error(transparent)] #[error(transparent)]
PkgJsonLoad(#[from] PackageJsonLoadError), PkgJsonLoad(#[from] PackageJsonLoadError),
#[error(transparent)] #[error(transparent)]
PackageFolderResolve(#[from] PackageFolderResolveError),
#[error(transparent)]
Exports(PackageExportsResolveError), Exports(PackageExportsResolveError),
#[error(transparent)] #[error(transparent)]
LegacyMain(LegacyMainResolveError), LegacyResolve(LegacyResolveError),
#[error(transparent)]
LegacyExact(PathToDeclarationUrlError),
} }
#[derive(Debug, Error)] #[derive(Debug, Error)]
@ -254,7 +284,7 @@ impl NodeJsErrorCoded for PackageTargetResolveError {
PackageTargetResolveErrorKind::InvalidPackageTarget(e) => e.code(), PackageTargetResolveErrorKind::InvalidPackageTarget(e) => e.code(),
PackageTargetResolveErrorKind::InvalidModuleSpecifier(e) => e.code(), PackageTargetResolveErrorKind::InvalidModuleSpecifier(e) => e.code(),
PackageTargetResolveErrorKind::PackageResolve(e) => e.code(), PackageTargetResolveErrorKind::PackageResolve(e) => e.code(),
PackageTargetResolveErrorKind::PathToDeclarationUrl(e) => e.code(), PackageTargetResolveErrorKind::TypesNotFound(e) => e.code(),
} }
} }
} }
@ -270,7 +300,7 @@ pub enum PackageTargetResolveErrorKind {
#[error(transparent)] #[error(transparent)]
PackageResolve(#[from] PackageResolveError), PackageResolve(#[from] PackageResolveError),
#[error(transparent)] #[error(transparent)]
PathToDeclarationUrl(#[from] PathToDeclarationUrlError), TypesNotFound(#[from] TypesNotFoundError),
} }
kinded_err!(PackageExportsResolveError, PackageExportsResolveErrorKind); kinded_err!(PackageExportsResolveError, PackageExportsResolveErrorKind);
@ -293,16 +323,23 @@ pub enum PackageExportsResolveErrorKind {
} }
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum PathToDeclarationUrlError { #[error(
#[error(transparent)] "[{}] Could not find types for '{}'{}",
SubPath(#[from] PackageSubpathResolveError), self.code(),
self.0.code_specifier,
self.0.maybe_referrer.as_ref().map(|r| format!(" imported from '{}'", r)).unwrap_or_default(),
)]
pub struct TypesNotFoundError(pub Box<TypesNotFoundErrorData>);
#[derive(Debug)]
pub struct TypesNotFoundErrorData {
pub code_specifier: ModuleSpecifier,
pub maybe_referrer: Option<ModuleSpecifier>,
} }
impl NodeJsErrorCoded for PathToDeclarationUrlError { impl NodeJsErrorCoded for TypesNotFoundError {
fn code(&self) -> NodeJsErrorCode { fn code(&self) -> NodeJsErrorCode {
match self { NodeJsErrorCode::ERR_TYPES_NOT_FOUND
PathToDeclarationUrlError::SubPath(e) => e.code(),
}
} }
} }
@ -441,6 +478,7 @@ impl NodeJsErrorCoded for PackageResolveError {
match self.as_kind() { match self.as_kind() {
PackageResolveErrorKind::ClosestPkgJson(e) => e.code(), PackageResolveErrorKind::ClosestPkgJson(e) => e.code(),
PackageResolveErrorKind::InvalidModuleSpecifier(e) => e.code(), PackageResolveErrorKind::InvalidModuleSpecifier(e) => e.code(),
PackageResolveErrorKind::PackageFolderResolve(e) => e.code(),
PackageResolveErrorKind::ExportsResolve(e) => e.code(), PackageResolveErrorKind::ExportsResolve(e) => e.code(),
PackageResolveErrorKind::SubpathResolve(e) => e.code(), PackageResolveErrorKind::SubpathResolve(e) => e.code(),
} }
@ -454,37 +492,49 @@ pub enum PackageResolveErrorKind {
#[error(transparent)] #[error(transparent)]
InvalidModuleSpecifier(#[from] InvalidModuleSpecifierError), InvalidModuleSpecifier(#[from] InvalidModuleSpecifierError),
#[error(transparent)] #[error(transparent)]
PackageFolderResolve(#[from] PackageFolderResolveError),
#[error(transparent)]
ExportsResolve(#[from] PackageExportsResolveError), ExportsResolve(#[from] PackageExportsResolveError),
#[error(transparent)] #[error(transparent)]
SubpathResolve(#[from] PackageSubpathResolveError), SubpathResolve(#[from] PackageSubpathResolveError),
} }
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum NodeResolveError { #[error("Failed joining '{path}' from '{base}'.")]
#[error("Failed joining '{path}' from '{base}'.")] pub struct NodeResolveRelativeJoinError {
RelativeJoinError { pub path: String,
path: String, pub base: ModuleSpecifier,
base: ModuleSpecifier, #[source]
#[source] pub source: url::ParseError,
source: url::ParseError, }
},
#[derive(Debug, Error)]
#[error("Failed resolving specifier from data url referrer.")]
pub struct DataUrlReferrerError {
#[source]
pub source: url::ParseError,
}
kinded_err!(NodeResolveError, NodeResolveErrorKind);
#[derive(Debug, Error)]
pub enum NodeResolveErrorKind {
#[error(transparent)]
RelativeJoin(#[from] NodeResolveRelativeJoinError),
#[error(transparent)] #[error(transparent)]
PackageImportsResolve(#[from] PackageImportsResolveError), PackageImportsResolve(#[from] PackageImportsResolveError),
#[error(transparent)] #[error(transparent)]
UnsupportedEsmUrlScheme(#[from] UnsupportedEsmUrlSchemeError), UnsupportedEsmUrlScheme(#[from] UnsupportedEsmUrlSchemeError),
#[error("Failed resolving specifier from data url referrer.")] #[error(transparent)]
DataUrlReferrerFailed { DataUrlReferrer(#[from] DataUrlReferrerError),
#[source]
source: url::ParseError,
},
#[error(transparent)] #[error(transparent)]
PackageResolve(#[from] PackageResolveError), PackageResolve(#[from] PackageResolveError),
#[error(transparent)] #[error(transparent)]
PathToDeclarationUrl(#[from] PathToDeclarationUrlError), TypesNotFound(#[from] TypesNotFoundError),
#[error(transparent)]
UrlToNodeResolution(#[from] UrlToNodeResolutionError),
#[error(transparent)] #[error(transparent)]
FinalizeResolution(#[from] FinalizeResolutionError), FinalizeResolution(#[from] FinalizeResolutionError),
#[error(transparent)]
UrlToNodeResolution(#[from] UrlToNodeResolutionError),
} }
kinded_err!(FinalizeResolutionError, FinalizeResolutionErrorKind); kinded_err!(FinalizeResolutionError, FinalizeResolutionErrorKind);
@ -499,6 +549,16 @@ pub enum FinalizeResolutionErrorKind {
UnsupportedDirImport(#[from] UnsupportedDirImportError), UnsupportedDirImport(#[from] UnsupportedDirImportError),
} }
impl NodeJsErrorCoded for FinalizeResolutionError {
fn code(&self) -> NodeJsErrorCode {
match self.as_kind() {
FinalizeResolutionErrorKind::InvalidModuleSpecifierError(e) => e.code(),
FinalizeResolutionErrorKind::ModuleNotFound(e) => e.code(),
FinalizeResolutionErrorKind::UnsupportedDirImport(e) => e.code(),
}
}
}
#[derive(Debug, Error)] #[derive(Debug, Error)]
#[error( #[error(
"[{}] Cannot find {} '{}'{}", "[{}] Cannot find {} '{}'{}",
@ -513,9 +573,9 @@ pub struct ModuleNotFoundError {
pub typ: &'static str, pub typ: &'static str,
} }
impl ModuleNotFoundError { impl NodeJsErrorCoded for ModuleNotFoundError {
pub fn code(&self) -> &'static str { fn code(&self) -> NodeJsErrorCode {
"ERR_MODULE_NOT_FOUND" NodeJsErrorCode::ERR_MODULE_NOT_FOUND
} }
} }

1
ext/node/lib.rs
View file

@ -46,7 +46,6 @@ pub use path::PathClean;
pub use polyfill::is_builtin_node_module; pub use polyfill::is_builtin_node_module;
pub use polyfill::SUPPORTED_BUILTIN_NODE_MODULES; pub use polyfill::SUPPORTED_BUILTIN_NODE_MODULES;
pub use polyfill::SUPPORTED_BUILTIN_NODE_MODULES_WITH_PREFIX; pub use polyfill::SUPPORTED_BUILTIN_NODE_MODULES_WITH_PREFIX;
pub use resolution::parse_npm_pkg_name;
pub use resolution::NodeModuleKind; pub use resolution::NodeModuleKind;
pub use resolution::NodeResolution; pub use resolution::NodeResolution;
pub use resolution::NodeResolutionMode; pub use resolution::NodeResolutionMode;

387
ext/node/resolution.rs
View file

@ -18,14 +18,16 @@ use deno_package_json::PackageJsonRc;
use crate::errors; use crate::errors;
use crate::errors::CanonicalizingPkgJsonDirError; use crate::errors::CanonicalizingPkgJsonDirError;
use crate::errors::ClosestPkgJsonError; use crate::errors::ClosestPkgJsonError;
use crate::errors::DataUrlReferrerError;
use crate::errors::FinalizeResolutionError; use crate::errors::FinalizeResolutionError;
use crate::errors::InvalidModuleSpecifierError; use crate::errors::InvalidModuleSpecifierError;
use crate::errors::InvalidPackageTargetError; use crate::errors::InvalidPackageTargetError;
use crate::errors::LegacyMainResolveError; use crate::errors::LegacyResolveError;
use crate::errors::ModuleNotFoundError; use crate::errors::ModuleNotFoundError;
use crate::errors::NodeJsErrorCode; use crate::errors::NodeJsErrorCode;
use crate::errors::NodeJsErrorCoded; use crate::errors::NodeJsErrorCoded;
use crate::errors::NodeResolveError; use crate::errors::NodeResolveError;
use crate::errors::NodeResolveRelativeJoinError;
use crate::errors::PackageExportsResolveError; use crate::errors::PackageExportsResolveError;
use crate::errors::PackageImportNotDefinedError; use crate::errors::PackageImportNotDefinedError;
use crate::errors::PackageImportsResolveError; use crate::errors::PackageImportsResolveError;
@ -38,11 +40,12 @@ use crate::errors::PackageSubpathResolveErrorKind;
use crate::errors::PackageTargetNotFoundError; use crate::errors::PackageTargetNotFoundError;
use crate::errors::PackageTargetResolveError; use crate::errors::PackageTargetResolveError;
use crate::errors::PackageTargetResolveErrorKind; use crate::errors::PackageTargetResolveErrorKind;
use crate::errors::PathToDeclarationUrlError;
use crate::errors::ResolveBinaryCommandsError; use crate::errors::ResolveBinaryCommandsError;
use crate::errors::ResolvePkgJsonBinExportError; use crate::errors::ResolvePkgJsonBinExportError;
use crate::errors::ResolvePkgSubpathFromDenoModuleError; use crate::errors::ResolvePkgSubpathFromDenoModuleError;
use crate::errors::TypeScriptNotSupportedInNpmError; use crate::errors::TypeScriptNotSupportedInNpmError;
use crate::errors::TypesNotFoundError;
use crate::errors::TypesNotFoundErrorData;
use crate::errors::UnsupportedDirImportError; use crate::errors::UnsupportedDirImportError;
use crate::errors::UnsupportedEsmUrlSchemeError; use crate::errors::UnsupportedEsmUrlSchemeError;
use crate::errors::UrlToNodeResolutionError; use crate::errors::UrlToNodeResolutionError;
@ -55,6 +58,7 @@ use crate::PathClean;
pub static DEFAULT_CONDITIONS: &[&str] = &["deno", "node", "import"]; pub static DEFAULT_CONDITIONS: &[&str] = &["deno", "node", "import"];
pub static REQUIRE_CONDITIONS: &[&str] = &["require", "node"]; pub static REQUIRE_CONDITIONS: &[&str] = &["require", "node"];
static TYPES_ONLY_CONDITIONS: &[&str] = &["types"];
pub type NodeModuleKind = deno_package_json::NodeModuleKind; pub type NodeModuleKind = deno_package_json::NodeModuleKind;
@ -177,23 +181,23 @@ impl NodeResolver {
referrer: &ModuleSpecifier, referrer: &ModuleSpecifier,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<NodeResolution>, NodeResolveError> { ) -> Result<NodeResolution, NodeResolveError> {
// Note: if we are here, then the referrer is an esm module // Note: if we are here, then the referrer is an esm module
// TODO(bartlomieju): skipped "policy" part as we don't plan to support it // TODO(bartlomieju): skipped "policy" part as we don't plan to support it
if crate::is_builtin_node_module(specifier) { if crate::is_builtin_node_module(specifier) {
return Ok(Some(NodeResolution::BuiltIn(specifier.to_string()))); return Ok(NodeResolution::BuiltIn(specifier.to_string()));
} }
if let Ok(url) = Url::parse(specifier) { if let Ok(url) = Url::parse(specifier) {
if url.scheme() == "data" { if url.scheme() == "data" {
return Ok(Some(NodeResolution::Esm(url))); return Ok(NodeResolution::Esm(url));
} }
if let Some(module_name) = if let Some(module_name) =
get_module_name_from_builtin_node_module_specifier(&url) get_module_name_from_builtin_node_module_specifier(&url)
{ {
return Ok(Some(NodeResolution::BuiltIn(module_name.to_string()))); return Ok(NodeResolution::BuiltIn(module_name.to_string()));
} }
let protocol = url.scheme(); let protocol = url.scheme();
@ -209,14 +213,14 @@ impl NodeResolver {
// todo(dsherret): this seems wrong // todo(dsherret): this seems wrong
if referrer.scheme() == "data" { if referrer.scheme() == "data" {
let url = referrer.join(specifier).map_err(|source| { let url = referrer
NodeResolveError::DataUrlReferrerFailed { source } .join(specifier)
})?; .map_err(|source| DataUrlReferrerError { source })?;
return Ok(Some(NodeResolution::Esm(url))); return Ok(NodeResolution::Esm(url));
} }
} }
let maybe_url = self.module_resolve( let url = self.module_resolve(
specifier, specifier,
referrer, referrer,
referrer_kind, referrer_kind,
@ -226,15 +230,19 @@ impl NodeResolver {
}, },
mode, mode,
)?; )?;
let url = match maybe_url {
Some(url) => url, let url = if mode.is_types() {
None => return Ok(None), let file_path = to_file_path(&url);
self.path_to_declaration_url(&file_path, Some(referrer), referrer_kind)?
} else {
url
}; };
let url = self.finalize_resolution(url, Some(referrer))?;
let resolve_response = self.url_to_node_resolution(url)?; let resolve_response = self.url_to_node_resolution(url)?;
// TODO(bartlomieju): skipped checking errors for commonJS resolution and // TODO(bartlomieju): skipped checking errors for commonJS resolution and
// "preserveSymlinksMain"/"preserveSymlinks" options. // "preserveSymlinksMain"/"preserveSymlinks" options.
Ok(Some(resolve_response)) Ok(resolve_response)
} }
fn module_resolve( fn module_resolve(
@ -244,12 +252,10 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, NodeResolveError> { ) -> Result<ModuleSpecifier, NodeResolveError> {
// note: if we're here, the referrer is an esm module if should_be_treated_as_relative_or_absolute_path(specifier) {
let maybe_url = if should_be_treated_as_relative_or_absolute_path(specifier) Ok(referrer.join(specifier).map_err(|err| {
{ NodeResolveRelativeJoinError {
Some(referrer.join(specifier).map_err(|err| {
NodeResolveError::RelativeJoinError {
path: specifier.to_string(), path: specifier.to_string(),
base: referrer.clone(), base: referrer.clone(),
source: err, source: err,
@ -260,7 +266,7 @@ impl NodeResolver {
.get_closest_package_json(referrer) .get_closest_package_json(referrer)
.map_err(PackageImportsResolveErrorKind::ClosestPkgJson) .map_err(PackageImportsResolveErrorKind::ClosestPkgJson)
.map_err(|err| PackageImportsResolveError(Box::new(err)))?; .map_err(|err| PackageImportsResolveError(Box::new(err)))?;
Some(self.package_imports_resolve( Ok(self.package_imports_resolve(
specifier, specifier,
Some(referrer), Some(referrer),
referrer_kind, referrer_kind,
@ -269,32 +275,16 @@ impl NodeResolver {
mode, mode,
)?) )?)
} else if let Ok(resolved) = Url::parse(specifier) { } else if let Ok(resolved) = Url::parse(specifier) {
Some(resolved) Ok(resolved)
} else { } else {
self.package_resolve( Ok(self.package_resolve(
specifier, specifier,
referrer, referrer,
referrer_kind, referrer_kind,
conditions, conditions,
mode, mode,
)? )?)
}; }
let Some(url) = maybe_url else {
return Ok(None);
};
let maybe_url = if mode.is_types() {
let file_path = to_file_path(&url);
self.path_to_declaration_url(&file_path, Some(referrer), referrer_kind)?
} else {
Some(url)
};
Ok(match maybe_url {
Some(url) => Some(self.finalize_resolution(url, Some(referrer))?),
None => None,
})
} }
fn finalize_resolution( fn finalize_resolution(
@ -369,12 +359,12 @@ impl NodeResolver {
package_subpath: Option<&str>, package_subpath: Option<&str>,
maybe_referrer: Option<&ModuleSpecifier>, maybe_referrer: Option<&ModuleSpecifier>,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<NodeResolution>, ResolvePkgSubpathFromDenoModuleError> { ) -> Result<NodeResolution, ResolvePkgSubpathFromDenoModuleError> {
let node_module_kind = NodeModuleKind::Esm; let node_module_kind = NodeModuleKind::Esm;
let package_subpath = package_subpath let package_subpath = package_subpath
.map(|s| format!("./{s}")) .map(|s| format!("./{s}"))
.unwrap_or_else(|| ".".to_string()); .unwrap_or_else(|| ".".to_string());
let maybe_resolved_url = self.resolve_package_dir_subpath( let resolved_url = self.resolve_package_dir_subpath(
package_dir, package_dir,
&package_subpath, &package_subpath,
maybe_referrer, maybe_referrer,
@ -382,14 +372,10 @@ impl NodeResolver {
DEFAULT_CONDITIONS, DEFAULT_CONDITIONS,
mode, mode,
)?; )?;
let resolved_url = match maybe_resolved_url {
Some(resolved_url) => resolved_url,
None => return Ok(None),
};
let resolve_response = self.url_to_node_resolution(resolved_url)?; let resolve_response = self.url_to_node_resolution(resolved_url)?;
// TODO(bartlomieju): skipped checking errors for commonJS resolution and // TODO(bartlomieju): skipped checking errors for commonJS resolution and
// "preserveSymlinksMain"/"preserveSymlinks" options. // "preserveSymlinksMain"/"preserveSymlinks" options.
Ok(Some(resolve_response)) Ok(resolve_response)
} }
pub fn resolve_binary_commands( pub fn resolve_binary_commands(
@ -475,7 +461,7 @@ impl NodeResolver {
path: &Path, path: &Path,
maybe_referrer: Option<&ModuleSpecifier>, maybe_referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
) -> Result<Option<ModuleSpecifier>, PathToDeclarationUrlError> { ) -> Result<ModuleSpecifier, TypesNotFoundError> {
fn probe_extensions( fn probe_extensions(
fs: &dyn deno_fs::FileSystem, fs: &dyn deno_fs::FileSystem,
path: &Path, path: &Path,
@ -525,15 +511,15 @@ impl NodeResolver {
|| lowercase_path.ends_with(".d.cts") || lowercase_path.ends_with(".d.cts")
|| lowercase_path.ends_with(".d.mts") || lowercase_path.ends_with(".d.mts")
{ {
return Ok(Some(to_file_specifier(path))); return Ok(to_file_specifier(path));
} }
if let Some(path) = if let Some(path) =
probe_extensions(&*self.fs, path, &lowercase_path, referrer_kind) probe_extensions(&*self.fs, path, &lowercase_path, referrer_kind)
{ {
return Ok(Some(to_file_specifier(&path))); return Ok(to_file_specifier(&path));
} }
if self.fs.is_dir_sync(path) { if self.fs.is_dir_sync(path) {
let maybe_resolution = self.resolve_package_dir_subpath( let resolution_result = self.resolve_package_dir_subpath(
path, path,
/* sub path */ ".", /* sub path */ ".",
maybe_referrer, maybe_referrer,
@ -543,9 +529,9 @@ impl NodeResolver {
NodeModuleKind::Cjs => REQUIRE_CONDITIONS, NodeModuleKind::Cjs => REQUIRE_CONDITIONS,
}, },
NodeResolutionMode::Types, NodeResolutionMode::Types,
)?; );
if let Some(resolution) = maybe_resolution { if let Ok(resolution) = resolution_result {
return Ok(Some(resolution)); return Ok(resolution);
} }
let index_path = path.join("index.js"); let index_path = path.join("index.js");
if let Some(path) = probe_extensions( if let Some(path) = probe_extensions(
@ -554,14 +540,17 @@ impl NodeResolver {
&index_path.to_string_lossy().to_lowercase(), &index_path.to_string_lossy().to_lowercase(),
referrer_kind, referrer_kind,
) { ) {
return Ok(Some(to_file_specifier(&path))); return Ok(to_file_specifier(&path));
} }
} }
// allow resolving .css files for types resolution // allow resolving .css files for types resolution
if lowercase_path.ends_with(".css") { if lowercase_path.ends_with(".css") {
return Ok(Some(to_file_specifier(path))); return Ok(to_file_specifier(path));
} }
Ok(None) Err(TypesNotFoundError(Box::new(TypesNotFoundErrorData {
code_specifier: to_file_specifier(path),
maybe_referrer: maybe_referrer.cloned(),
})))
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
@ -719,22 +708,32 @@ impl NodeResolver {
conditions, conditions,
mode, mode,
) { ) {
Ok(Some(url)) => Ok(url), Ok(url) => Ok(url),
Ok(None) => Err( Err(err) => match err.code() {
PackageTargetResolveErrorKind::NotFound( NodeJsErrorCode::ERR_INVALID_MODULE_SPECIFIER
PackageTargetNotFoundError { | NodeJsErrorCode::ERR_INVALID_PACKAGE_CONFIG
pkg_json_path: package_json_path.to_path_buf(), | NodeJsErrorCode::ERR_INVALID_PACKAGE_TARGET
target: export_target.to_string(), | NodeJsErrorCode::ERR_PACKAGE_IMPORT_NOT_DEFINED
maybe_referrer: maybe_referrer.map(ToOwned::to_owned), | NodeJsErrorCode::ERR_PACKAGE_PATH_NOT_EXPORTED
referrer_kind, | NodeJsErrorCode::ERR_UNKNOWN_FILE_EXTENSION
mode, | NodeJsErrorCode::ERR_UNSUPPORTED_DIR_IMPORT
}, | NodeJsErrorCode::ERR_UNSUPPORTED_ESM_URL_SCHEME
) | NodeJsErrorCode::ERR_TYPES_NOT_FOUND => {
.into(), Err(PackageTargetResolveErrorKind::PackageResolve(err).into())
), }
Err(err) => { NodeJsErrorCode::ERR_MODULE_NOT_FOUND => Err(
Err(PackageTargetResolveErrorKind::PackageResolve(err).into()) PackageTargetResolveErrorKind::NotFound(
} PackageTargetNotFoundError {
pkg_json_path: package_json_path.to_path_buf(),
target: export_target.to_string(),
maybe_referrer: maybe_referrer.map(ToOwned::to_owned),
referrer_kind,
mode,
},
)
.into(),
),
},
}; };
return match result { return match result {
@ -831,6 +830,62 @@ impl NodeResolver {
internal: bool, internal: bool,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageTargetResolveError> {
let result = self.resolve_package_target_inner(
package_json_path,
target,
subpath,
package_subpath,
maybe_referrer,
referrer_kind,
pattern,
internal,
conditions,
mode,
);
match result {
Ok(maybe_resolved) => Ok(maybe_resolved),
Err(err) => {
if mode.is_types()
&& err.code() == NodeJsErrorCode::ERR_TYPES_NOT_FOUND
&& conditions != TYPES_ONLY_CONDITIONS
{
// try resolving with just "types" conditions for when someone misconfigures
// and puts the "types" condition in the wrong place
if let Ok(Some(resolved)) = self.resolve_package_target_inner(
package_json_path,
target,
subpath,
package_subpath,
maybe_referrer,
referrer_kind,
pattern,
internal,
TYPES_ONLY_CONDITIONS,
mode,
) {
return Ok(Some(resolved));
}
}
Err(err)
}
}
}
#[allow(clippy::too_many_arguments)]
fn resolve_package_target_inner(
&self,
package_json_path: &Path,
target: &Value,
subpath: &str,
package_subpath: &str,
maybe_referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind,
pattern: bool,
internal: bool,
conditions: &[&str],
mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageTargetResolveError> { ) -> Result<Option<ModuleSpecifier>, PackageTargetResolveError> {
if let Some(target) = target.as_str() { if let Some(target) = target.as_str() {
let url = self.resolve_package_target_string( let url = self.resolve_package_target_string(
@ -847,11 +902,11 @@ impl NodeResolver {
)?; )?;
if mode.is_types() && url.scheme() == "file" { if mode.is_types() && url.scheme() == "file" {
let path = url.to_file_path().unwrap(); let path = url.to_file_path().unwrap();
return Ok(self.path_to_declaration_url( return Ok(Some(self.path_to_declaration_url(
&path, &path,
maybe_referrer, maybe_referrer,
referrer_kind, referrer_kind,
)?); )?));
} else { } else {
return Ok(Some(url)); return Ok(Some(url));
} }
@ -1069,41 +1124,37 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageResolveError> { ) -> Result<ModuleSpecifier, PackageResolveError> {
let (package_name, package_subpath, _is_scoped) = let (package_name, package_subpath, _is_scoped) =
parse_npm_pkg_name(specifier, referrer)?; parse_npm_pkg_name(specifier, referrer)?;
let Some(package_config) = self.get_closest_package_json(referrer)? else { if let Some(package_config) = self.get_closest_package_json(referrer)? {
return Ok(None); // ResolveSelf
}; if package_config.name.as_ref() == Some(&package_name) {
// ResolveSelf if let Some(exports) = &package_config.exports {
if package_config.name.as_ref() == Some(&package_name) { return self
if let Some(exports) = &package_config.exports { .package_exports_resolve(
return self &package_config.path,
.package_exports_resolve( &package_subpath,
&package_config.path, exports,
&package_subpath, Some(referrer),
exports, referrer_kind,
Some(referrer), conditions,
referrer_kind, mode,
conditions, )
mode, .map_err(|err| err.into());
) }
.map(Some)
.map_err(|err| err.into());
} }
} }
self self.resolve_package_subpath_for_package(
.resolve_package_subpath_for_package( &package_name,
&package_name, &package_subpath,
&package_subpath, referrer,
referrer, referrer_kind,
referrer_kind, conditions,
conditions, mode,
mode, )
)
.map_err(|err| err.into())
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
@ -1115,7 +1166,7 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageSubpathResolveError> { ) -> Result<ModuleSpecifier, PackageResolveError> {
let result = self.resolve_package_subpath_for_package_inner( let result = self.resolve_package_subpath_for_package_inner(
package_name, package_name,
package_subpath, package_subpath,
@ -1124,10 +1175,10 @@ impl NodeResolver {
conditions, conditions,
mode, mode,
); );
if mode.is_types() && !matches!(result, Ok(Some(_))) { if mode.is_types() && !matches!(result, Ok(ModuleSpecifier { .. })) {
// try to resolve with the @types package // try to resolve with the @types package
let package_name = types_package_name(package_name); let package_name = types_package_name(package_name);
if let Ok(Some(result)) = self.resolve_package_subpath_for_package_inner( if let Ok(result) = self.resolve_package_subpath_for_package_inner(
&package_name, &package_name,
package_subpath, package_subpath,
referrer, referrer,
@ -1135,7 +1186,7 @@ impl NodeResolver {
conditions, conditions,
mode, mode,
) { ) {
return Ok(Some(result)); return Ok(result);
} }
} }
result result
@ -1150,7 +1201,7 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageSubpathResolveError> { ) -> Result<ModuleSpecifier, PackageResolveError> {
let package_dir_path = self let package_dir_path = self
.npm_resolver .npm_resolver
.resolve_package_folder_from_package(package_name, referrer)?; .resolve_package_folder_from_package(package_name, referrer)?;
@ -1169,14 +1220,16 @@ impl NodeResolver {
// )) // ))
// Package match. // Package match.
self.resolve_package_dir_subpath( self
&package_dir_path, .resolve_package_dir_subpath(
package_subpath, &package_dir_path,
Some(referrer), package_subpath,
referrer_kind, Some(referrer),
conditions, referrer_kind,
mode, conditions,
) mode,
)
.map_err(|err| err.into())
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
@ -1188,7 +1241,7 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageSubpathResolveError> { ) -> Result<ModuleSpecifier, PackageSubpathResolveError> {
let package_json_path = package_dir_path.join("package.json"); let package_json_path = package_dir_path.join("package.json");
match self.load_package_json(&package_json_path)? { match self.load_package_json(&package_json_path)? {
Some(pkg_json) => self.resolve_package_subpath( Some(pkg_json) => self.resolve_package_subpath(
@ -1207,7 +1260,9 @@ impl NodeResolver {
referrer_kind, referrer_kind,
mode, mode,
) )
.map_err(|err| PackageSubpathResolveErrorKind::LegacyExact(err).into()), .map_err(|err| {
PackageSubpathResolveErrorKind::LegacyResolve(err).into()
}),
} }
} }
@ -1220,7 +1275,7 @@ impl NodeResolver {
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
conditions: &[&str], conditions: &[&str],
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PackageSubpathResolveError> { ) -> Result<ModuleSpecifier, PackageSubpathResolveError> {
if let Some(exports) = &package_json.exports { if let Some(exports) = &package_json.exports {
let result = self.package_exports_resolve( let result = self.package_exports_resolve(
&package_json.path, &package_json.path,
@ -1232,13 +1287,13 @@ impl NodeResolver {
mode, mode,
); );
match result { match result {
Ok(found) => return Ok(Some(found)), Ok(found) => return Ok(found),
Err(exports_err) => { Err(exports_err) => {
if mode.is_types() && package_subpath == "." { if mode.is_types() && package_subpath == "." {
return self return self
.legacy_main_resolve(package_json, referrer, referrer_kind, mode) .legacy_main_resolve(package_json, referrer, referrer_kind, mode)
.map_err(|err| { .map_err(|err| {
PackageSubpathResolveErrorKind::LegacyMain(err).into() PackageSubpathResolveErrorKind::LegacyResolve(err).into()
}); });
} }
return Err( return Err(
@ -1251,7 +1306,9 @@ impl NodeResolver {
if package_subpath == "." { if package_subpath == "." {
return self return self
.legacy_main_resolve(package_json, referrer, referrer_kind, mode) .legacy_main_resolve(package_json, referrer, referrer_kind, mode)
.map_err(|err| PackageSubpathResolveErrorKind::LegacyMain(err).into()); .map_err(|err| {
PackageSubpathResolveErrorKind::LegacyResolve(err).into()
});
} }
self self
@ -1262,7 +1319,9 @@ impl NodeResolver {
referrer_kind, referrer_kind,
mode, mode,
) )
.map_err(|err| PackageSubpathResolveErrorKind::LegacyExact(err).into()) .map_err(|err| {
PackageSubpathResolveErrorKind::LegacyResolve(err.into()).into()
})
} }
fn resolve_subpath_exact( fn resolve_subpath_exact(
@ -1272,13 +1331,13 @@ impl NodeResolver {
referrer: Option<&ModuleSpecifier>, referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PathToDeclarationUrlError> { ) -> Result<ModuleSpecifier, TypesNotFoundError> {
assert_ne!(package_subpath, "."); assert_ne!(package_subpath, ".");
let file_path = directory.join(package_subpath); let file_path = directory.join(package_subpath);
if mode.is_types() { if mode.is_types() {
Ok(self.path_to_declaration_url(&file_path, referrer, referrer_kind)?) Ok(self.path_to_declaration_url(&file_path, referrer, referrer_kind)?)
} else { } else {
Ok(Some(to_file_specifier(&file_path))) Ok(to_file_specifier(&file_path))
} }
} }
@ -1286,20 +1345,22 @@ impl NodeResolver {
&self, &self,
directory: &Path, directory: &Path,
package_subpath: &str, package_subpath: &str,
referrer: Option<&ModuleSpecifier>, maybe_referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, PathToDeclarationUrlError> { ) -> Result<ModuleSpecifier, LegacyResolveError> {
if package_subpath == "." { if package_subpath == "." {
Ok(self.legacy_index_resolve(directory, referrer_kind, mode)) self.legacy_index_resolve(directory, maybe_referrer, referrer_kind, mode)
} else { } else {
self.resolve_subpath_exact( self
directory, .resolve_subpath_exact(
package_subpath, directory,
referrer, package_subpath,
referrer_kind, maybe_referrer,
mode, referrer_kind,
) mode,
)
.map_err(|err| err.into())
} }
} }
@ -1348,7 +1409,7 @@ impl NodeResolver {
maybe_referrer: Option<&ModuleSpecifier>, maybe_referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Result<Option<ModuleSpecifier>, LegacyMainResolveError> { ) -> Result<ModuleSpecifier, LegacyResolveError> {
let maybe_main = if mode.is_types() { let maybe_main = if mode.is_types() {
match package_json.types.as_ref() { match package_json.types.as_ref() {
Some(types) => Some(types.as_str()), Some(types) => Some(types.as_str()),
@ -1357,11 +1418,14 @@ impl NodeResolver {
// a corresponding declaration file // a corresponding declaration file
if let Some(main) = package_json.main(referrer_kind) { if let Some(main) = package_json.main(referrer_kind) {
let main = package_json.path.parent().unwrap().join(main).clean(); let main = package_json.path.parent().unwrap().join(main).clean();
let maybe_decl_url = self let decl_url_result = self.path_to_declaration_url(
.path_to_declaration_url(&main, maybe_referrer, referrer_kind) &main,
.map_err(LegacyMainResolveError::PathToDeclarationUrl)?; maybe_referrer,
if let Some(path) = maybe_decl_url { referrer_kind,
return Ok(Some(path)); );
// don't surface errors, fallback to checking the index now
if let Ok(url) = decl_url_result {
return Ok(url);
} }
} }
None None
@ -1374,7 +1438,7 @@ impl NodeResolver {
if let Some(main) = maybe_main { if let Some(main) = maybe_main {
let guess = package_json.path.parent().unwrap().join(main).clean(); let guess = package_json.path.parent().unwrap().join(main).clean();
if self.fs.is_file_sync(&guess) { if self.fs.is_file_sync(&guess) {
return Ok(Some(to_file_specifier(&guess))); return Ok(to_file_specifier(&guess));
} }
// todo(dsherret): investigate exactly how node and typescript handles this // todo(dsherret): investigate exactly how node and typescript handles this
@ -1404,24 +1468,26 @@ impl NodeResolver {
.clean(); .clean();
if self.fs.is_file_sync(&guess) { if self.fs.is_file_sync(&guess) {
// TODO(bartlomieju): emitLegacyIndexDeprecation() // TODO(bartlomieju): emitLegacyIndexDeprecation()
return Ok(Some(to_file_specifier(&guess))); return Ok(to_file_specifier(&guess));
} }
} }
} }
Ok(self.legacy_index_resolve( self.legacy_index_resolve(
package_json.path.parent().unwrap(), package_json.path.parent().unwrap(),
maybe_referrer,
referrer_kind, referrer_kind,
mode, mode,
)) )
} }
fn legacy_index_resolve( fn legacy_index_resolve(
&self, &self,
directory: &Path, directory: &Path,
maybe_referrer: Option<&ModuleSpecifier>,
referrer_kind: NodeModuleKind, referrer_kind: NodeModuleKind,
mode: NodeResolutionMode, mode: NodeResolutionMode,
) -> Option<ModuleSpecifier> { ) -> Result<ModuleSpecifier, LegacyResolveError> {
let index_file_names = if mode.is_types() { let index_file_names = if mode.is_types() {
// todo(dsherret): investigate exactly how typescript does this // todo(dsherret): investigate exactly how typescript does this
match referrer_kind { match referrer_kind {
@ -1435,11 +1501,28 @@ impl NodeResolver {
let guess = directory.join(index_file_name).clean(); let guess = directory.join(index_file_name).clean();
if self.fs.is_file_sync(&guess) { if self.fs.is_file_sync(&guess) {
// TODO(bartlomieju): emitLegacyIndexDeprecation() // TODO(bartlomieju): emitLegacyIndexDeprecation()
return Some(to_file_specifier(&guess)); return Ok(to_file_specifier(&guess));
} }
} }
None if mode.is_types() {
Err(
TypesNotFoundError(Box::new(TypesNotFoundErrorData {
code_specifier: to_file_specifier(&directory.join("index.js")),
maybe_referrer: maybe_referrer.cloned(),
}))
.into(),
)
} else {
Err(
ModuleNotFoundError {
specifier: to_file_specifier(&directory.join("index.js")),
typ: "module",
maybe_referrer: maybe_referrer.cloned(),
}
.into(),
)
}
} }
} }
@ -1557,7 +1640,7 @@ fn should_be_treated_as_relative_or_absolute_path(specifier: &str) -> bool {
// TODO(ry) We very likely have this utility function elsewhere in Deno. // TODO(ry) We very likely have this utility function elsewhere in Deno.
fn is_relative_specifier(specifier: &str) -> bool { fn is_relative_specifier(specifier: &str) -> bool {
let specifier_len = specifier.len(); let specifier_len = specifier.len();
let specifier_chars: Vec<_> = specifier.chars().collect(); let specifier_chars: Vec<_> = specifier.chars().take(3).collect();
if !specifier_chars.is_empty() && specifier_chars[0] == '.' { if !specifier_chars.is_empty() && specifier_chars[0] == '.' {
if specifier_len == 1 || specifier_chars[1] == '/' { if specifier_len == 1 || specifier_chars[1] == '/' {

37
tests/integration/npm_tests.rs
View file

@ -15,13 +15,6 @@ use util::TestContextBuilder;
// NOTE: See how to make test npm packages at ./testdata/npm/README.md // NOTE: See how to make test npm packages at ./testdata/npm/README.md
itest!(esm_import_cjs_default {
args: "run --allow-read --allow-env --quiet --check=all npm/esm_import_cjs_default/main.ts",
output: "npm/esm_import_cjs_default/main.out",
envs: env_vars_for_npm_tests(),
http_server: true,
});
itest!(cjs_with_deps { itest!(cjs_with_deps {
args: "run --allow-read --allow-env npm/cjs_with_deps/main.js", args: "run --allow-read --allow-env npm/cjs_with_deps/main.js",
output: "npm/cjs_with_deps/main.out", output: "npm/cjs_with_deps/main.out",
@ -324,14 +317,6 @@ itest!(check_local {
exit_code: 1, exit_code: 1,
}); });
itest!(types_general {
args: "check --quiet npm/types/main.ts",
output: "npm/types/main.out",
envs: env_vars_for_npm_tests(),
http_server: true,
exit_code: 1,
});
itest!(types_ambient_module { itest!(types_ambient_module {
args: "check --quiet npm/types_ambient_module/main.ts", args: "check --quiet npm/types_ambient_module/main.ts",
output: "npm/types_ambient_module/main.out", output: "npm/types_ambient_module/main.out",
@ -341,27 +326,11 @@ itest!(types_ambient_module {
}); });
itest!(types_ambient_module_import_map { itest!(types_ambient_module_import_map {
args: "check --quiet --import-map=npm/types_ambient_module/import_map.json npm/types_ambient_module/main_import_map.ts", args: "check --quiet --import-map=npm/types_ambient_module/import_map.json npm/types_ambient_module/main_import_map.ts",
output: "npm/types_ambient_module/main_import_map.out", output: "npm/types_ambient_module/main_import_map.out",
envs: env_vars_for_npm_tests(),
http_server: true,
exit_code: 1,
});
itest!(no_types_cjs {
args: "check --quiet npm/no_types_cjs/main.ts",
output_str: Some(""),
exit_code: 0,
envs: env_vars_for_npm_tests(),
http_server: true,
});
itest!(no_types_in_conditional_exports {
args: "run --check npm/no_types_in_conditional_exports/main.ts",
output: "npm/no_types_in_conditional_exports/main.out",
exit_code: 0,
envs: env_vars_for_npm_tests(), envs: env_vars_for_npm_tests(),
http_server: true, http_server: true,
exit_code: 1,
}); });
itest!(types_entry_value_not_exists { itest!(types_entry_value_not_exists {

13
tests/specs/node/byonm_phantom_dep_res_failure/__test__.jsonc Normal file
View file

@ -0,0 +1,13 @@
{
"tests": {
"bad_import": {
"args": "run bad_import.ts",
"output": "bad_import.out",
"exitCode": 1
},
"good_import": {
"args": "run good_import.ts",
"output": "good_import.out"
}
}
}

2
tests/specs/node/byonm_phantom_dep_res_failure/bad_import.out Normal file
View file

@ -0,0 +1,2 @@
error: [ERR_MODULE_NOT_FOUND] Cannot find module 'file:///[WILDLINE]/node_modules/package/index.js' imported from 'file:///[WILDLINE]/bad_import.ts'
at file:///[WILDLINE]/bad_import.ts:1:16

3
tests/specs/node/byonm_phantom_dep_res_failure/bad_import.ts Normal file
View file

@ -0,0 +1,3 @@
import hi from "package";
hi();

3
tests/specs/node/byonm_phantom_dep_res_failure/deno.json Normal file
View file

@ -0,0 +1,3 @@
{
"unstable": ["byonm"]
}

1
tests/specs/node/byonm_phantom_dep_res_failure/good_import.out Normal file
View file

@ -0,0 +1 @@
hi

3
tests/specs/node/byonm_phantom_dep_res_failure/good_import.ts Normal file
View file

@ -0,0 +1,3 @@
import hi from "package/main.js";
hi();

1
tests/specs/node/byonm_phantom_dep_res_failure/node_modules/package/main.js generated vendored Normal file
View file

@ -0,0 +1 @@
module.exports = () => console.log('hi');

4
tests/specs/node/byonm_phantom_dep_res_failure/node_modules/package/package.json generated vendored Normal file
View file

@ -0,0 +1,4 @@
{
"name": "package",
"version": "1.0.0"
}

2
tests/specs/node/byonm_phantom_dep_res_failure/package.json Normal file
View file

@ -0,0 +1,2 @@
{
}

4
tests/specs/npm/esm_import_cjs_default/__test__.jsonc Normal file
View file

@ -0,0 +1,4 @@
{
"args": "run --allow-read --allow-env --check=all main.ts",
"output": "main.out"
}

7
tests/testdata/npm/esm_import_cjs_default/main.out → tests/specs/npm/esm_import_cjs_default/main.out
View file

@ -1,3 +1,10 @@
[UNORDERED_START]
Download http://localhost:4260/@denotest/esm-import-cjs-default
Download http://localhost:4260/@denotest/cjs-default-export
Download http://localhost:4260/@denotest/cjs-default-export/1.0.0.tgz
Download http://localhost:4260/@denotest/esm-import-cjs-default/1.0.0.tgz
[UNORDERED_END]
Check file:///[WILDLINE]/main.ts
Node esm importing node cjs Node esm importing node cjs
=========================== ===========================
{ {

0
tests/testdata/npm/esm_import_cjs_default/main.ts → tests/specs/npm/esm_import_cjs_default/main.ts
View file

4
tests/specs/npm/no_types_cjs/__test__.jsonc Normal file
View file

@ -0,0 +1,4 @@
{
"args": "check main.ts",
"output": "main.out"
}

3
tests/specs/npm/no_types_cjs/main.out Normal file
View file

@ -0,0 +1,3 @@
Download http://localhost:4260/@denotest/no-types-cjs
Download http://localhost:4260/@denotest/no-types-cjs/1.0.0.tgz
Check file:///[WILDLINE]/no_types_cjs/main.ts

0
tests/testdata/npm/no_types_cjs/main.ts → tests/specs/npm/no_types_cjs/main.ts
View file

4
tests/specs/npm/no_types_in_conditional_exports/__test__.jsonc Normal file
View file

@ -0,0 +1,4 @@
{
"args": "run --check main.ts",
"output": "main.out"
}

0
tests/testdata/npm/no_types_in_conditional_exports/main.out → tests/specs/npm/no_types_in_conditional_exports/main.out
View file

0
tests/testdata/npm/no_types_in_conditional_exports/main.ts → tests/specs/npm/no_types_in_conditional_exports/main.ts
View file

5
tests/specs/npm/types_general/__test__.jsonc Normal file
View file

@ -0,0 +1,5 @@
{
"args": "check main.ts",
"output": "main.out",
"exitCode": 1
}

27
tests/testdata/npm/types/main.out → tests/specs/npm/types_general/main.out
View file

@ -1,7 +1,16 @@
[UNORDERED_START]
Download http://localhost:4260/@denotest/types
Download http://localhost:4260/@denotest/types_imported
Download http://localhost:4260/@denotest/types-exports-subpaths
Download http://localhost:4260/@denotest/types_imported/1.0.0.tgz
Download http://localhost:4260/@denotest/types-exports-subpaths/1.0.0.tgz
Download http://localhost:4260/@denotest/types/1.0.0.tgz
[UNORDERED_END]
Check file:///[WILDLINE]/main.ts
error: TS2322 [ERROR]: Type 'number' is not assignable to type 'string'. error: TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
bar: 1, bar: 1,
~~~ ~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
The expected type comes from property 'bar' which is declared here on type 'Foobar' The expected type comes from property 'bar' which is declared here on type 'Foobar'
bar: string; bar: string;
@ -11,7 +20,7 @@ error: TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
TS2322 [ERROR]: Type 'number' is not assignable to type 'string'. TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
prop: 1, prop: 1,
~~~~ ~~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
The expected type comes from property 'prop' which is declared here on type 'SomeInterface' The expected type comes from property 'prop' which is declared here on type 'SomeInterface'
prop: string; prop: string;
@ -21,7 +30,7 @@ TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
TS2322 [ERROR]: Type 'string' is not assignable to type 'number'. TS2322 [ERROR]: Type 'string' is not assignable to type 'number'.
prop2: "asdf", prop2: "asdf",
~~~~~ ~~~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
The expected type comes from property 'prop2' which is declared here on type 'SomeInterface' The expected type comes from property 'prop2' which is declared here on type 'SomeInterface'
prop2: number; prop2: number;
@ -31,7 +40,7 @@ TS2322 [ERROR]: Type 'string' is not assignable to type 'number'.
TS2322 [ERROR]: Type 'number' is not assignable to type 'string'. TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
fizz: 1, fizz: 1,
~~~~ ~~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
The expected type comes from property 'fizz' which is declared here on type 'Fizzbuzz' The expected type comes from property 'fizz' which is declared here on type 'Fizzbuzz'
fizz: string; fizz: string;
@ -41,7 +50,7 @@ TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
TS2322 [ERROR]: Type 'number' is not assignable to type 'string'. TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
buzz: 2, buzz: 2,
~~~~ ~~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
The expected type comes from property 'buzz' which is declared here on type 'Fizzbuzz' The expected type comes from property 'buzz' which is declared here on type 'Fizzbuzz'
buzz: string; buzz: string;
@ -51,21 +60,21 @@ TS2322 [ERROR]: Type 'number' is not assignable to type 'string'.
TS2322 [ERROR]: Type '5' is not assignable to type '"test1"'. TS2322 [ERROR]: Type '5' is not assignable to type '"test1"'.
const valueA: "test1" = getClient(); const valueA: "test1" = getClient();
~~~~~~ ~~~~~~
at [WILDCARD]/npm/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
TS2322 [ERROR]: Type '"import"' is not assignable to type '"test2"'. TS2322 [ERROR]: Type '"import"' is not assignable to type '"test2"'.
const valueB: "test2" = entryImport(); const valueB: "test2" = entryImport();
~~~~~~ ~~~~~~
at [WILDCARD]/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
TS2322 [ERROR]: Type '12' is not assignable to type '"test3"'. TS2322 [ERROR]: Type '12' is not assignable to type '"test3"'.
const valueC: "test3" = entryA(); const valueC: "test3" = entryA();
~~~~~~ ~~~~~~
at [WILDCARD]/types/main.ts:[WILDCARD] at [WILDCARD]/main.ts:[WILDCARD]
TS2322 [ERROR]: Type '"types"' is not assignable to type '"test4"'. TS2322 [ERROR]: Type '"types"' is not assignable to type '"test4"'.
const valueD: "test4" = entryTypes(); const valueD: "test4" = entryTypes();
~~~~~~ ~~~~~~
at file:///[WILDCARD]/types/main.ts:[WILDCARD] at file:///[WILDCARD]/main.ts:[WILDCARD]
Found 9 errors. Found 9 errors.

0
tests/testdata/npm/types/main.ts → tests/specs/npm/types_general/main.ts
View file

2
tools/lint.js
View file

@ -218,7 +218,7 @@ async function ensureNoNewITests() {
"lsp_tests.rs": 0, "lsp_tests.rs": 0,
"node_compat_tests.rs": 4, "node_compat_tests.rs": 4,
"node_unit_tests.rs": 2, "node_unit_tests.rs": 2,
"npm_tests.rs": 97, "npm_tests.rs": 93,
"pm_tests.rs": 0, "pm_tests.rs": 0,
"publish_tests.rs": 0, "publish_tests.rs": 0,
"repl_tests.rs": 0, "repl_tests.rs": 0,