xert 0.2.0

A professional Rust project scaffolding tool for Web, CLI, and Embedded projects.
Documentation
use anyhow::{Context, Result};
use futures::future::join_all;
use serde::Deserialize;
use std::collections::HashMap;

#[derive(Deserialize)]
struct CrateResponse {
    #[serde(rename = "crate")]
    krate: CrateInfo,
}

#[derive(Deserialize)]
struct CrateInfo {
    max_stable_version: String,
}

pub async fn get_latest_version(
    client: &reqwest::Client,
    crate_name: &str,
) -> Result<(String, String)> {
    let url = format!("https://crates.io/api/v1/crates/{}", crate_name);

    let resp: CrateResponse = client
        .get(&url)
        .header("User-Agent", "xert-cli/0.1.0")
        .send()
        .await
        .context(format!("Failed to fetch version for {}", crate_name))?
        .json()
        .await
        .context(format!("Failed to parse response for {}", crate_name))?;

    Ok((crate_name.to_string(), resp.krate.max_stable_version))
}

pub async fn resolve_dependencies(crates: &[&str]) -> HashMap<String, String> {
    let client = reqwest::Client::new();
    let mut futures = Vec::new();

    for &krate in crates {
        futures.push(get_latest_version(&client, krate));
    }

    let results = join_all(futures).await;
    let mut versions = HashMap::new();

    for res in results {
        match res {
            Ok((name, ver)) => {
                versions.insert(name, ver);
            }
            Err(e) => {
                // In a real lib, we might want to log this or return errors,
                // but keeping original behavior of ignoring failures for now (or maybe printing?)
                // The original code passed over errors.
                eprintln!("Warning: {}", e);
            }
        }
    }
    versions
}