refactor: integrate deno_graph breaking changes (denoland#13495)

Co-authored-by: Bartek Iwańczuk <[email protected]>

cli/Cargo.toml

@@ -45,11 +45,11 @@ winapi = "=0.3.9"
 winres = "=0.1.11"
 
 [dependencies]
-deno_ast = { version = "0.9.0", features = ["bundler", "codegen", "dep_graph", "module_specifier", "proposal", "react", "sourcemap", "transforms", "transpiling", "typescript", "view", "visit"] }
+deno_ast = { version = "0.10.0", features = ["bundler", "codegen", "dep_graph", "module_specifier", "proposal", "react", "sourcemap", "transforms", "transpiling", "typescript", "view", "visit"] }
 deno_core = { version = "0.117.0", path = "../core" }
-deno_doc = "0.26.0"
-deno_graph = "0.18.0"
-deno_lint = { version = "0.22.0", features = ["docs"] }
+deno_doc = "0.28.0"
+deno_graph = "0.21.1"
+deno_lint = { version = "0.23.0", features = ["docs"] }
 deno_runtime = { version = "0.43.0", path = "../runtime" }
 
 atty = "=0.2.14"
@@ -63,7 +63,7 @@ data-url = "=0.1.1"
 dissimilar = "=1.0.2"
 dprint-plugin-json = "=0.14.0"
 dprint-plugin-markdown = "=0.12.1"
-dprint-plugin-typescript = "=0.62.0"
+dprint-plugin-typescript = "=0.62.1"
 encoding_rs = "=0.8.29"
 env_logger = "=0.8.4"
 fancy-regex = "=0.7.1"

cli/compat/esm_resolver.rs

@@ -9,6 +9,7 @@ use deno_core::serde_json::Map;
 use deno_core::serde_json::Value;
 use deno_core::url::Url;
 use deno_core::ModuleSpecifier;
+use deno_graph::source::ResolveResponse;
 use deno_graph::source::Resolver;
 use regex::Regex;
 use std::path::PathBuf;
@@ -31,24 +32,28 @@ impl Resolver for NodeEsmResolver {
  &self,
  specifier: &str,
  referrer: &ModuleSpecifier,
- ) -> Result<ModuleSpecifier, AnyError> {
+ ) -> ResolveResponse {
  // First try to resolve using import map, ignoring any errors
  if !specifier.starts_with("node:") {
  if let Some(import_map_resolver) = &self.maybe_import_map_resolver {
- if let Ok(specifier) = import_map_resolver.resolve(specifier, referrer)
- {
- return Ok(specifier);
+ let response = import_map_resolver.resolve(specifier, referrer);
+ if !matches!(response, ResolveResponse::Err(_)) {
+ return response;
  }
  }
  }
 
+ let current_dir = match std::env::current_dir() {
+ Ok(path) => path,
+ Err(err) => return ResolveResponse::Err(err.into()),
+ };
  let node_resolution =
- node_resolve(specifier, referrer.as_str(), &std::env::current_dir()?);
+ node_resolve(specifier, referrer.as_str(), &current_dir);
 
  match node_resolution {
- Ok(specifier) => {
+ Ok(resolve_response) => {
  // If node resolution succeeded, return the specifier
- Ok(specifier)
+ resolve_response
  }
  Err(err) => {
  // If node resolution failed, check if it's because of unsupported
@@ -57,11 +62,13 @@ impl Resolver for NodeEsmResolver {
  .to_string()
  .starts_with("[ERR_UNSUPPORTED_ESM_URL_SCHEME]")
  {
- return deno_core::resolve_import(specifier, referrer.as_str())
- .map_err(|err| err.into());
+ return match deno_core::resolve_import(specifier, referrer.as_str()) {
+ Ok(specifier) => ResolveResponse::Esm(specifier),
+ Err(err) => ResolveResponse::Err(err.into()),
+ };
  }
 
- Err(err)
+ ResolveResponse::Err(err)
  }
  }
  }
@@ -75,16 +82,16 @@ fn node_resolve(
  specifier: &str,
  referrer: &str,
  cwd: &std::path::Path,
-) -> Result<ModuleSpecifier, AnyError> {
+) -> Result<ResolveResponse, AnyError> {
  // TODO(bartlomieju): skipped "policy" part as we don't plan to support it
 
  if let Some(resolved) = crate::compat::try_resolve_builtin_module(specifier) {
- return Ok(resolved);
+ return Ok(ResolveResponse::Esm(resolved));
  }
 
  if let Ok(url) = Url::parse(specifier) {
  if url.scheme() == "data" {
- return Ok(url);
+ return Ok(ResolveResponse::Specifier(url));
  }
 
  let protocol = url.scheme();
@@ -95,7 +102,7 @@ fn node_resolve(
  if let Some(resolved) =
  crate::compat::try_resolve_builtin_module(&specifier)
  {
- return Ok(resolved);
+ return Ok(ResolveResponse::Esm(resolved));
  } else {
  return Err(generic_error(format!("Unknown module {}", specifier)));
  }
@@ -107,7 +114,8 @@ fn node_resolve(
 
  if referrer.starts_with("data:") {
  let referrer_url = Url::parse(referrer)?;
- return referrer_url.join(specifier).map_err(AnyError::from);
+ let url = referrer_url.join(specifier).map_err(AnyError::from)?;
+ return Ok(ResolveResponse::Specifier(url));
  }
  }
 
@@ -121,9 +129,23 @@ fn node_resolve(
  let conditions = DEFAULT_CONDITIONS;
  let url = module_resolve(specifier, &parent_url, conditions)?;
 
+ let resolve_response = if url.as_str().starts_with("http") {
+ ResolveResponse::Esm(url)
+ } else if url.as_str().ends_with(".js") {
+ let package_config = get_package_scope_config(&url)?;
+ if package_config.typ == "module" {
+ ResolveResponse::Esm(url)
+ } else {
+ ResolveResponse::CommonJs(url)
+ }
+ } else if url.as_str().ends_with(".cjs") {
+ ResolveResponse::CommonJs(url)
+ } else {
+ ResolveResponse::Esm(url)
+ };
  // TODO(bartlomieju): skipped checking errors for commonJS resolution and
  // "preserveSymlinksMain"/"preserveSymlinks" options.
- Ok(url)
+ Ok(resolve_response)
 }
 
 fn to_file_path(url: &ModuleSpecifier) -> PathBuf {
@@ -1146,20 +1168,20 @@ mod tests {
  let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
  let expected =
  Url::from_file_path(cwd.join("node_modules/foo/index.js")).unwrap();
- assert_eq!(actual, expected);
+ assert!(matches!(actual, ResolveResponse::Esm(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
 
  let actual = node_resolve(
  "data:application/javascript,console.log(\"Hello%20Deno\");",
  main.as_str(),
  &cwd,
  )
  .unwrap();
- eprintln!("actual {}", actual);
- assert_eq!(
- actual,
+ let expected =
  Url::parse("data:application/javascript,console.log(\"Hello%20Deno\");")
- .unwrap()
- );
+ .unwrap();
+ assert!(matches!(actual, ResolveResponse::Specifier(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
  }
 
  #[test]
@@ -1169,7 +1191,8 @@ mod tests {
  let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
  let expected =
  Url::from_file_path(cwd.join("node_modules/foo/index.js")).unwrap();
- assert_eq!(actual, expected);
+ matches!(actual, ResolveResponse::Esm(_));
+ assert_eq!(actual.to_result().unwrap(), expected);
  }
 
  #[test]
@@ -1179,13 +1202,15 @@ mod tests {
  let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
  let foo_js =
  Url::from_file_path(cwd.join("node_modules/foo/foo.js")).unwrap();
- assert_eq!(actual, foo_js);
+ assert!(matches!(actual, ResolveResponse::Esm(_)));
+ assert_eq!(actual.to_result().unwrap(), foo_js);
 
  let actual = node_resolve("bar", foo_js.as_str(), &cwd).unwrap();
 
  let bar_js =
  Url::from_file_path(cwd.join("node_modules/bar/bar.js")).unwrap();
- assert_eq!(actual, bar_js);
+ assert!(matches!(actual, ResolveResponse::Esm(_)));
+ assert_eq!(actual.to_result().unwrap(), bar_js);
  }
 
  #[test]
@@ -1196,12 +1221,12 @@ mod tests {
  Url::parse("https://deno.land/[email protected]/node/http.ts").unwrap();
 
  let actual = node_resolve("http", main.as_str(), &cwd).unwrap();
- println!("actual {}", actual);
- assert_eq!(actual, expected);
+ assert!(matches!(actual, ResolveResponse::Esm(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
 
  let actual = node_resolve("node:http", main.as_str(), &cwd).unwrap();
- println!("actual {}", actual);
- assert_eq!(actual, expected);
+ assert!(matches!(actual, ResolveResponse::Esm(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
  }
 
  #[test]
@@ -1214,14 +1239,16 @@ mod tests {
  cwd.join("node_modules/imports_exports/import_export.js"),
  )
  .unwrap();
- assert_eq!(actual, expected);
+ assert!(matches!(actual, ResolveResponse::CommonJs(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
 
  // check that `imports` mapping works correctly
  let cwd = testdir("conditions/node_modules/imports_exports");
  let main = Url::from_file_path(cwd.join("import_export.js")).unwrap();
  let actual = node_resolve("#dep", main.as_str(), &cwd).unwrap();
  let expected = Url::from_file_path(cwd.join("import_polyfill.js")).unwrap();
- assert_eq!(actual, expected);
+ assert!(matches!(actual, ResolveResponse::CommonJs(_)));
+ assert_eq!(actual.to_result().unwrap(), expected);
  }
 
  #[test]