[WIP] feat(update): support updating @jsr/** dependencies

Author: JamieMason

package.json

@@ -36,7 +36,10 @@
   ],
   "dependencies": {
     "cosmiconfig": "^9.0.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "@jsr/luca__cases": "0.9.9",
+    "@std/path": "npm:@jsr/std__path@^0.1.2",
+    "@std/fs": "npm:@jsr/std__fs@^0.2.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",

src/context.rs

@@ -1,6 +1,7 @@
 use {
   crate::{
     config::Config,
+    dependency::UpdateUrl,
     instance::Instance,
     packages::Packages,
     registry_client::{LiveRegistryClient, PackageMeta, RegistryClient, RegistryError},
@@ -118,20 +119,20 @@ impl Context {
     let mut all_updates_by_internal_name: HashMap<String, Vec<Specifier>> = HashMap::new();
     let mut failed_updates: Vec<String> = vec![];
 
-    for internal_name in self.get_unique_internal_names_of_updateable_dependencies() {
+    for update_url in self.get_unique_update_urls() {
       let permit = Arc::clone(&semaphore).acquire_owned().await;
       let client = Arc::clone(&client);
       let progress_bars = Arc::clone(&progress_bars);
 
       handles.push((
-        internal_name.clone(),
+        update_url.internal_name.clone(),
         spawn(async move {
           let _permit = permit;
           let progress_bar = progress_bars.add(ProgressBar::new_spinner());
           progress_bar.enable_steady_tick(Duration::from_millis(100));
           progress_bar.set_style(ProgressStyle::default_spinner());
-          progress_bar.set_message(internal_name.clone());
-          let package_meta = client.fetch(&internal_name).await;
+          progress_bar.set_message(update_url.internal_name.clone());
+          let package_meta = client.fetch(&update_url).await;
           progress_bar.finish_and_clear();
           progress_bars.remove(&progress_bar);
           package_meta
@@ -143,7 +144,7 @@ impl Context {
       match handle.await {
         Ok(result) => match result {
           Ok(package_meta) => {
-            let all_updates = all_updates_by_internal_name.entry(package_meta.name.clone()).or_default();
+            let all_updates = all_updates_by_internal_name.entry(internal_name.clone()).or_default();
             for (version, _timestamp) in package_meta.time.iter() {
               if !version.contains("created") && !version.contains("modified") {
                 all_updates.push(Specifier::new(version, None));
@@ -169,18 +170,18 @@ impl Context {
   /// Return a list of every dependency we should query the registry for
   /// updates. We use internal names in order to support dependency groups,
   /// where many dependencies can be aliased as one.
-  fn get_unique_internal_names_of_updateable_dependencies(&self) -> HashSet<String> {
+  fn get_unique_update_urls(&self) -> HashSet<UpdateUrl> {
     self
       .version_groups
       .iter()
       .filter(|group| group.matches_cli_filter)
-      .fold(HashSet::new(), |mut unique_internal_names, group| {
-        group.get_internal_names_of_updateable_dependencies().inspect(|internal_names| {
-          internal_names.iter().for_each(|internal_name| {
-            unique_internal_names.insert(internal_name.clone());
+      .fold(HashSet::new(), |mut unique_update_urls, group| {
+        group.get_update_urls().inspect(|update_urls| {
+          update_urls.iter().for_each(|url| {
+            unique_update_urls.insert(url.clone());
           });
         });
-        unique_internal_names
+        unique_update_urls
       })
   }
 }

src/dependency.rs

@@ -15,6 +15,15 @@ use {
 #[path = "dependency_test.rs"]
 mod dependency_test;
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct UpdateUrl {
+  /// The name of the dependency
+  pub internal_name: String,
+  /// @example https://registry.npmjs.org/syncpack
+  /// @example https://npm.jsr.io/@jsr/std__path
+  pub url: String,
+}
+
 #[derive(Debug)]
 pub struct Dependency {
   /// The expected version specifier which all instances of this dependency
@@ -58,8 +67,12 @@ impl Dependency {
     }
   }
 
-  pub fn is_updateable(&self) -> bool {
-    self.matches_cli_filter && self.internal_name_is_supported() && !self.has_local_instance() && !self.contains_alias_specifier()
+  pub fn get_update_url(&self) -> Option<UpdateUrl> {
+    if self.matches_cli_filter && self.internal_name_is_supported() {
+      self.instances.iter().find_map(|instance| instance.get_update_url())
+    } else {
+      None
+    }
   }
 
   pub fn add_instance(&mut self, instance: Rc<Instance>) {

src/instance.rs

@@ -1,5 +1,10 @@
+#[cfg(test)]
+#[path = "instance_test.rs"]
+mod instance_test;
+
 use {
   crate::{
+    dependency::UpdateUrl,
     dependency_type::{DependencyType, Strategy},
     instance_state::{
       FixableInstance, InstanceState, InvalidInstance, SemverGroupAndVersionConflict, SuspectInstance, UnfixableInstance, ValidInstance,
@@ -205,6 +210,52 @@ impl Instance {
       .map(|preferred_semver_range| self.descriptor.specifier.clone().with_range(preferred_semver_range))
   }
 
+  pub fn get_update_url(&self) -> Option<UpdateUrl> {
+    if self.descriptor.matches_cli_filter && !self.is_local {
+      let internal_name = &self.descriptor.internal_name;
+      let actual_name = &self.descriptor.name;
+      let raw = self.descriptor.specifier.get_raw();
+      match &self.descriptor.specifier {
+        Specifier::Alias(alias) => {
+          if let Some(aliased_name) = alias.extract_package_name() {
+            if aliased_name.starts_with("@jsr/") {
+              Some(UpdateUrl {
+                internal_name: internal_name.clone(),
+                url: format!("https://npm.jsr.io/{}", aliased_name),
+              })
+            } else if &aliased_name == actual_name {
+              Some(UpdateUrl {
+                internal_name: internal_name.clone(),
+                url: format!("https://registry.npmjs.org/{}", actual_name),
+              })
+            } else {
+              debug!("'{aliased_name}' in '{raw}' does not equal the instance name '{actual_name}', skipping update as this might create mismatches");
+              None
+            }
+          } else {
+            None
+          }
+        }
+        Specifier::BasicSemver(_) => {
+          if actual_name.starts_with("@jsr/") {
+            Some(UpdateUrl {
+              internal_name: internal_name.clone(),
+              url: format!("https://npm.jsr.io/{}", actual_name),
+            })
+          } else {
+            Some(UpdateUrl {
+              internal_name: internal_name.clone(),
+              url: format!("https://registry.npmjs.org/{}", actual_name),
+            })
+          }
+        }
+        _ => None,
+      }
+    } else {
+      None
+    }
+  }
+
   /// Does this instance's specifier match the specifier of every one of the
   /// given instances?
   pub fn already_satisfies_all(&self, instances: &[Rc<Instance>]) -> bool {

src/instance_test.rs

@@ -0,0 +1,80 @@
+use {
+  crate::{
+    dependency::UpdateUrl,
+    test::{self},
+    Context,
+  },
+  serde_json::json,
+};
+
+#[test]
+fn returns_correct_registry_update_url() {
+  let config = test::mock::config_from_mock(json!({}));
+  let packages = test::mock::packages_from_mocks(vec![json!({
+    "name": "local-package",
+    "version": "0.0.0",
+    "dependencies": {
+      "@jsr/luca__cases": "1",
+      "@lit-labs/ssr": "npm:@lit-labs/ssr@3.3.0",
+      "@luca/cases": "npm:@jsr/luca__cases@1",
+      "@std/fmt": "npm:@jsr/std__fmt@^1.0.3",
+      "@std/yaml": "npm:@jsr/std__yaml",
+      "lit": "npm:lit@3.2.1",
+    }
+  })]);
+  let registry_client = None;
+  let ctx = Context::create(config, packages, registry_client);
+
+  let get_update_url_by_name = |name: &str| {
+    ctx
+      .instances
+      .iter()
+      .find(|instance| instance.descriptor.internal_name == name)
+      .unwrap()
+      .get_update_url()
+  };
+
+  assert_eq!(get_update_url_by_name("local-package"), None);
+  assert_eq!(
+    get_update_url_by_name("@jsr/luca__cases"),
+    Some(UpdateUrl {
+      internal_name: "@jsr/luca__cases".to_string(),
+      url: "https://npm.jsr.io/@jsr/luca__cases".to_string()
+    })
+  );
+  assert_eq!(
+    get_update_url_by_name("@lit-labs/ssr"),
+    Some(UpdateUrl {
+      internal_name: "@lit-labs/ssr".to_string(),
+      url: "https://registry.npmjs.org/@lit-labs/ssr".to_string()
+    })
+  );
+  assert_eq!(
+    get_update_url_by_name("@luca/cases"),
+    Some(UpdateUrl {
+      internal_name: "@luca/cases".to_string(),
+      url: "https://npm.jsr.io/@jsr/luca__cases".to_string()
+    })
+  );
+  assert_eq!(
+    get_update_url_by_name("@std/fmt"),
+    Some(UpdateUrl {
+      internal_name: "@std/fmt".to_string(),
+      url: "https://npm.jsr.io/@jsr/std__fmt".to_string()
+    })
+  );
+  assert_eq!(
+    get_update_url_by_name("@std/yaml"),
+    Some(UpdateUrl {
+      internal_name: "@std/yaml".to_string(),
+      url: "https://npm.jsr.io/@jsr/std__yaml".to_string()
+    })
+  );
+  assert_eq!(
+    get_update_url_by_name("lit"),
+    Some(UpdateUrl {
+      internal_name: "lit".to_string(),
+      url: "https://registry.npmjs.org/lit".to_string()
+    })
+  );
+}

src/registry_client.rs

@@ -1,4 +1,5 @@
 use {
+  crate::dependency::UpdateUrl,
   log::{debug, error},
   reqwest::{header::ACCEPT, Client, StatusCode},
   serde::{Deserialize, Serialize},
@@ -8,15 +9,15 @@ use {
 
 #[derive(Error, Debug)]
 pub enum RegistryError {
-  #[error("Failed to fetch package '{name}': {source}")]
+  #[error("Failed to fetch package '{url}': {source}")]
   FetchError {
-    name: String,
+    url: String,
     #[source]
     source: Box<dyn std::error::Error + Send + Sync>,
   },
 
-  #[error("HTTP error for package '{name}': {status}")]
-  HttpError { name: String, status: StatusCode },
+  #[error("HTTP error for package '{url}': {status}")]
+  HttpError { url: String, status: StatusCode },
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -29,7 +30,7 @@ pub struct PackageMeta {
 #[async_trait::async_trait]
 pub trait RegistryClient: std::fmt::Debug + Send + Sync {
   /// Fetch latest version of a given dep
-  async fn fetch(&self, dependency_name: &str) -> Result<PackageMeta, RegistryError>;
+  async fn fetch(&self, update_url: &UpdateUrl) -> Result<PackageMeta, RegistryError>;
 }
 
 /// The real implementation of RegistryClientTrait which makes actual network
@@ -41,26 +42,25 @@ pub struct LiveRegistryClient {
 
 #[async_trait::async_trait]
 impl RegistryClient for LiveRegistryClient {
-  async fn fetch(&self, dependency_name: &str) -> Result<PackageMeta, RegistryError> {
-    let url = format!("https://registry.npmjs.org/{}", dependency_name);
-    let req = self.client.get(&url).header(ACCEPT, "application/json");
-    debug!("GET {url}");
+  async fn fetch(&self, update_url: &UpdateUrl) -> Result<PackageMeta, RegistryError> {
+    let req = self.client.get(&update_url.url).header(ACCEPT, "application/json");
+    debug!("GET {update_url:?}");
     match req.send().await {
       Ok(res) => match res.status() {
         StatusCode::OK => match res.json::<PackageMeta>().await {
           Ok(package_meta) => Ok(package_meta),
           Err(err) => Err(RegistryError::FetchError {
-            name: dependency_name.to_string(),
+            url: update_url.url.to_string(),
             source: Box::new(err),
           }),
         },
         status => Err(RegistryError::HttpError {
-          name: dependency_name.to_string(),
+          url: update_url.url.to_string(),
           status,
         }),
       },
       Err(err) => Err(RegistryError::FetchError {
-        name: dependency_name.to_string(),
+        url: update_url.url.to_string(),
         source: Box::new(err),
       }),
     }

src/specifier.rs

@@ -148,14 +148,20 @@ impl Specifier {
 
   /// Create a new instance from an npm alias specifier
   fn from_alias(value: &str, raw: String) -> Self {
-    let aliased_version = {
-      let start = value.rfind('@').unwrap() + 1;
-      value[start..].to_string()
-    };
-    let aliased_name = {
+    let (aliased_name, aliased_version) = {
       let start = value.find(':').unwrap() + 1;
-      let end = value.rfind('@').unwrap();
-      value[start..end].to_string()
+      if let Some(at_pos) = value.rfind('@') {
+        if at_pos > start {
+          // There's a version specifier
+          (value[start..at_pos].to_string(), value[at_pos + 1..].to_string())
+        } else {
+          // The @ is part of a scoped package name, no version
+          (value[start..].to_string(), String::new())
+        }
+      } else {
+        // No @ at all, unscoped package without version
+        (value[start..].to_string(), String::new())
+      }
     };
     if aliased_name.is_empty() {
       Self::Unsupported(raw::Raw { raw })
@@ -384,8 +390,8 @@ impl Specifier {
 
   /// Are both specifiers on eg. "-alpha", or neither have a release channel?
   pub fn has_same_release_channel_as(&self, other: &Specifier) -> bool {
-    if let (Specifier::BasicSemver(a), Specifier::BasicSemver(b)) = (self, other) {
-      a.node_version.pre_release.first() == b.node_version.pre_release.first()
+    if let (Some(a), Some(b)) = (self.get_node_version(), other.get_node_version()) {
+      a.pre_release.first() == b.pre_release.first()
     } else {
       false
     }
@@ -402,7 +408,7 @@ impl Specifier {
   }
 
   pub fn is_older_than(&self, other: &Specifier) -> bool {
-    if let (Specifier::BasicSemver(_), Specifier::BasicSemver(_)) = (self, other) {
+    if self.get_node_version().is_some() && other.get_node_version().is_some() {
       other > self
     } else {
       false
@@ -411,8 +417,8 @@ impl Specifier {
 
   /// Is this specifier on the same major version, but otherwise older?
   pub fn is_older_than_by_minor(&self, other: &Specifier) -> bool {
-    if let (Specifier::BasicSemver(a), Specifier::BasicSemver(b)) = (self, other) {
-      b.node_version.major == a.node_version.major && other > self
+    if let (Some(a), Some(b)) = (self.get_node_version(), other.get_node_version()) {
+      b.major == a.major && other > self
     } else {
       false
     }
@@ -421,8 +427,8 @@ impl Specifier {
   /// Is this specifier on the same major and minor version, but otherwise
   /// older?
   pub fn is_older_than_by_patch(&self, other: &Specifier) -> bool {
-    if let (Specifier::BasicSemver(a), Specifier::BasicSemver(b)) = (self, other) {
-      b.node_version.major == a.node_version.major && b.node_version.minor == a.node_version.minor && other > self
+    if let (Some(a), Some(b)) = (self.get_node_version(), other.get_node_version()) {
+      b.major == a.major && b.minor == a.minor && other > self
     } else {
       false
     }