catapulte-adapter-smtp 0.1.0

SMTP adapter for catapulte - implements EmailSender using Lettre
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

use anyhow::Context;
use catapulte_domain::error::SendError;
use catapulte_domain::model::{Email, Recipient, RenderedEmail};
use catapulte_domain::prelude::EmailSender;
use lettre::message::header::ContentType;
use lettre::message::{Mailbox, MultiPart, SinglePart};
use lettre::transport::smtp::AsyncSmtpTransport;
use lettre::{AsyncTransport, Message, Tokio1Executor};

use crate::config::SmtpConfig;

/// SMTP email sender implementing the `EmailSender` port
pub struct SmtpSender {
    transport: AsyncSmtpTransport<Tokio1Executor>,
}

impl SmtpSender {
    /// Create a new SMTP sender from configuration
    pub fn new(config: &SmtpConfig) -> Result<Self, SendError> {
        let transport = config
            .build()
            .map_err(|err| SendError::ConnectionError(anyhow::Error::new(err)))?;
        Ok(Self { transport })
    }

    fn recipient_to_mailbox(recipient: &Recipient) -> Result<Mailbox, SendError> {
        let address: lettre::Address = recipient
            .email
            .parse()
            .with_context(|| format!("invalid email address: {}", recipient.email))
            .map_err(SendError::BuildError)?;

        Ok(Mailbox::new(recipient.name.clone(), address))
    }

    fn build_message(email: &Email, rendered: &RenderedEmail) -> Result<Message, SendError> {
        let from = Self::recipient_to_mailbox(&email.from)?;

        let mut builder = Message::builder().from(from);

        for recipient in &email.recipients.to {
            builder = builder.to(Self::recipient_to_mailbox(recipient)?);
        }
        for recipient in &email.recipients.cc {
            builder = builder.cc(Self::recipient_to_mailbox(recipient)?);
        }
        for recipient in &email.recipients.bcc {
            builder = builder.bcc(Self::recipient_to_mailbox(recipient)?);
        }

        let multipart = match &rendered.text_body {
            Some(text) => {
                MultiPart::alternative_plain_html(text.clone(), rendered.html_body.clone())
            }
            None => {
                MultiPart::alternative().singlepart(SinglePart::html(rendered.html_body.clone()))
            }
        };

        let multipart = email.attachments.iter().fold(multipart, |mp, attachment| {
            let content_type: ContentType = attachment
                .content_type
                .parse()
                .unwrap_or(ContentType::TEXT_PLAIN);
            mp.singlepart(
                lettre::message::Attachment::new(attachment.filename.clone())
                    .body(attachment.content.clone(), content_type),
            )
        });

        builder
            .subject(&rendered.subject)
            .multipart(multipart)
            .map_err(|err| SendError::BuildError(anyhow::Error::new(err)))
    }
}

impl EmailSender for SmtpSender {
    async fn send(&self, email: &Email, rendered: &RenderedEmail) -> Result<(), SendError> {
        let message = Self::build_message(email, rendered)?;
        self.transport
            .send(message)
            .await
            .map_err(|err| SendError::TransportError(anyhow::Error::new(err)))?;
        Ok(())
    }

    async fn test_connection(&self) -> Result<(), SendError> {
        self.transport
            .test_connection()
            .await
            .map_err(|err| SendError::ConnectionError(anyhow::Error::new(err)))?;
        Ok(())
    }
}