gestalt-sdk 0.0.1-alpha.12

Rust SDK scaffolding and generated protocol bindings for Gestalt executable providers
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

#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
#[error("{message}")]
pub struct Error {
    status: Option<u16>,
    message: String,
    expose_message: bool,
}

pub(crate) const HTTP_BAD_REQUEST: u16 = 400;
pub(crate) const HTTP_NOT_FOUND: u16 = 404;
pub(crate) const HTTP_INTERNAL_SERVER_ERROR: u16 = 500;
pub(crate) const HTTP_NOT_IMPLEMENTED: u16 = 501;
pub(crate) const INTERNAL_ERROR_MESSAGE: &str = "internal error";

pub type Result<T> = std::result::Result<T, Error>;

impl Error {
    pub fn new(message: impl Into<String>) -> Self {
        Self {
            status: None,
            message: message.into(),
            expose_message: true,
        }
    }

    pub fn with_status(status: u16, message: impl Into<String>) -> Self {
        Self {
            status: Some(status),
            message: message.into(),
            expose_message: true,
        }
    }

    pub fn bad_request(message: impl Into<String>) -> Self {
        Self::with_status(HTTP_BAD_REQUEST, message)
    }

    pub fn internal(message: impl Into<String>) -> Self {
        Self::with_status(HTTP_INTERNAL_SERVER_ERROR, message)
    }

    pub fn not_found(message: impl Into<String>) -> Self {
        Self::with_status(HTTP_NOT_FOUND, message)
    }

    pub fn unimplemented(message: impl Into<String>) -> Self {
        Self::with_status(HTTP_NOT_IMPLEMENTED, message)
    }

    pub fn status(&self) -> Option<u16> {
        self.status
    }

    pub fn message(&self) -> &str {
        &self.message
    }

    pub(crate) fn expose_message(&self) -> bool {
        self.expose_message
    }

    pub(crate) fn hidden_internal(message: impl Into<String>) -> Self {
        Self {
            status: Some(HTTP_INTERNAL_SERVER_ERROR),
            message: message.into(),
            expose_message: false,
        }
    }
}

impl From<serde_json::Error> for Error {
    fn from(value: serde_json::Error) -> Self {
        Self::hidden_internal(value.to_string())
    }
}

impl From<std::io::Error> for Error {
    fn from(value: std::io::Error) -> Self {
        Self::hidden_internal(value.to_string())
    }
}

impl From<tonic::transport::Error> for Error {
    fn from(value: tonic::transport::Error) -> Self {
        Self::hidden_internal(value.to_string())
    }
}