g2h 0.5.0

A code generator that bridges gRPC services to HTTP/JSON endpoints using Axum
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

use cargo_metadata::semver::Version;

///
/// [`Deps`] this is used to check the dependencies of the project. `g2h` is a build-dependency.
///
/// We can preemptively recognize the version of the following dependencies:
/// - `axum`
/// - `tonic`
/// - `http`
///
pub struct Deps {
    axum_version: Version,
    tonic_version: Version,
    http_version: Version,
}

#[derive(Debug, thiserror::Error)]
pub enum DepError {
    #[error("Dependency `{name}` is absent")]
    DependencyAbsent { name: String },
    #[error("Incompatible dependency `{name}`: expected `{expected}`, found `{actual}`")]
    DependencyVersionMismatch {
        name: String,
        expected: String,
        actual: String,
    },
    #[error("Failed to read Cargo metadata: {0}")]
    MetadataError(#[from] cargo_metadata::Error),
    #[error("Failed to parse version: {0}")]
    VersionParseError(#[from] cargo_metadata::semver::Error),
}

impl Deps {
    pub fn new(
        axum_version: &str,
        tonic_version: &str,
        http_version: &str,
    ) -> Result<Self, DepError> {
        Ok(Self {
            axum_version: Version::parse(axum_version)?,
            tonic_version: Version::parse(tonic_version)?,
            http_version: Version::parse(http_version)?,
        })
    }

    pub fn validate(self) -> Result<(), DepError> {
        let deps = [
            ("axum", self.axum_version),
            ("tonic", self.tonic_version),
            ("http", self.http_version),
        ];

        let metadata = cargo_metadata::MetadataCommand::new().exec()?;

        for (name, expected_version) in deps {
            let actual_version = &metadata
                .packages
                .iter()
                .find(|pkg| pkg.name == name)
                .ok_or_else(|| DepError::DependencyAbsent {
                    name: name.to_string(),
                })?
                .version;

            if expected_version.cmp_precedence(actual_version) != std::cmp::Ordering::Equal {
                return Err(DepError::DependencyVersionMismatch {
                    name: name.to_string(),
                    expected: expected_version.to_string(),
                    actual: actual_version.to_string(),
                });
            }
        }

        Ok(())
    }
}