feat(vendor): support using an existing import map (#14836)

2 files changed, 246 insertions, 74 deletions

diff --git a/cli/tests/integration/vendor_tests.rs b/cli/tests/integration/vendor_tests.rs
index 5737f0365..7c106c79b 100644
--- a/cli/tests/integration/vendor_tests.rs
+++ b/cli/tests/integration/vendor_tests.rs
@@ -3,20 +3,19 @@
 use deno_core::serde_json;
 use deno_core::serde_json::json;
 use pretty_assertions::assert_eq;
-use std::fs;
 use std::path::PathBuf;
 use std::process::Stdio;
 use test_util as util;
 use test_util::TempDir;
 use util::http_server;
+use util::new_deno_dir;
 
 #[test]
 fn output_dir_exists() {
   let t = TempDir::new();
-  let vendor_dir = t.path().join("vendor");
-  fs::write(t.path().join("mod.ts"), "").unwrap();
-  fs::create_dir_all(&vendor_dir).unwrap();
-  fs::write(vendor_dir.join("mod.ts"), "").unwrap();
+  t.write("mod.ts", "");
+  t.create_dir_all("vendor");
+  t.write("vendor/mod.ts", "");
 
   let deno = util::deno_cmd()
     .current_dir(t.path())
@@ -76,15 +75,12 @@ fn output_dir_exists() {
 #[test]
 fn import_map_output_dir() {
   let t = TempDir::new();
-  let vendor_dir = t.path().join("vendor");
-  fs::write(t.path().join("mod.ts"), "").unwrap();
-  fs::create_dir_all(&vendor_dir).unwrap();
-  let import_map_path = vendor_dir.join("import_map.json");
-  fs::write(
-    &import_map_path,
+  t.write("mod.ts", "");
+  t.create_dir_all("vendor");
+  t.write(
+    "vendor/import_map.json",
     "{ \"imports\": { \"https://localhost/\": \"./localhost/\" }}",
-  )
-  .unwrap();
+  );
 
   let deno = util::deno_cmd()
     .current_dir(t.path())
@@ -92,7 +88,7 @@ fn import_map_output_dir() {
     .arg("vendor")
     .arg("--force")
     .arg("--import-map")
-    .arg(import_map_path)
+    .arg("vendor/import_map.json")
     .arg("mod.ts")
     .stdout(Stdio::piped())
     .stderr(Stdio::piped())
@@ -101,7 +97,14 @@ fn import_map_output_dir() {
   let output = deno.wait_with_output().unwrap();
   assert_eq!(
     String::from_utf8_lossy(&output.stderr).trim(),
-    "error: Using an import map found in the output directory is not supported.",
+    format!(
+      concat!(
+        "error: Specifying an import map file ({}) in the deno vendor ",
+        "output directory is not supported. Please specify no import ",
+        "map or one located outside this directory.",
+      ),
+      PathBuf::from("vendor").join("import_map.json").display(),
+    ),
   );
   assert!(!output.status.success());
 }
@@ -111,10 +114,10 @@ fn standard_test() {
   let _server = http_server();
   let t = TempDir::new();
   let vendor_dir = t.path().join("vendor2");
-  fs::write(
-    t.path().join("my_app.ts"),
+  t.write(
+    "my_app.ts",
     "import {Logger} from 'http://localhost:4545/vendor/query_reexport.ts?testing'; new Logger().log('outputted');",
-  ).unwrap();
+  );
 
   let deno = util::deno_cmd()
     .current_dir(t.path())
@@ -136,7 +139,7 @@ fn standard_test() {
         "Download http://localhost:4545/vendor/logger.ts?test\n",
         "{}",
       ),
-      success_text("2 modules", "vendor2", "my_app.ts"),
+      success_text("2 modules", "vendor2", true),
     )
   );
   assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "");
@@ -144,16 +147,14 @@ fn standard_test() {
 
   assert!(vendor_dir.exists());
   assert!(!t.path().join("vendor").exists());
-  let import_map: serde_json::Value = serde_json::from_str(
-    &fs::read_to_string(vendor_dir.join("import_map.json")).unwrap(),
-  )
-  .unwrap();
+  let import_map: serde_json::Value =
+    serde_json::from_str(&t.read_to_string("vendor2/import_map.json")).unwrap();
   assert_eq!(
     import_map,
     json!({
       "imports": {
-        "http://localhost:4545/": "./localhost_4545/",
         "http://localhost:4545/vendor/query_reexport.ts?testing": "./localhost_4545/vendor/query_reexport.ts",
+        "http://localhost:4545/": "./localhost_4545/",
       },
       "scopes": {
         "./localhost_4545/": {
@@ -169,7 +170,8 @@ fn standard_test() {
     .env("NO_COLOR", "1")
     .arg("run")
     .arg("--no-remote")
-    .arg("--no-check")
+    .arg("--check")
+    .arg("--quiet")
     .arg("--import-map")
     .arg("vendor2/import_map.json")
     .arg("my_app.ts")
@@ -207,7 +209,7 @@ fn remote_module_test() {
         "Download http://localhost:4545/vendor/logger.ts?test\n",
         "{}",
       ),
-      success_text("2 modules", "vendor/", "main.ts"),
+      success_text("2 modules", "vendor/", true),
     )
   );
   assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "");
@@ -217,10 +219,8 @@ fn remote_module_test() {
     .join("localhost_4545/vendor/query_reexport.ts")
     .exists());
   assert!(vendor_dir.join("localhost_4545/vendor/logger.ts").exists());
-  let import_map: serde_json::Value = serde_json::from_str(
-    &fs::read_to_string(vendor_dir.join("import_map.json")).unwrap(),
-  )
-  .unwrap();
+  let import_map: serde_json::Value =
+    serde_json::from_str(&t.read_to_string("vendor/import_map.json")).unwrap();
   assert_eq!(
     import_map,
     json!({
@@ -229,7 +229,7 @@ fn remote_module_test() {
       },
       "scopes": {
         "./localhost_4545/": {
-          "./localhost_4545/vendor/logger.ts?test": "./localhost_4545/vendor/logger.ts"
+          "./localhost_4545/vendor/logger.ts?test": "./localhost_4545/vendor/logger.ts",
         }
       }
     }),
@@ -237,49 +237,155 @@ fn remote_module_test() {
 }
 
 #[test]
-fn existing_import_map() {
+fn existing_import_map_no_remote() {
   let _server = http_server();
   let t = TempDir::new();
-  let vendor_dir = t.path().join("vendor");
-  fs::write(
-    t.path().join("mod.ts"),
+  t.write(
+    "mod.ts",
     "import {Logger} from 'http://localhost:4545/vendor/logger.ts';",
-  )
-  .unwrap();
-  fs::write(
-    t.path().join("imports.json"),
-    r#"{ "imports": { "http://localhost:4545/vendor/": "./logger/" } }"#,
-  )
-  .unwrap();
-  fs::create_dir(t.path().join("logger")).unwrap();
-  fs::write(t.path().join("logger/logger.ts"), "export class Logger {}")
+  );
+  let import_map_filename = "imports2.json";
+  let import_map_text =
+    r#"{ "imports": { "http://localhost:4545/vendor/": "./logger/" } }"#;
+  t.write(import_map_filename, &import_map_text);
+  t.create_dir_all("logger");
+  t.write("logger/logger.ts", "export class Logger {}");
+
+  let deno = util::deno_cmd()
+    .current_dir(t.path())
+    .env("NO_COLOR", "1")
+    .arg("vendor")
+    .arg("mod.ts")
+    .arg("--import-map")
+    .arg(import_map_filename)
+    .stderr(Stdio::piped())
+    .spawn()
     .unwrap();
+  let output = deno.wait_with_output().unwrap();
+  assert_eq!(
+    String::from_utf8_lossy(&output.stderr).trim(),
+    success_text("0 modules", "vendor/", false)
+  );
+  assert!(output.status.success());
+  // it should not have found any remote dependencies because
+  // the provided import map mapped it to a local directory
+  assert_eq!(t.read_to_string(import_map_filename), import_map_text);
+}
 
-  let status = util::deno_cmd()
+#[test]
+fn existing_import_map_mixed_with_remote() {
+  let _server = http_server();
+  let deno_dir = new_deno_dir();
+  let t = TempDir::new();
+  t.write(
+    "mod.ts",
+    "import {Logger} from 'http://localhost:4545/vendor/logger.ts';",
+  );
+
+  let status = util::deno_cmd_with_deno_dir(&deno_dir)
+    .current_dir(t.path())
+    .arg("vendor")
+    .arg("mod.ts")
+    .spawn()
+    .unwrap()
+    .wait()
+    .unwrap();
+  assert!(status.success());
+
+  assert_eq!(
+    t.read_to_string("vendor/import_map.json"),
+    r#"{
+  "imports": {
+    "http://localhost:4545/": "./localhost_4545/"
+  }
+}
+"#,
+  );
+
+  // make the import map specific to support vendoring mod.ts in the next step
+  t.write(
+    "vendor/import_map.json",
+    r#"{
+  "imports": {
+    "http://localhost:4545/vendor/logger.ts": "./localhost_4545/vendor/logger.ts"
+  }
+}
+"#,
+  );
+
+  t.write(
+    "mod.ts",
+    concat!(
+      "import {Logger} from 'http://localhost:4545/vendor/logger.ts';\n",
+      "import {Logger as OtherLogger} from 'http://localhost:4545/vendor/mod.ts';\n",
+    ),
+  );
+
+  // now vendor with the existing import map in a separate vendor directory
+  let deno = util::deno_cmd_with_deno_dir(&deno_dir)
+    .env("NO_COLOR", "1")
     .current_dir(t.path())
     .arg("vendor")
     .arg("mod.ts")
     .arg("--import-map")
-    .arg("imports.json")
+    .arg("vendor/import_map.json")
+    .arg("--output")
+    .arg("vendor2")
+    .stderr(Stdio::piped())
+    .spawn()
+    .unwrap();
+  let output = deno.wait_with_output().unwrap();
+  assert_eq!(
+    String::from_utf8_lossy(&output.stderr).trim(),
+    format!(
+      concat!("Download http://localhost:4545/vendor/mod.ts\n", "{}",),
+      success_text("1 module", "vendor2", true),
+    )
+  );
+  assert!(output.status.success());
+
+  // tricky scenario here where the output directory now contains a mapping
+  // back to the previous vendor location
+  assert_eq!(
+    t.read_to_string("vendor2/import_map.json"),
+    r#"{
+  "imports": {
+    "http://localhost:4545/vendor/logger.ts": "../vendor/localhost_4545/vendor/logger.ts",
+    "http://localhost:4545/": "./localhost_4545/"
+  },
+  "scopes": {
+    "./localhost_4545/": {
+      "./localhost_4545/vendor/logger.ts": "../vendor/localhost_4545/vendor/logger.ts"
+    }
+  }
+}
+"#,
+  );
+
+  // ensure it runs
+  let status = util::deno_cmd()
+    .current_dir(t.path())
+    .arg("run")
+    .arg("--check")
+    .arg("--no-remote")
+    .arg("--import-map")
+    .arg("vendor2/import_map.json")
+    .arg("mod.ts")
     .spawn()
     .unwrap()
     .wait()
     .unwrap();
   assert!(status.success());
-  // it should not have found any remote dependencies because
-  // the provided import map mapped it to a local directory
-  assert!(!vendor_dir.join("import_map.json").exists());
 }
 
 #[test]
 fn dynamic_import() {
   let _server = http_server();
   let t = TempDir::new();
-  let vendor_dir = t.path().join("vendor");
-  fs::write(
-    t.path().join("mod.ts"),
+  t.write(
+    "mod.ts",
     "import {Logger} from 'http://localhost:4545/vendor/dynamic.ts'; new Logger().log('outputted');",
-  ).unwrap();
+  );
 
   let status = util::deno_cmd()
     .current_dir(t.path())
@@ -290,10 +396,8 @@ fn dynamic_import() {
     .wait()
     .unwrap();
   assert!(status.success());
-  let import_map: serde_json::Value = serde_json::from_str(
-    &fs::read_to_string(vendor_dir.join("import_map.json")).unwrap(),
-  )
-  .unwrap();
+  let import_map: serde_json::Value =
+    serde_json::from_str(&t.read_to_string("vendor/import_map.json")).unwrap();
   assert_eq!(
     import_map,
     json!({
@@ -310,7 +414,8 @@ fn dynamic_import() {
     .arg("run")
     .arg("--allow-read=.")
     .arg("--no-remote")
-    .arg("--no-check")
+    .arg("--check")
+    .arg("--quiet")
     .arg("--import-map")
     .arg("vendor/import_map.json")
     .arg("mod.ts")
@@ -328,10 +433,10 @@ fn dynamic_import() {
 fn dynamic_non_analyzable_import() {
   let _server = http_server();
   let t = TempDir::new();
-  fs::write(
-    t.path().join("mod.ts"),
+  t.write(
+    "mod.ts",
     "import {Logger} from 'http://localhost:4545/vendor/dynamic_non_analyzable.ts'; new Logger().log('outputted');",
-  ).unwrap();
+  );
 
   let deno = util::deno_cmd()
     .current_dir(t.path())
@@ -350,23 +455,89 @@ fn dynamic_non_analyzable_import() {
     String::from_utf8_lossy(&output.stderr).trim(),
     format!(
       "Download http://localhost:4545/vendor/dynamic_non_analyzable.ts\n{}",
-      success_text("1 module", "vendor/", "mod.ts"),
+      success_text("1 module", "vendor/", true),
     )
   );
   assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "");
   assert!(output.status.success());
 }
 
-fn success_text(module_count: &str, dir: &str, entry_point: &str) -> String {
-  format!(
-    concat!(
-      "Vendored {} into {} directory.\n\n",
-      "To use vendored modules, specify the `--import-map` flag when invoking deno subcommands:\n",
-      "  deno run -A --import-map {} {}"
-    ),
-    module_count,
-    dir,
-    PathBuf::from(dir).join("import_map.json").display(),
-    entry_point,
-  )
+#[test]
+fn update_existing_config_test() {
+  let _server = http_server();
+  let t = TempDir::new();
+  t.write(
+    "my_app.ts",
+    "import {Logger} from 'http://localhost:4545/vendor/logger.ts'; new Logger().log('outputted');",
+  );
+  t.write("deno.json", "{\n}");
+
+  let deno = util::deno_cmd()
+    .current_dir(t.path())
+    .arg("vendor")
+    .arg("my_app.ts")
+    .arg("--output")
+    .arg("vendor2")
+    .env("NO_COLOR", "1")
+    .stdout(Stdio::piped())
+    .stderr(Stdio::piped())
+    .spawn()
+    .unwrap();
+  let output = deno.wait_with_output().unwrap();
+  assert_eq!(
+    String::from_utf8_lossy(&output.stderr).trim(),
+    format!(
+      concat!(
+        "Download http://localhost:4545/vendor/logger.ts\n",
+        "Vendored 1 module into vendor2 directory.\n\n",
+        "Updated your local Deno configuration file with a reference to the ",
+        "new vendored import map at {}. Invoking Deno subcommands will ",
+        "now automatically resolve using the vendored modules. You may override ",
+        "this by providing the `--import-map <other-import-map>` flag or by ",
+        "manually editing your Deno configuration file."
+      ),
+      PathBuf::from("vendor2").join("import_map.json").display(),
+    )
+  );
+  assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "");
+  assert!(output.status.success());
+
+  // try running the output with `--no-remote` and not specifying a `--vendor`
+  let deno = util::deno_cmd()
+    .current_dir(t.path())
+    .env("NO_COLOR", "1")
+    .arg("run")
+    .arg("--no-remote")
+    .arg("--check")
+    .arg("--quiet")
+    .arg("my_app.ts")
+    .stdout(Stdio::piped())
+    .stderr(Stdio::piped())
+    .spawn()
+    .unwrap();
+  let output = deno.wait_with_output().unwrap();
+  assert_eq!(String::from_utf8_lossy(&output.stderr).trim(), "");
+  assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "outputted");
+  assert!(output.status.success());
+}
+
+fn success_text(module_count: &str, dir: &str, has_import_map: bool) -> String {
+  let mut text = format!("Vendored {} into {} directory.", module_count, dir);
+  if has_import_map {
+    text.push_str(&
+      format!(
+        concat!(
+          "\n\nTo use vendored modules, specify the `--import-map {}import_map.json` flag when ",
+          r#"invoking Deno subcommands or add an `"importMap": "<path_to_vendored_import_map>"` "#,
+          "entry to a deno.json file.",
+        ),
+        if dir != "vendor/" {
+          format!("{}{}", dir.trim_end_matches('/'), if cfg!(windows) { '\\' } else {'/'})
+        } else {
+          dir.to_string()
+        }
+      )
+    );
+  }
+  text
 }
diff --git a/cli/tests/testdata/vendor/mod.ts b/cli/tests/testdata/vendor/mod.ts
new file mode 100644
index 000000000..8824d1b2a
--- /dev/null
+++ b/cli/tests/testdata/vendor/mod.ts
@@ -0,0 +1 @@
+export * from "./logger.ts";