reevit 0.2.0

Official Rust SDK for the Reevit payments API
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use reqwest::StatusCode;
use serde_json::Value;

/// A result returned by the Reevit SDK.
pub type Result<T> = std::result::Result<T, Error>;

/// An error returned by the Reevit API.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ApiError {
    /// HTTP status returned by Reevit.
    pub status: StatusCode,
    /// Stable machine-readable error code, when supplied.
    pub code: Option<String>,
    /// Human-readable error message.
    pub message: String,
    /// Additional structured context supplied by Reevit.
    pub details: Option<Value>,
    /// Request identifier useful when contacting support.
    pub request_id: Option<String>,
}

impl ApiError {
    /// Returns whether retrying the request may succeed.
    #[must_use]
    pub fn is_recoverable(&self) -> bool {
        matches!(self.status.as_u16(), 408 | 409 | 425 | 429) || self.status.is_server_error()
    }
}

impl std::fmt::Display for ApiError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.code {
            Some(code) => write!(
                formatter,
                "Reevit request failed with status {} ({code}): {}",
                self.status.as_u16(),
                self.message
            ),
            None => write!(
                formatter,
                "Reevit request failed with status {}: {}",
                self.status.as_u16(),
                self.message
            ),
        }
    }
}

impl std::error::Error for ApiError {}

/// Errors produced while configuring or calling Reevit.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// The client configuration is invalid.
    #[error("invalid Reevit client configuration: {0}")]
    Configuration(String),
    /// The HTTP request could not be completed.
    #[error("Reevit transport error: {0}")]
    Transport(TransportError),
    /// Reevit returned a non-successful HTTP response.
    #[error(transparent)]
    Api(#[from] ApiError),
    /// A successful response did not match the expected schema.
    #[error("failed to decode Reevit response (status {status}): {source}")]
    Decode {
        /// HTTP status of the response that failed to decode.
        status: StatusCode,
        /// JSON decoding failure.
        #[source]
        source: serde_json::Error,
    },
    /// A successful response omitted the resource shape required by the interface.
    #[error("unexpected Reevit response: {0}")]
    UnexpectedResponse(String),
}

/// A URL-safe summary of a failed HTTP operation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TransportError {
    kind: TransportErrorKind,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TransportErrorKind {
    Timeout,
    Connection,
    Request,
    Body,
    Other,
}

impl TransportError {
    /// Returns whether the operation exceeded its configured timeout.
    #[must_use]
    pub fn is_timeout(&self) -> bool {
        self.kind == TransportErrorKind::Timeout
    }

    /// Returns whether the SDK could not establish a network connection.
    #[must_use]
    pub fn is_connect(&self) -> bool {
        self.kind == TransportErrorKind::Connection
    }
}

impl std::fmt::Display for TransportError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let message = match self.kind {
            TransportErrorKind::Timeout => "request timed out",
            TransportErrorKind::Connection => "failed to connect to Reevit",
            TransportErrorKind::Request => "failed to construct or send the request",
            TransportErrorKind::Body => "failed while reading the response",
            TransportErrorKind::Other => "HTTP operation failed",
        };
        formatter.write_str(message)
    }
}

impl std::error::Error for TransportError {}

impl From<reqwest::Error> for Error {
    fn from(error: reqwest::Error) -> Self {
        let kind = if error.is_timeout() {
            TransportErrorKind::Timeout
        } else if error.is_connect() {
            TransportErrorKind::Connection
        } else if error.is_request() {
            TransportErrorKind::Request
        } else if error.is_body() || error.is_decode() {
            TransportErrorKind::Body
        } else {
            TransportErrorKind::Other
        };
        Self::Transport(TransportError { kind })
    }
}

impl Error {
    /// Returns whether retrying the request may succeed.
    #[must_use]
    pub fn is_recoverable(&self) -> bool {
        match self {
            Self::Transport(_) => true,
            Self::Api(error) => error.is_recoverable(),
            Self::Configuration(_) | Self::Decode { .. } | Self::UnexpectedResponse(_) => false,
        }
    }
}