zv 0.11.0

Ziglang Version Manager and Project Starter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::app::constants::ZLS_SELECT_VERSION_ENDPOINT;
use crate::app::network::create_client;
use crate::{NetErr, ZvError};
use color_eyre::eyre::eyre;
use serde::Deserialize;
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct ZlsArtifact {
    pub tarball: String,
    pub shasum: String,
    pub size: u64,
}

#[derive(Debug, Clone)]
pub struct ZlsRelease {
    pub version: String,
    pub date: String,
    pub per_target: HashMap<String, ZlsArtifact>,
}

impl ZlsRelease {
    pub fn artifact_for_target(&self, target: &str) -> Option<&ZlsArtifact> {
        self.per_target.get(target)
    }
}

#[derive(Debug, Deserialize)]
struct SelectVersionResponse {
    version: String,
    date: String,
    #[serde(flatten)]
    targets: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Deserialize)]
struct ArtifactDto {
    tarball: String,
    shasum: String,
    #[serde(deserialize_with = "deserialize_size")]
    size: u64,
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
enum SizeValue {
    Number(u64),
    String(String),
}

fn deserialize_size<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let value = SizeValue::deserialize(deserializer)?;
    match value {
        SizeValue::Number(value) => Ok(value),
        SizeValue::String(value) => value.parse::<u64>().map_err(serde::de::Error::custom),
    }
}

pub async fn select_version(zig_version: &str) -> Result<ZlsRelease, ZvError> {
    let client = create_client()?;
    let response = client
        .get(ZLS_SELECT_VERSION_ENDPOINT)
        .query(&[("zig_version", zig_version), ("compatibility", "full")])
        .send()
        .await
        .map_err(NetErr::Reqwest)
        .map_err(ZvError::NetworkError)?;

    if !response.status().is_success() {
        return Err(ZvError::NetworkError(NetErr::HTTP(response.status())));
    }

    let body: SelectVersionResponse = response
        .json()
        .await
        .map_err(NetErr::Reqwest)
        .map_err(ZvError::NetworkError)?;

    let mut per_target = HashMap::new();
    for (key, value) in body.targets {
        match serde_json::from_value::<ArtifactDto>(value) {
            Ok(artifact) => {
                per_target.insert(
                    key,
                    ZlsArtifact {
                        tarball: artifact.tarball,
                        shasum: artifact.shasum,
                        size: artifact.size,
                    },
                );
            }
            Err(err) => {
                tracing::warn!(
                    target: "zv::network::zls",
                    artifact_target = %key,
                    "Skipping malformed ZLS artifact in select-version response: {err}"
                );
            }
        }
    }

    if per_target.is_empty() {
        return Err(ZvError::General(eyre!(
            "ZLS select-version response did not include any target artifacts"
        )));
    }

    Ok(ZlsRelease {
        version: body.version,
        date: body.date,
        per_target,
    })
}