Merge remote-tracking branch 'upstream/main' into feat_mapping_bare_specifiers

# Conflicts:
#	deno.jsonc

Author: dsherret

README.md

@@ -726,8 +726,14 @@ await build({
 
 ### deno.json Support
 
-Starting in dnt 0.42, the deno.json is auto-discovered. A config file can be
-explicitly specified by the `configFile` key:
+Starting in dnt 0.42, the deno.json is auto-discovered by searching upwards from
+the entry points. dnt logs the config file it discovered:
+
+```
+[dnt] Auto-discovered config file: /home/david/dev/my_project/deno.json
+```
+
+A config file can be explicitly specified by the `configFile` key:
 
 ```ts
 await build({
@@ -736,6 +742,16 @@ await build({
 });
 ```
 
+Or set it to `false` to not use a config file at all, which also disables
+discovering a package.json and deno.lock:
+
+```ts
+await build({
+  // ...etc...
+  configFile: false,
+});
+```
+
 ### Frozen Lock File
 
 The deno.lock file that's beside the deno.json is used to resolve dependencies,

deno.jsonc

@@ -44,6 +44,7 @@
     "lib/pkg/",
     "rs-lib/src/polyfills/scripts/",
     "tests/bare_mapping_project/npm",
+    "tests/config_discovery_project/npm",
     "tests/declaration_import_project/npm",
     "tests/frozen_lockfile_project/npm",
     "tests/import_map_project/npm",

mod.ts

@@ -183,8 +183,15 @@ export interface BuildOptions {
   mappings?: SpecifierMappings;
   /** Package.json output. You may override dependencies and dev dependencies in here. */
   package: PackageJson;
-  /** Path or url to a deno.json. */
-  configFile?: string;
+  /** Path or url to a deno.json.
+   *
+   * When not specified, a deno.json is auto-discovered by searching upwards
+   * from the entry points.
+   *
+   * Specify `false` to disable the auto-discovery, which also disables
+   * discovering a package.json and deno.lock.
+   */
+  configFile?: string | false;
   /** Path or url to import map.
    *
    * @remarks Use `configFile` for a deno.json. Like `deno --import-map`, the
@@ -352,6 +359,13 @@ export async function build(options: BuildOptions): Promise<void> {
 
   log("Transforming...");
   const transformOutput = await transformEntryPoints();
+  if (transformOutput.discoveredConfigFile != null) {
+    log(
+      `Auto-discovered config file: ${
+        standardizePath(transformOutput.discoveredConfigFile)
+      }`,
+    );
+  }
   for (const warning of transformOutput.warnings) {
     warn(warning);
   }

rs-lib/src/lib.rs

@@ -101,6 +101,12 @@ pub struct TransformOutput {
   pub main: TransformOutputEnvironment,
   pub test: TransformOutputEnvironment,
   pub warnings: Vec<String>,
+  /// Config file that was auto-discovered by searching upwards from the
+  /// entry points (or the cwd when there are no local entry points).
+  ///
+  /// This is `None` when no config file was found, when one was explicitly
+  /// provided, or when auto-discovery is disabled.
+  pub discovered_config_file: Option<PathBuf>,
 }
 
 #[cfg_attr(feature = "serialization", derive(serde::Serialize))]
@@ -265,6 +271,11 @@ pub struct TransformOptions {
   /// over what `target` implies.
   pub polyfills: PolyfillOverrides,
   pub config_file: Option<ModuleSpecifier>,
+  /// Disables auto-discovering a config file based on the entry points
+  /// when no config file or import map is provided.
+  ///
+  /// Note this also disables discovering a package.json and deno.lock.
+  pub no_config: bool,
   pub import_map: Option<ModuleSpecifier>,
   /// Errors when the deno lockfile would need to be updated in order to
   /// transform (ex. a dependency is not in it).
@@ -333,6 +344,7 @@ pub async fn transform(
   };
   let config_discovery = match maybe_config_path.as_ref() {
     Some(config_path) => ConfigDiscoveryOption::Path(config_path.clone()),
+    None if options.no_config => ConfigDiscoveryOption::Disabled,
     None => {
       if paths.is_empty() {
         ConfigDiscoveryOption::DiscoverCwd
@@ -341,6 +353,10 @@ pub async fn transform(
       }
     }
   };
+  let is_auto_discovering = matches!(
+    config_discovery,
+    ConfigDiscoveryOption::Discover { .. } | ConfigDiscoveryOption::DiscoverCwd
+  );
 
   let factory = deno_resolver::factory::WorkspaceFactory::new(
     sys,
@@ -364,6 +380,14 @@ pub async fn transform(
       no_lock: false,
     },
   );
+  let discovered_config_file = if is_auto_discovering {
+    factory
+      .workspace_directory()?
+      .member_or_root_deno_json()
+      .and_then(|c| deno_path_util::url_to_file_path(&c.specifier).ok())
+  } else {
+    None
+  };
   let file_fetcher = PermissionedFileFetcher::new(
     NullBlobStore,
     Rc::new(factory.http_cache()?.clone()),
@@ -680,6 +704,7 @@ pub async fn transform(
     main: main_env_context.environment,
     test: test_env_context.environment,
     warnings,
+    discovered_config_file,
   })
 }
 

rs-lib/tests/integration/test_builder.rs

@@ -29,6 +29,7 @@ pub struct TestBuilder {
   target: ScriptTarget,
   polyfills: PolyfillOverrides,
   config_file: Option<ModuleSpecifier>,
+  no_config: bool,
   import_map: Option<ModuleSpecifier>,
   frozen_lockfile: Option<bool>,
 }
@@ -50,6 +51,7 @@ impl TestBuilder {
       target: ScriptTarget::ES5,
       polyfills: Default::default(),
       config_file: None,
+      no_config: false,
       import_map: None,
       frozen_lockfile: None,
     }
@@ -81,11 +83,16 @@ impl TestBuilder {
   }
 
   pub fn set_config_file(&mut self, url: impl AsRef<str>) -> &mut Self {
-    self.import_map =
+    self.config_file =
       Some(ModuleSpecifier::parse(&normalize_urls(url.as_ref())).unwrap());
     self
   }
 
+  pub fn set_no_config(&mut self, value: bool) -> &mut Self {
+    self.no_config = value;
+    self
+  }
+
   pub fn set_import_map(&mut self, url: impl AsRef<str>) -> &mut Self {
     self.import_map =
       Some(ModuleSpecifier::parse(&normalize_urls(url.as_ref())).unwrap());
@@ -218,6 +225,7 @@ impl TestBuilder {
         target: self.target,
         polyfills: self.polyfills.clone(),
         config_file: self.config_file.clone(),
+        no_config: self.no_config,
         import_map: self.import_map.clone(),
         frozen_lockfile: self.frozen_lockfile,
         cwd: self.loader.sys.env_current_dir().unwrap(),

rs-lib/tests/integration_test.rs

@@ -15,6 +15,7 @@ use pretty_assertions::assert_eq;
 #[macro_use]
 mod integration;
 
+use integration::InMemoryLoader;
 use integration::TestBuilder;
 
 use crate::integration::assert_identity_transforms;
@@ -1244,7 +1245,7 @@ async fn transform_jsr_specifier_mappings() {
 }
 
 #[tokio::test]
-async fn transform_jsr_specifier_mapping_via_import_map() {
+async fn transform_jsr_specifier_mapping_via_config_file() {
   let result = TestBuilder::new()
     .with_loader(|loader| {
       loader
@@ -1259,6 +1260,42 @@ async fn transform_jsr_specifier_mapping_via_import_map() {
         );
     })
     .set_config_file("file:///deno.json")
+    // the version requirement comes from the config file
+    .add_package_specifier_mapping("jsr:@scope/name", "scope-name", None, None)
+    .transform()
+    .await
+    .unwrap();
+
+  assert_files!(
+    result.main.files,
+    &[("mod.ts", "import * as pkg from 'scope-name';")]
+  );
+  assert_eq!(
+    result.main.dependencies,
+    &[Dependency {
+      name: "scope-name".to_string(),
+      version: "^1.0.0".to_string(),
+      peer_dependency: false,
+    }]
+  );
+}
+
+#[tokio::test]
+async fn transform_jsr_specifier_mapping_via_import_map() {
+  let result = TestBuilder::new()
+    .with_loader(|loader| {
+      loader
+        .add_local_file("/mod.ts", "import * as pkg from '@scope/name';")
+        .add_local_file(
+          "/import_map.json",
+          r#"{
+  "imports": {
+    "@scope/name": "jsr:@scope/name@^1.0.0"
+  }
+}"#,
+        );
+    })
+    .set_import_map("file:///import_map.json")
     // the version requirement comes from the import map
     .add_package_specifier_mapping("jsr:@scope/name", "scope-name", None, None)
     .transform()
@@ -1746,6 +1783,8 @@ async fn transform_import_map() {
     .await
     .unwrap();
 
+  // the import map is used as the config file, so nothing was auto-discovered
+  assert_eq!(result.discovered_config_file, None);
   assert_files!(
     result.main.files,
     &[
@@ -1996,6 +2035,8 @@ async fn transform_config_file() {
     .await
     .unwrap();
 
+  // it was provided, so it wasn't auto-discovered
+  assert_eq!(result.discovered_config_file, None);
   assert_files!(
     result.main.files,
     &[
@@ -2006,6 +2047,58 @@ async fn transform_config_file() {
   );
 }
 
+#[tokio::test]
+async fn transform_auto_discovered_config_file() {
+  let result = TestBuilder::new()
+    .with_loader(|loader| {
+      add_config_discovery_files(loader);
+    })
+    .entry_point("file:///sub_dir/mod.ts")
+    .transform()
+    .await
+    .unwrap();
+
+  assert_eq!(
+    result.discovered_config_file,
+    Some(PathBuf::from(if cfg!(windows) {
+      "C:\\deno.json"
+    } else {
+      "/deno.json"
+    }))
+  );
+  assert_files!(
+    result.main.files,
+    &[
+      ("sub_dir/mod.ts", "import * as remote from '../other.js';",),
+      ("other.ts", "export function test() {}",)
+    ]
+  );
+}
+
+#[tokio::test]
+async fn transform_no_config() {
+  let err_message = TestBuilder::new()
+    .with_loader(|loader| {
+      add_config_discovery_files(loader);
+    })
+    .entry_point("file:///sub_dir/mod.ts")
+    .set_no_config(true)
+    .transform()
+    .await
+    .err()
+    .unwrap();
+
+  // the config file should not have been discovered, so its
+  // import mapping should not have been applied
+  assert_eq!(
+    err_message.to_string(),
+    normalize_urls(
+      "Import \"localhost/mod.ts\" not a dependency
+    at file:///sub_dir/mod.ts:1:25"
+    )
+  );
+}
+
 #[tokio::test]
 async fn transform_multiple_entry_points() {
   let result = TestBuilder::new()
@@ -3021,3 +3114,22 @@ fn get_shim_file_text(mut text: String) -> String {
   );
   text
 }
+
+/// Adds a config file in a parent directory of the `/sub_dir/mod.ts`
+/// entry point so that it's only found by searching upwards from it.
+fn add_config_discovery_files(loader: &mut InMemoryLoader) {
+  loader
+    .add_local_file(
+      "/sub_dir/mod.ts",
+      "import * as remote from 'localhost/mod.ts';",
+    )
+    .add_local_file(
+      "/deno.json",
+      r#"{
+  "imports": {
+    "localhost/mod.ts": "./other.ts"
+  }
+}"#,
+    )
+    .add_local_file("/other.ts", "export function test() {}");
+}

tests/config_discovery_project/deno.json

@@ -0,0 +1,5 @@
+{
+  "imports": {
+    "@dnt/marker": "./marker.ts"
+  }
+}

tests/config_discovery_project/marker.ts

@@ -0,0 +1,3 @@
+// Copyright 2018-2024 the Deno authors. MIT license.
+
+export const marker = "marker";

tests/config_discovery_project/mod.ts

@@ -0,0 +1,7 @@
+// Copyright 2018-2024 the Deno authors. MIT license.
+
+import { marker } from "@dnt/marker";
+
+export function getMarker() {
+  return marker;
+}