feat: npm workspace and better Deno workspace support (#24334)

Adds much better support for the unstable Deno workspaces as well as
support for npm workspaces. npm workspaces is still lacking in that we
only install packages into the root node_modules folder. We'll make it
smarter over time in order for it to figure out when to add node_modules
folders within packages.

This includes a breaking change in config file resolution where we stop
searching for config files on the first found package.json unless it's
in a workspace. For the previous behaviour, the root deno.json needs to
be updated to be a workspace by adding `"workspace":
["./path-to-pkg-json-folder-goes-here"]`. See details in
https://github.com/denoland/deno_config/pull/66

Closes #24340
Closes #24159
Closes #24161
Closes #22020
Closes #18546
Closes #16106
Closes #24160

4 files changed, 41 insertions, 30 deletions

diff --git a/cli/tools/vendor/build.rs b/cli/tools/vendor/build.rs
index 5aef63192..a4424e3f3 100644
--- a/cli/tools/vendor/build.rs
+++ b/cli/tools/vendor/build.rs
@@ -81,8 +81,8 @@ pub async fn build<
     build_graph,
     parsed_source_cache,
     output_dir,
-    maybe_original_import_map: original_import_map,
-    maybe_jsx_import_source: jsx_import_source,
+    maybe_original_import_map,
+    maybe_jsx_import_source,
     resolver,
     environment,
   } = input;
@@ -90,12 +90,12 @@ pub async fn build<
   let output_dir_specifier =
     ModuleSpecifier::from_directory_path(output_dir).unwrap();
 
-  if let Some(original_im) = &original_import_map {
+  if let Some(original_im) = &maybe_original_import_map {
     validate_original_import_map(original_im, &output_dir_specifier)?;
   }
 
   // add the jsx import source to the entry points to ensure it is always vendored
-  if let Some(jsx_import_source) = jsx_import_source {
+  if let Some(jsx_import_source) = maybe_jsx_import_source {
     if let Some(specifier_text) = jsx_import_source.maybe_specifier_text() {
       if let Ok(specifier) = resolver.resolve(
         &specifier_text,
@@ -171,8 +171,8 @@ pub async fn build<
       graph: &graph,
       modules: &all_modules,
       mappings: &mappings,
-      original_import_map,
-      jsx_import_source,
+      maybe_original_import_map,
+      maybe_jsx_import_source,
       resolver,
       parsed_source_cache,
     })?;
diff --git a/cli/tools/vendor/import_map.rs b/cli/tools/vendor/import_map.rs
index 68f2530d7..644e84a7b 100644
--- a/cli/tools/vendor/import_map.rs
+++ b/cli/tools/vendor/import_map.rs
@@ -59,7 +59,7 @@ impl<'a> ImportMapBuilder<'a> {
 
   pub fn into_import_map(
     self,
-    original_import_map: Option<&ImportMap>,
+    maybe_original_import_map: Option<&ImportMap>,
   ) -> ImportMap {
     fn get_local_imports(
       new_relative_path: &str,
@@ -99,7 +99,7 @@ impl<'a> ImportMapBuilder<'a> {
 
     let mut import_map = ImportMap::new(self.base_dir.clone());
 
-    if let Some(original_im) = original_import_map {
+    if let Some(original_im) = maybe_original_import_map {
       let original_base_dir = ModuleSpecifier::from_directory_path(
         original_im
           .base_url()
@@ -183,8 +183,8 @@ pub struct BuildImportMapInput<'a> {
   pub modules: &'a [&'a Module],
   pub graph: &'a ModuleGraph,
   pub mappings: &'a Mappings,
-  pub original_import_map: Option<&'a ImportMap>,
-  pub jsx_import_source: Option<&'a JsxImportSourceConfig>,
+  pub maybe_original_import_map: Option<&'a ImportMap>,
+  pub maybe_jsx_import_source: Option<&'a JsxImportSourceConfig>,
   pub resolver: &'a dyn deno_graph::source::Resolver,
   pub parsed_source_cache: &'a ParsedSourceCache,
 }
@@ -197,8 +197,8 @@ pub fn build_import_map(
     modules,
     graph,
     mappings,
-    original_import_map,
-    jsx_import_source,
+    maybe_original_import_map,
+    maybe_jsx_import_source,
     resolver,
     parsed_source_cache,
   } = input;
@@ -212,7 +212,7 @@ pub fn build_import_map(
   }
 
   // add the jsx import source to the destination import map, if mapped in the original import map
-  if let Some(jsx_import_source) = jsx_import_source {
+  if let Some(jsx_import_source) = maybe_jsx_import_source {
     if let Some(specifier_text) = jsx_import_source.maybe_specifier_text() {
       if let Ok(resolved_url) = resolver.resolve(
         &specifier_text,
@@ -228,7 +228,7 @@ pub fn build_import_map(
     }
   }
 
-  Ok(builder.into_import_map(original_import_map).to_json())
+  Ok(builder.into_import_map(maybe_original_import_map).to_json())
 }
 
 fn visit_modules(
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index a8d8000d8..2dfa71c44 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -48,10 +48,17 @@ pub async fn vendor(
   validate_options(&mut cli_options, &output_dir)?;
   let factory = CliFactory::from_cli_options(Arc::new(cli_options));
   let cli_options = factory.cli_options();
+  if cli_options.workspace.config_folders().len() > 1 {
+    bail!("deno vendor is not supported in a workspace. Set `\"vendor\": true` in the workspace deno.json file instead");
+  }
   let entry_points =
     resolve_entry_points(&vendor_flags, cli_options.initial_cwd())?;
-  let jsx_import_source = cli_options.to_maybe_jsx_import_source_config()?;
+  let jsx_import_source =
+    cli_options.workspace.to_maybe_jsx_import_source_config()?;
   let module_graph_creator = factory.module_graph_creator().await?.clone();
+  let workspace_resolver = factory.workspace_resolver().await?;
+  let root_folder = cli_options.workspace.root_folder().1;
+  let maybe_config_file = root_folder.deno_json.as_ref();
   let output = build::build(build::BuildInput {
     entry_points,
     build_graph: move |entry_points| {
@@ -64,7 +71,7 @@ pub async fn vendor(
     },
     parsed_source_cache: factory.parsed_source_cache(),
     output_dir: &output_dir,
-    maybe_original_import_map: factory.maybe_import_map().await?.as_deref(),
+    maybe_original_import_map: workspace_resolver.maybe_import_map(),
     maybe_jsx_import_source: jsx_import_source.as_ref(),
     resolver: factory.resolver().await?.as_graph_resolver(),
     environment: &build::RealVendorEnvironment,
@@ -91,7 +98,7 @@ pub async fn vendor(
   let try_add_import_map = vendored_count > 0;
   let modified_result = maybe_update_config_file(
     &output_dir,
-    cli_options,
+    maybe_config_file,
     try_add_import_map,
     try_add_node_modules_dir,
   );
@@ -100,8 +107,9 @@ pub async fn vendor(
   if modified_result.added_node_modules_dir {
     let node_modules_path =
       cli_options.node_modules_dir_path().cloned().or_else(|| {
-        cli_options
-          .maybe_config_file_specifier()
+        maybe_config_file
+          .as_ref()
+          .map(|d| &d.specifier)
           .filter(|c| c.scheme() == "file")
           .and_then(|c| c.to_file_path().ok())
           .map(|config_path| config_path.parent().unwrap().join("node_modules"))
@@ -176,7 +184,7 @@ fn validate_options(
   let import_map_specifier = options
     .resolve_specified_import_map_specifier()?
     .or_else(|| {
-      let config_file = options.maybe_config_file().as_ref()?;
+      let config_file = options.workspace.root_folder().1.deno_json.as_ref()?;
       config_file
         .to_import_map_specifier()
         .ok()
@@ -229,12 +237,12 @@ fn validate_options(
 
 fn maybe_update_config_file(
   output_dir: &Path,
-  options: &CliOptions,
+  maybe_config_file: Option<&Arc<ConfigFile>>,
   try_add_import_map: bool,
   try_add_node_modules_dir: bool,
 ) -> ModifiedResult {
   assert!(output_dir.is_absolute());
-  let config_file = match options.maybe_config_file() {
+  let config_file = match maybe_config_file {
     Some(config_file) => config_file,
     None => return ModifiedResult::default(),
   };
@@ -245,7 +253,6 @@ fn maybe_update_config_file(
   let fmt_config_options = config_file
     .to_fmt_config()
     .ok()
-    .flatten()
     .map(|config| config.options)
     .unwrap_or_default();
   let result = update_config_file(
diff --git a/cli/tools/vendor/test.rs b/cli/tools/vendor/test.rs
index 830d5f8f0..ac07c47d1 100644
--- a/cli/tools/vendor/test.rs
+++ b/cli/tools/vendor/test.rs
@@ -8,6 +8,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use deno_ast::ModuleSpecifier;
+use deno_config::workspace::WorkspaceResolver;
 use deno_core::anyhow::anyhow;
 use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
@@ -182,7 +183,7 @@ pub struct VendorOutput {
 pub struct VendorTestBuilder {
   entry_points: Vec<ModuleSpecifier>,
   loader: TestLoader,
-  original_import_map: Option<ImportMap>,
+  maybe_original_import_map: Option<ImportMap>,
   environment: TestVendorEnvironment,
   jsx_import_source_config: Option<JsxImportSourceConfig>,
 }
@@ -207,7 +208,7 @@ impl VendorTestBuilder {
     &mut self,
     import_map: ImportMap,
   ) -> &mut Self {
-    self.original_import_map = Some(import_map);
+    self.maybe_original_import_map = Some(import_map);
     self
   }
 
@@ -234,7 +235,7 @@ impl VendorTestBuilder {
     let parsed_source_cache = ParsedSourceCache::default();
     let resolver = Arc::new(build_resolver(
       self.jsx_import_source_config.clone(),
-      self.original_import_map.clone(),
+      self.maybe_original_import_map.clone(),
     ));
     super::build::build(super::build::BuildInput {
       entry_points,
@@ -257,7 +258,7 @@ impl VendorTestBuilder {
       },
       parsed_source_cache: &parsed_source_cache,
       output_dir: &output_dir,
-      maybe_original_import_map: self.original_import_map.as_ref(),
+      maybe_original_import_map: self.maybe_original_import_map.as_ref(),
       maybe_jsx_import_source: self.jsx_import_source_config.as_ref(),
       resolver: resolver.as_graph_resolver(),
       environment: &self.environment,
@@ -287,15 +288,18 @@ impl VendorTestBuilder {
 
 fn build_resolver(
   maybe_jsx_import_source_config: Option<JsxImportSourceConfig>,
-  original_import_map: Option<ImportMap>,
+  maybe_original_import_map: Option<ImportMap>,
 ) -> CliGraphResolver {
   CliGraphResolver::new(CliGraphResolverOptions {
     node_resolver: None,
     npm_resolver: None,
     sloppy_imports_resolver: None,
-    package_json_deps_provider: Default::default(),
+    workspace_resolver: Arc::new(WorkspaceResolver::new_raw(
+      maybe_original_import_map,
+      Vec::new(),
+      deno_config::workspace::PackageJsonDepResolution::Enabled,
+    )),
     maybe_jsx_import_source_config,
-    maybe_import_map: original_import_map.map(Arc::new),
     maybe_vendor_dir: None,
     bare_node_builtins_enabled: false,
   })