plunk-rs 0.1.1

Async Rust client for the Plunk transactional email 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

use reqwest::StatusCode;
use std::fmt;
use thiserror::Error as ThisError;

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

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ApiError {
    status: StatusCode,
    code: Option<i64>,
    kind: Option<String>,
    message: String,
    body: String,
}

impl ApiError {
    pub(crate) fn from_response(status: StatusCode, body: String) -> Self {
        match serde_json::from_str::<crate::wire::WireApiError>(&body) {
            Ok(payload) => Self {
                status,
                code: Some(payload.code),
                kind: Some(payload.error),
                message: payload.message,
                body,
            },
            Err(_) => Self {
                status,
                code: None,
                kind: None,
                message: "unparseable API error response".to_string(),
                body,
            },
        }
    }

    pub fn status(&self) -> StatusCode {
        self.status
    }

    pub fn code(&self) -> Option<i64> {
        self.code
    }

    pub fn kind(&self) -> Option<&str> {
        self.kind.as_deref()
    }

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

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

impl fmt::Display for ApiError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.kind() {
            Some(kind) => write!(f, "{} {}: {}", self.status, kind, self.message),
            None => write!(f, "{}: {}", self.status, self.message),
        }
    }
}

#[derive(Debug, ThisError)]
pub enum Error {
    #[error("api key cannot be empty")]
    InvalidApiKey,
    #[error("base URL is invalid: {0}")]
    InvalidBaseUrl(#[from] url::ParseError),
    #[error("at least one recipient is required")]
    MissingRecipients,
    #[error("subject cannot be empty")]
    InvalidSubject,
    #[error("body cannot be empty")]
    InvalidBody,
    #[error("template id cannot be empty")]
    InvalidTemplateId,
    #[error("display name cannot be empty")]
    InvalidDisplayName,
    #[error("header name cannot be empty")]
    InvalidHeaderName,
    #[error("header value cannot be empty")]
    InvalidHeaderValue,
    #[error("email address is invalid: {reason} ({value})")]
    InvalidEmailAddress { reason: &'static str, value: String },
    #[error("template data must serialize into a JSON object")]
    TemplateDataMustBeObject,
    #[error("failed to serialize template data: {0}")]
    TemplateDataSerialization(serde_json::Error),
    #[error("http request failed: {0}")]
    Transport(#[from] reqwest::Error),
    #[error("plunk API returned {0}")]
    Api(ApiError),
    #[error("unexpected API response: {0}")]
    UnexpectedResponse(String),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn api_error_preserves_raw_body_when_json_is_unparseable() {
        let error =
            ApiError::from_response(StatusCode::BAD_GATEWAY, "<html>bad gateway</html>".into());

        assert_eq!(error.status(), StatusCode::BAD_GATEWAY);
        assert_eq!(error.code(), None);
        assert_eq!(error.body(), "<html>bad gateway</html>");
    }
}