refactor(registry): inject NpmrcConfig and consolidate URL resolution

Make NpmrcConfig injectable into LiveRegistryClient for testability
and future reuse. Consolidate registry URL resolution into a single
resolve_url() method. Remove unused imports from update command.

Author: evaliyev

src/commands/update.rs

@@ -1,10 +1,6 @@
 use {
-  crate::{
-    commands::{ui, ui::LINE_ENDING},
-    context::Context,
-    version_group::VersionGroupVariant,
-  },
-  log::{error, warn},
+  crate::{commands::ui, context::Context, version_group::VersionGroupVariant},
+  log::error,
 };
 
 pub fn run(ctx: Context) -> i32 {

src/instance.rs

@@ -301,13 +301,7 @@ impl Instance {
         Specifier::Alias(alias) => {
           let aliased_name = &alias.name;
           if !aliased_name.is_empty() {
-            // JSR aliases are always fetched (they have their own namespace)
-            if aliased_name.starts_with("@jsr/") {
-              Some(UpdateUrl {
-                internal_name: internal_name.clone(),
-                package_name: aliased_name.clone(),
-              })
-            } else if aliased_name == actual_name {
+            if aliased_name.starts_with("@jsr/") || aliased_name == actual_name {
               Some(UpdateUrl {
                 internal_name: internal_name.clone(),
                 package_name: aliased_name.clone(),

src/main.rs

@@ -71,13 +71,11 @@ async fn main() {
   }
 
   let registry_client = if is_update_command {
-    match LiveRegistryClient::new() {
-      Ok(client) => Some(Arc::new(client) as Arc<dyn crate::registry_client::RegistryClient>),
-      Err(e) => {
-        error!("Failed to initialize registry client: {e}");
-        exit(1);
-      }
-    }
+    let npmrc = npmrc_config_rs::NpmrcConfig::load().unwrap_or_else(|e| {
+      error!("Failed to load .npmrc config: {e}");
+      exit(1);
+    });
+    Some(Arc::new(LiveRegistryClient::new(npmrc)) as Arc<dyn crate::registry_client::RegistryClient>)
   } else {
     None
   };

src/registry_client.rs

@@ -23,9 +23,6 @@ pub enum RegistryError {
 
   #[error("HTTP error for package '{url}': {status}")]
   HttpError { url: String, status: StatusCode },
-
-  #[error("Failed to load .npmrc config: {0}")]
-  NpmrcLoadError(#[from] npmrc_config_rs::Error),
 }
 
 /// Registry responses such as https://registry.npmjs.org/colors
@@ -60,18 +57,10 @@ pub struct LiveRegistryClient {
 #[async_trait::async_trait]
 impl RegistryClient for LiveRegistryClient {
   async fn fetch(&self, update_url: &UpdateUrl) -> Result<AllPackageVersions, RegistryError> {
-    // Build full URL from package name using .npmrc config
-    let registry_base = self.registry_url(&update_url.package_name);
-    let full_url = registry_base
-      .join(&update_url.package_name)
-      .map_err(|e| RegistryError::FetchError {
-        url: update_url.package_name.clone(),
-        source: Box::new(e),
-      })?;
+    let (full_url, registry_base) = self.resolve_url(&update_url.package_name)?;
     let url_str = full_url.to_string();
 
-    // Build request with auth if credentials exist
-    let mut req = self.client.get(full_url.clone()).header(ACCEPT, "application/json");
+    let mut req = self.client.get(full_url).header(ACCEPT, "application/json");
     if let Some(creds) = self.npmrc.credentials_for(&registry_base) {
       req = match &creds {
         Credentials::Token { token, .. } => req.bearer_auth(token),
@@ -94,10 +83,7 @@ impl RegistryClient for LiveRegistryClient {
             let versions = package_meta
               .versions
               .into_iter()
-              .filter(|(_, metadata)| {
-                // Filter out deprecated versions by checking if "deprecated" field exists
-                metadata.get("deprecated").is_none()
-              })
+              .filter(|(_, metadata)| metadata.get("deprecated").is_none())
               .map(|(version, _)| version)
               .collect();
             Ok(AllPackageVersions {
@@ -121,25 +107,31 @@ impl RegistryClient for LiveRegistryClient {
 }
 
 impl LiveRegistryClient {
-  pub fn new() -> Result<Self, RegistryError> {
-    let npmrc = NpmrcConfig::load()?;
-    Ok(LiveRegistryClient {
+  pub fn new(npmrc: NpmrcConfig) -> Self {
+    LiveRegistryClient {
       client: Client::builder()
         .connect_timeout(Duration::from_secs(5))
         .timeout(Duration::from_secs(30))
         .build()
         .expect("Failed to build reqwest client"),
       npmrc,
-    })
+    }
   }
 
-  /// Resolve registry URL for a package, with JSR fallback
-  pub fn registry_url(&self, package_name: &str) -> Url {
-    let url = self.npmrc.registry_for(package_name);
-    // Fallback: @jsr/* uses npm.jsr.io if not explicitly configured
-    if package_name.starts_with("@jsr/") && url.host_str() == Some("registry.npmjs.org") {
-      return Url::parse("https://npm.jsr.io/").unwrap();
+  /// Resolve the full registry URL for a package name.
+  ///
+  /// Uses .npmrc scoped registry config, with a fallback to npm.jsr.io
+  /// for @jsr/* packages that have no explicit registry configured.
+  /// Returns (full_url, registry_base) so callers can look up credentials.
+  pub fn resolve_url(&self, package_name: &str) -> Result<(Url, Url), RegistryError> {
+    let mut registry_base = self.npmrc.registry_for(package_name);
+    if package_name.starts_with("@jsr/") && registry_base.host_str() == Some("registry.npmjs.org") {
+      registry_base = Url::parse("https://npm.jsr.io/").unwrap();
     }
-    url
+    let full_url = registry_base.join(package_name).map_err(|e| RegistryError::FetchError {
+      url: package_name.to_string(),
+      source: Box::new(e),
+    })?;
+    Ok((full_url, registry_base))
   }
 }

src/registry_client_test.rs

@@ -1,5 +1,6 @@
 use {
   crate::registry_client::{LiveRegistryClient, PackageMeta},
+  npmrc_config_rs::NpmrcConfig,
   serde_json::json,
   std::collections::BTreeMap,
 };
@@ -65,36 +66,31 @@ fn includes_all_versions_when_none_deprecated() {
   assert!(versions.contains(&"3.0.0".to_string()));
 }
 
+fn make_client() -> LiveRegistryClient {
+  let npmrc = NpmrcConfig::load().expect("Failed to load .npmrc config");
+  LiveRegistryClient::new(npmrc)
+}
+
 #[test]
 fn registry_client_can_be_created() {
-  // Verifies that LiveRegistryClient::new() succeeds
-  // This loads .npmrc from standard locations (may be empty)
-  let result = LiveRegistryClient::new();
-  assert!(result.is_ok(), "Failed to create registry client: {:?}", result.err());
+  make_client();
 }
 
 #[test]
-fn registry_url_returns_default_for_regular_packages() {
-  let client = LiveRegistryClient::new().unwrap();
-  let url = client.registry_url("react");
-  // Should use default npm registry (or user's configured default)
-  // We can't assert exact URL since user might have custom config,
-  // but we can verify it's a valid URL
+fn resolve_url_returns_default_for_regular_packages() {
+  let client = make_client();
+  let (url, _) = client.resolve_url("react").unwrap();
   assert!(url.scheme() == "https" || url.scheme() == "http");
   assert!(url.host_str().is_some());
 }
 
 #[test]
-fn registry_url_uses_jsr_fallback_for_jsr_packages() {
-  let client = LiveRegistryClient::new().unwrap();
-  let url = client.registry_url("@jsr/luca__cases");
-  // JSR packages should use npm.jsr.io when not explicitly configured
-  // If user has @jsr:registry configured, this will use that instead
-  let host = url.host_str().unwrap();
-  // Either npm.jsr.io (fallback) or user's configured JSR registry
-  assert!(
-    host == "npm.jsr.io" || host != "registry.npmjs.org",
-    "Expected JSR package to NOT use registry.npmjs.org, got: {}",
-    url
+fn resolve_url_uses_jsr_fallback_for_jsr_packages() {
+  let client = make_client();
+  let (url, _) = client.resolve_url("@jsr/luca__cases").unwrap();
+  assert_ne!(
+    url.host_str().unwrap(),
+    "registry.npmjs.org",
+    "Expected JSR package to NOT use registry.npmjs.org, got: {url}",
   );
 }