ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::contract::Registry;
use crate::core::model::{Availability, Dependency, RegistryId, UdError, Version, VersionMeta};
use async_trait::async_trait;
use serde::Deserialize;
use std::collections::HashMap;

crate::http_registry! {
    NpmRegistry { id: "npm", base: "https://registry.npmjs.org" },
    JsrRegistry { id: "jsr", base: "https://jsr.io" },
}

#[derive(Deserialize)]
struct NpmPackument {
    versions: HashMap<String, serde::de::IgnoredAny>,
}

#[async_trait]
impl Registry for NpmRegistry {
    fn id(&self) -> RegistryId {
        RegistryId::from(Self::REGISTRY_ID)
    }

    async fn versions(&self, dep: &Dependency) -> Result<Availability, UdError> {
        let name_encoded = dep.coordinate.0.replace('/', "%2F");
        let url = format!("{}/{}", self.base_url, name_encoded);

        tracing::debug!(coordinate = %dep.coordinate.0, url = %url, "fetching npm registry");

        let res = self
            .client
            .get(&url)
            .header("accept", "application/vnd.npm.install-v1+json")
            .send()
            .await
            .map_err(|e| {
                UdError::Http(format!("Network error for npm:{}: {}", dep.coordinate.0, e))
            })?;

        if res.status() == 404 {
            return Ok(Availability::default());
        }

        if !res.status().is_success() {
            return Err(UdError::Http(format!(
                "HTTP error {} for npm:{}",
                res.status(),
                dep.coordinate.0
            )));
        }

        let body = res.text().await.map_err(|e| {
            UdError::Http(format!(
                "Failed to read response body for npm:{}: {}",
                dep.coordinate.0, e
            ))
        })?;

        let packument: NpmPackument = serde_json::from_str(&body).map_err(|e| {
            UdError::Parse(format!(
                "Failed to parse npm JSON for {}: {}",
                dep.coordinate.0, e
            ))
        })?;

        let versions = packument
            .versions
            .into_keys()
            .map(|v| VersionMeta {
                version: Version(v),
                yanked: false, // npm deprecated is ignored (ASSUMPTION §1)
            })
            .collect();

        Ok(Availability { versions })
    }
}

#[derive(Deserialize)]
struct JsrVersionInfo {
    #[serde(default)]
    yanked: bool,
}

#[derive(Deserialize)]
struct JsrMeta {
    versions: HashMap<String, JsrVersionInfo>,
}

fn is_jsr_scoped(name: &str) -> bool {
    if !name.starts_with('@') {
        return false;
    }
    let parts: Vec<&str> = name.split('/').collect();
    if parts.len() != 2 {
        return false;
    }
    !parts[0].is_empty() && !parts[1].is_empty()
}

#[async_trait]
impl Registry for JsrRegistry {
    fn id(&self) -> RegistryId {
        RegistryId::from(Self::REGISTRY_ID)
    }

    async fn versions(&self, dep: &Dependency) -> Result<Availability, UdError> {
        // Namespace shortcut: Jsr only allows scoped packages (@scope/name)
        if !is_jsr_scoped(&dep.coordinate.0) {
            tracing::debug!(coordinate = %dep.coordinate.0, "JSR namespace shortcut matched: zero HTTP");
            return Ok(Availability::default());
        }

        let url = format!("{}/{}/meta.json", self.base_url, dep.coordinate.0);

        tracing::debug!(coordinate = %dep.coordinate.0, url = %url, "fetching jsr registry");

        let res = self.client.get(&url).send().await.map_err(|e| {
            UdError::Http(format!("Network error for jsr:{}: {}", dep.coordinate.0, e))
        })?;

        if res.status() == 404 {
            return Ok(Availability::default());
        }

        if !res.status().is_success() {
            return Err(UdError::Http(format!(
                "HTTP error {} for jsr:{}",
                res.status(),
                dep.coordinate.0
            )));
        }

        let body = res.text().await.map_err(|e| {
            UdError::Http(format!(
                "Failed to read response body for jsr:{}: {}",
                dep.coordinate.0, e
            ))
        })?;

        let meta: JsrMeta = serde_json::from_str(&body).map_err(|e| {
            UdError::Parse(format!(
                "Failed to parse JSR JSON for {}: {}",
                dep.coordinate.0, e
            ))
        })?;

        let versions = meta
            .versions
            .into_iter()
            .map(|(v, info)| VersionMeta {
                version: Version(v),
                yanked: info.yanked,
            })
            .collect();

        Ok(Availability { versions })
    }
}