cnb 0.2.2

CNB (cnb.cool) API client for Rust — typed, async, production-ready
Documentation 
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
117
118
119

//! Hand-written shared types for DTOs. Generated modules in this directory are
//! overwritten whenever the codegen runs — keep anything stable here.

use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// Repository visibility level.
///
/// Defined by the CNB API spec as string enum: `"Public"`, `"Private"`, `"Secret"`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Visibility {
    /// Public repository — accessible without authentication.
    Public,
    /// Private repository — requires explicit per-user access.
    Private,
    /// Secret (encrypted) repository — requires specific role credentials.
    Secret,
}

impl Visibility {
    /// Returns the canonical string form as declared by the API spec.
    pub fn as_str(&self) -> &'static str {
        match self {
            Visibility::Public => "Public",
            Visibility::Private => "Private",
            Visibility::Secret => "Secret",
        }
    }
}

impl std::fmt::Display for Visibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl Serialize for Visibility {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for Visibility {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        struct VisibilityVisitor;

        impl<'de> serde::de::Visitor<'de> for VisibilityVisitor {
            type Value = Visibility;

            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                formatter.write_str(
                    r#"a visibility string ("Public","Private","Secret") or integer (0, 10, 20)"#,
                )
            }

            fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Visibility, E> {
                match v {
                    "Public" | "public" => Ok(Visibility::Public),
                    "Private" | "private" => Ok(Visibility::Private),
                    "Secret" | "secret" | "Internal" | "internal" => Ok(Visibility::Secret),
                    _ => Err(E::unknown_variant(v, &["Public", "Private", "Secret"])),
                }
            }

            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Visibility, E> {
                match v {
                    0 => Ok(Visibility::Public),
                    10 => Ok(Visibility::Secret),
                    20 => Ok(Visibility::Private),
                    _ => Err(E::invalid_value(
                        serde::de::Unexpected::Unsigned(v),
                        &"0, 10, or 20",
                    )),
                }
            }

            fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<Visibility, E> {
                self.visit_u64(v as u64)
            }
        }

        deserializer.deserialize_any(VisibilityVisitor)
    }
}

/// Typed representation of a PR head/base reference.
///
/// Matches `api.PullRef` from the CNB API spec.
/// Fields: `ref` (branch reference name), `sha` (commit hash), `repo` (repository info).
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PullRef {
    /// Branch reference name (e.g. `"refs/heads/main"`).
    #[serde(default, rename = "ref", skip_serializing_if = "Option::is_none")]
    pub ref_: Option<String>,
    /// Commit hash the ref points to.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
    /// Associated repository information.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repo: Option<serde_json::Value>,
}

/// A container image tag (returned by the registries package-tags endpoint).
///
/// Distinct from the git `Tag` struct which represents a git tag object.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RegistryPackageTag {
    /// Tag name (e.g. `"latest"`, `"v1.2.3"`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Last update timestamp.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    /// Image digest (e.g. `"sha256:…"`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub digest: Option<String>,
    /// Image size in bytes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
}