guac 0.3.1

A library that provides toolkit for working with [Guac](https://guac.sh) from Rust.
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

mod ingest;
mod query;

use crate::client::intrinsic::has_sbom::ingest::IngestHasSBOM;
use crate::client::intrinsic::has_sbom::query::QueryHasSBOM;
use crate::client::intrinsic::{IntrinsicGuacClient, PackageOrArtifact, PackageOrArtifactInput, PackageOrArtifactSpec};
use crate::client::{Error, Id};
use chrono::Utc;
use graphql_client::reqwest::post_graphql;
use packageurl::PackageUrl;

type Time = chrono::DateTime<Utc>;

impl IntrinsicGuacClient {
    pub async fn ingest_has_sbom(
        &self,
        subject: &PackageOrArtifactInput,
        has_sbom: &HasSBOMInputSpec,
    ) -> Result<Id, Error> {
        use self::ingest::ingest_has_sbom;

        let variables = ingest_has_sbom::Variables {
            subject: subject.into(),
            has_sbom: has_sbom.into(),
        };

        let response_body = post_graphql::<IngestHasSBOM, _>(self.client(), self.url(), variables).await?;

        if let Some(errors) = response_body.errors {
            return Err(Error::GraphQL(errors));
        }

        let data = response_body.data.ok_or(Error::GraphQL(vec![]))?;

        Ok(data.ingest_has_sbom)
    }

    pub async fn has_sbom(&self, has_sbom_spec: &HasSBOMSpec) -> Result<Vec<HasSBOM>, Error> {
        use self::query::query_has_sbom;

        let variables = query_has_sbom::Variables {
            has_sbom_spec: has_sbom_spec.into(),
        };
        let response_body = post_graphql::<QueryHasSBOM, _>(self.client(), self.url(), variables).await?;

        if let Some(errors) = response_body.errors {
            return Err(Error::GraphQL(errors));
        }

        let data = response_body.data.ok_or(Error::GraphQL(vec![]))?;

        let mut has_sboms = Vec::new();

        for entry in &data.has_sbom {
            has_sboms.push(entry.into());
        }

        Ok(has_sboms)
    }
}

impl From<PackageUrl<'_>> for HasSBOMSpec {
    fn from(value: PackageUrl) -> Self {
        Self {
            id: None,
            subject: Some(value.into()),
            uri: None,
            algorithm: None,
            digist: None,
            download_location: None,
            origin: None,
            collector: None,
            known_since: None,
        }
    }
}

#[derive(Clone, Debug)]
pub struct HasSBOM {
    pub id: Id,
    pub subject: PackageOrArtifact,
    pub uri: String,
    pub algorithm: String,
    pub digest: String,
    pub download_location: String,
    pub origin: String,
    pub collector: String,
    pub known_since: Option<Time>,
}

#[derive(Clone, Debug)]
pub struct HasSBOMSpec {
    pub id: Option<Id>,
    pub subject: Option<PackageOrArtifactSpec>,
    pub uri: Option<String>,
    pub algorithm: Option<String>,
    pub digist: Option<String>,
    pub download_location: Option<String>,
    pub origin: Option<String>,
    pub collector: Option<String>,
    pub known_since: Option<Time>,
}

#[derive(Clone, Debug)]
pub struct HasSBOMInputSpec {
    pub uri: String,
    pub algorithm: String,
    pub digest: String,
    pub download_location: String,
    pub origin: String,
    pub collector: String,
    pub known_since: Time,
}