feat: strip jsr meta module graph data on global to local copy (#78)

Author: dsherret

rs_lib/src/lib.rs

@@ -46,6 +46,7 @@ pub mod wasm {
   use sys_traits::impls::wasm_path_to_str;
   use sys_traits::impls::wasm_string_to_path;
   use sys_traits::impls::RealSys;
+  use sys_traits::EnvVar;
   use url::Url;
   use wasm_bindgen::prelude::*;
 
@@ -131,6 +132,15 @@ pub mod wasm {
       console_error_panic_hook::set_once();
       let global =
         crate::GlobalHttpCache::new(RealSys, wasm_string_to_path(global_path));
+      let jsr_url = RealSys
+        .env_var("JSR_URL")
+        .ok()
+        .and_then(|url| {
+          // ensure there is a trailing slash for the directory
+          let registry_url = format!("{}/", url.trim_end_matches('/'));
+          Url::parse(&registry_url).ok()
+        })
+        .unwrap_or_else(|| Url::parse("https://jsr.io/").unwrap());
       let local = crate::LocalHttpCache::new(
         wasm_string_to_path(local_path),
         new_rc(global),
@@ -139,6 +149,7 @@ pub mod wasm {
         } else {
           GlobalToLocalCopy::Disallow
         },
+        jsr_url,
       );
       Self { cache: local }
     }

rs_lib/src/local.rs

@@ -103,6 +103,7 @@ impl<TSys: LocalHttpCacheSys> LocalLspHttpCache<TSys> {
         // 2. We need to verify the checksums for JSR https specifiers match what
         //    is found in the package's manifest.
         allow_global_to_local: GlobalToLocalCopy::Disallow,
+        jsr_registry_url: None, // only used when GlobalToLocalCopy::Allow
       },
     }
   }
@@ -250,13 +251,15 @@ pub struct LocalHttpCache<TSys: LocalHttpCacheSys> {
   manifest: LocalCacheManifest<TSys>,
   global_cache: GlobalHttpCacheRc<TSys>,
   allow_global_to_local: GlobalToLocalCopy,
+  jsr_registry_url: Option<Url>,
 }
 
 impl<TSys: LocalHttpCacheSys> LocalHttpCache<TSys> {
   pub fn new(
     path: PathBuf,
     global_cache: GlobalHttpCacheRc<TSys>,
     allow_global_to_local: GlobalToLocalCopy,
+    jsr_registry_url: Url,
   ) -> Self {
     #[cfg(not(feature = "wasm"))]
     assert!(path.is_absolute());
@@ -269,6 +272,7 @@ impl<TSys: LocalHttpCacheSys> LocalHttpCache<TSys> {
       manifest,
       global_cache,
       allow_global_to_local,
+      jsr_registry_url: Some(jsr_registry_url),
     }
   }
 
@@ -332,6 +336,54 @@ impl<TSys: LocalHttpCacheSys> LocalHttpCache<TSys> {
       Ok(None)
     }
   }
+
+  fn transform_content_on_copy_to_local(
+    &self,
+    url: &Url,
+    content: Cow<'static, [u8]>,
+  ) -> Cow<'static, [u8]> {
+    let Some(jsr_url) = &self.jsr_registry_url else {
+      return content;
+    };
+    if is_jsr_version_metadata_url(url, jsr_url) {
+      if let Some(data) = transform_jsr_version_metadata(&content) {
+        return Cow::Owned(data);
+      }
+    }
+    content
+  }
+}
+
+fn is_jsr_version_metadata_url(url: &Url, jsr_url: &Url) -> bool {
+  // example url: https://jsr.io/@david/dax/0.43.0_meta.json
+  let Some(suffix) = url.as_str().strip_prefix(jsr_url.as_str()) else {
+    return false;
+  };
+  let Some(suffix) = suffix.strip_prefix('@') else {
+    return false;
+  };
+  let Some(prefix) = suffix.strip_suffix("_meta.json") else {
+    return false;
+  };
+  prefix.chars().filter(|c| *c == '/').count() == 2
+}
+
+fn transform_jsr_version_metadata(content: &[u8]) -> Option<Vec<u8>> {
+  let mut json_data =
+    serde_json::from_slice::<serde_json::Value>(content).ok()?;
+  let obj = json_data.as_object_mut()?;
+  let keys_to_remove = obj
+    .keys()
+    .filter(|k| k.starts_with("moduleGraph"))
+    .cloned()
+    .collect::<Vec<_>>();
+  if keys_to_remove.is_empty() {
+    return None;
+  }
+  for key in keys_to_remove {
+    obj.remove(&key);
+  }
+  serde_json::to_vec(&json_data).ok()
 }
 
 impl<TSys: LocalHttpCacheSys> HttpCache for LocalHttpCache<TSys> {
@@ -434,13 +486,15 @@ impl<TSys: LocalHttpCacheSys> HttpCache for LocalHttpCache<TSys> {
                 let maybe_global_cache_file =
                   self.global_cache.get(&global_key, maybe_checksum)?;
                 if let Some(file) = maybe_global_cache_file {
+                  let content = self
+                    .transform_content_on_copy_to_local(&key.url, file.content);
                   atomic_write_file_with_retries(
                     self.env(),
                     &local_file_path,
-                    &file.content,
+                    &content,
                     CACHE_PERM,
                   )?;
-                  file.content
+                  content
                 } else {
                   return Ok(None);
                 }
@@ -1054,6 +1108,7 @@ mod test {
         local_temp.clone(),
         global_cache.clone(),
         GlobalToLocalCopy::Allow,
+        Url::parse("https://jsr.io/").unwrap(),
       ));
       Self {
         global_cache,
@@ -1216,4 +1271,60 @@ mod test {
       Ok(None)
     ));
   }
+
+  #[test]
+  fn test_copy_version_metadata_file() {
+    let test_caches = TestCaches::new();
+    let metadata_url =
+      Url::parse("https://jsr.io/@david/dax/1.2.3_meta.json").unwrap();
+    let data =
+      r#"{ "moduleGraph2": "testing", "checksums": { "test": "test" } }"#;
+    test_caches
+      .global_cache
+      .set(&metadata_url, Default::default(), data.as_bytes())
+      .unwrap();
+    let key = test_caches
+      .local_cache
+      .cache_item_key(&metadata_url)
+      .unwrap();
+    let final_data = test_caches.local_cache.get(&key, None).unwrap().unwrap();
+    assert_eq!(
+      String::from_utf8(final_data.content.to_vec()).unwrap(),
+      // had the moduleGraph2 property stripped
+      r#"{"checksums":{"test":"test"}}"#
+    );
+  }
+
+  #[test]
+  fn test_is_jsr_version_metadata_url() {
+    let cases = [
+      ("https://jsr.io/@test/test/1.2.3_meta.json", true),
+      ("https://jsr.io/@test/test/test/1.2.3_meta.json", false),
+      ("https://jsr.io/@test/test/meta.json", false),
+      ("https://jsr.io/test/test/1.2.3_meta.json", false),
+      ("https://jsr.com/@test/test/1.2.3_meta.json", false),
+    ];
+    let jsr_url = Url::parse("https://jsr.io/").unwrap();
+    for (url, expected) in cases {
+      let value =
+        is_jsr_version_metadata_url(&Url::parse(url).unwrap(), &jsr_url);
+      assert_eq!(value, expected);
+    }
+  }
+
+  #[test]
+  fn test_transform_jsr_version_metadata() {
+    let cases = [
+      (
+        r#"{ "moduleGraph1": "data", "moduleGraph2": "data", "moduleGraph3": "data", "other": "data" }"#,
+        Some(r#"{"other":"data"}"#),
+      ),
+      (r#"{ "other": "data" }"#, None),
+    ];
+
+    for (input, expected) in cases {
+      let output = transform_jsr_version_metadata(input.as_bytes());
+      assert_eq!(output.as_deref(), expected.map(|e| e.as_bytes()))
+    }
+  }
 }

rs_lib/tests/integration_test.rs

@@ -18,6 +18,10 @@ use sys_traits::impls::RealSys;
 use tempfile::TempDir;
 use url::Url;
 
+fn jsr_url() -> Url {
+  Url::parse("https://jsr.io/").unwrap()
+}
+
 #[test]
 fn test_global_create_cache() {
   let dir = TempDir::new().unwrap();
@@ -110,6 +114,7 @@ fn test_local_global_cache() {
     local_cache_path.clone(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
 
   let manifest_file_path = local_cache_path.join("manifest.json");
@@ -256,6 +261,7 @@ fn test_local_global_cache() {
     local_cache_path.clone(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
 
   // now try caching a file with many headers
@@ -322,6 +328,7 @@ fn test_local_global_cache() {
       local_cache_path.to_path_buf(),
       global_cache.clone(),
       GlobalToLocalCopy::Allow,
+      jsr_url(),
     ));
   }
 
@@ -331,6 +338,7 @@ fn test_local_global_cache() {
     local_cache_path.clone(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
 
   // try a file that can't be mapped to the file system
@@ -388,6 +396,7 @@ fn test_local_global_cache() {
         local_cache_path.to_path_buf(),
         global_cache.clone(),
         GlobalToLocalCopy::Allow,
+        jsr_url(),
       );
       assert_eq!(
         String::from_utf8(
@@ -423,6 +432,7 @@ fn test_local_global_cache() {
     local_cache_path.clone(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
 
   // now try a redirect
@@ -461,6 +471,7 @@ fn test_local_global_cache() {
     local_cache_path.clone(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
   let url = Url::parse("https://deno.land/x/mod.ts").unwrap();
   let matching_checksum =
@@ -530,6 +541,7 @@ fn test_lsp_local_cache() {
     local_cache_path.to_path_buf(),
     global_cache.clone(),
     GlobalToLocalCopy::Allow,
+    jsr_url(),
   );
   let create_readonly_cache = || {
     LocalLspHttpCache::new(local_cache_path.to_path_buf(), global_cache.clone())