plunk-rs 0.1.2

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
114
115
116

use crate::wire::{WireContact, WireDeliveredEmail, WireSendResponseData};

/// Successful send result.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SendResponse {
    deliveries: Vec<Delivery>,
    timestamp: String,
}

impl SendResponse {
    pub fn deliveries(&self) -> &[Delivery] {
        &self.deliveries
    }

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

impl From<WireSendResponseData> for SendResponse {
    fn from(value: WireSendResponseData) -> Self {
        Self {
            deliveries: value.emails.into_iter().map(Delivery::from).collect(),
            timestamp: value.timestamp,
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Delivery {
    contact: Contact,
    id: String,
}

impl Delivery {
    pub fn contact(&self) -> &Contact {
        &self.contact
    }

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

impl From<WireDeliveredEmail> for Delivery {
    fn from(value: WireDeliveredEmail) -> Self {
        Self {
            contact: Contact::from(value.contact),
            id: value.email,
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Contact {
    id: String,
    email: String,
}

impl Contact {
    pub fn id(&self) -> &str {
        &self.id
    }

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

impl From<WireContact> for Contact {
    fn from(value: WireContact) -> Self {
        Self {
            id: value.id,
            email: value.email,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::wire::WireSendResponse;
    use serde_json::json;

    #[test]
    fn deserializes_success_response_into_domain_types() {
        let response = serde_json::from_value::<WireSendResponse>(json!({
            "success": true,
            "data": {
                "emails": [
                    {
                        "contact": {
                            "id": "cnt_abc123",
                            "email": "user@example.com"
                        },
                        "email": "ac32f08e-c6b9-45d3-9824-a73dff1e3bbf"
                    }
                ],
                "timestamp": "2025-01-15T10:30:00.000Z"
            }
        }))
        .unwrap();

        let response = SendResponse::from(response.data);

        assert_eq!(response.deliveries().len(), 1);
        assert_eq!(
            response.deliveries()[0].contact().email(),
            "user@example.com"
        );
        assert_eq!(
            response.deliveries()[0].id(),
            "ac32f08e-c6b9-45d3-9824-a73dff1e3bbf"
        );
    }
}