oxidite-mail 2.2.0

Email sending for Oxidite with SMTP support
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 crate::{Attachment, Result, MailError};
use lettre::Address;

/// Email message builder (Nodemailer-style)
#[derive(Debug, Clone)]
pub struct Message {
    pub(crate) from: Option<String>,
    pub(crate) to: Vec<String>,
    pub(crate) cc: Vec<String>,
    pub(crate) bcc: Vec<String>,
    pub(crate) reply_to: Option<String>,
    pub(crate) subject: Option<String>,
    pub(crate) text: Option<String>,
    pub(crate) html: Option<String>,
    pub(crate) attachments: Vec<Attachment>,
}

impl Message {
    pub fn new() -> Self {
        Self {
            from: None,
            to: Vec::new(),
            cc: Vec::new(),
            bcc: Vec::new(),
            reply_to: None,
            subject: None,
            text: None,
            html: None,
            attachments: Vec::new(),
        }
    }

    /// Set sender address
    pub fn from(mut self, from: impl Into<String>) -> Self {
        self.from = Some(from.into());
        self
    }

    /// Add recipient
    pub fn to(mut self, to: impl Into<String>) -> Self {
        self.to.push(to.into());
        self
    }

    /// Add CC recipient
    pub fn cc(mut self, cc: impl Into<String>) -> Self {
        self.cc.push(cc.into());
        self
    }

    /// Add BCC recipient
    pub fn bcc(mut self, bcc: impl Into<String>) -> Self {
        self.bcc.push(bcc.into());
        self
    }

    /// Set reply-to address
    pub fn reply_to(mut self, reply_to: impl Into<String>) -> Self {
        self.reply_to = Some(reply_to.into());
        self
    }

    /// Set subject
    pub fn subject(mut self, subject: impl Into<String>) -> Self {
        self.subject = Some(subject.into());
        self
    }

    /// Set plain text body
    pub fn text(mut self, text: impl Into<String>) -> Self {
        self.text = Some(text.into());
        self
    }

    /// Set HTML body
    pub fn html(mut self, html: impl Into<String>) -> Self {
        self.html = Some(html.into());
        self
    }

    /// Add attachment
    pub fn attach(mut self, attachment: Attachment) -> Self {
        self.attachments.push(attachment);
        self
    }

    /// Validate message
    pub(crate) fn validate(&self) -> Result<()> {
        if self.from.is_none() {
            return Err(MailError::MissingField("from".to_string()));
        }
        if self.to.is_empty() {
            return Err(MailError::MissingField("to".to_string()));
        }
        if self.subject.is_none() {
            return Err(MailError::MissingField("subject".to_string()));
        }
        if self.text.is_none() && self.html.is_none() {
            return Err(MailError::MissingField("text or html".to_string()));
        }

        // Validate address formats early for clearer diagnostics.
        if let Some(from) = &self.from {
            from.parse::<Address>()
                .map_err(|_| MailError::InvalidAddress(format!("from: {from}")))?;
        }
        for to in &self.to {
            to.parse::<Address>()
                .map_err(|_| MailError::InvalidAddress(format!("to: {to}")))?;
        }
        for cc in &self.cc {
            cc.parse::<Address>()
                .map_err(|_| MailError::InvalidAddress(format!("cc: {cc}")))?;
        }
        for bcc in &self.bcc {
            bcc.parse::<Address>()
                .map_err(|_| MailError::InvalidAddress(format!("bcc: {bcc}")))?;
        }
        if let Some(reply_to) = &self.reply_to {
            reply_to
                .parse::<Address>()
                .map_err(|_| MailError::InvalidAddress(format!("reply_to: {reply_to}")))?;
        }

        Ok(())
    }
}

impl Default for Message {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn validate_rejects_bad_recipient() {
        let msg = Message::new()
            .from("sender@example.com")
            .to("bad-address")
            .subject("hello")
            .text("body");
        assert!(msg.validate().is_err());
    }
}