How to Set Separate Email Body and Text with wneessen/go-mail

Crafting Emails with Separate HTML and Plain Text Content

Sending emails with both HTML and plain text versions is a crucial feature for modern applications, ensuring compatibility across devices and user preferences. But what happens when the library you’re using makes this challenging? 🤔

Developers using the wneessen/go-mail package often face a peculiar issue: setting the HTML body updates or removes the plain text content, and vice versa. This can be especially frustrating when you're working with libraries like Hermes, which generate both formats independently.

Imagine this scenario: you've created a visually stunning HTML email with links and buttons but want to include a simple, clean plain text version for accessibility. However, as soon as you set one format, the other disappears. It’s like trying to paint a picture where each brushstroke erases the previous one! 🎨

In this article, we’ll explore if it’s possible to set both email body and text separately using wneessen/go-mail, and how to overcome this limitation. Drawing from a real-world project example, we’ll walk you through the problem and its potential solutions.

Mastering Dual Email Formats with wneessen/go-mail

The scripts provided demonstrate how to seamlessly integrate both HTML and plain text email bodies using the wneessen/go-mail library in Go. The core challenge lies in setting these two formats independently without overwriting one another. This problem is particularly relevant when working with libraries like Hermes, which generate separate outputs for HTML and plain text. By modularizing the initialization and sending processes, these scripts ensure a scalable and reusable approach for email handling. Imagine a situation where your application sends a vibrant HTML newsletter, but some recipients prefer plain text for clarity — the scripts ensure everyone is catered to. ✉️

To achieve this, the first script initializes an SMTP client using secure configurations such as TLS and authentication credentials. This setup is encapsulated in the initializeClient function, ensuring clarity and reusability. The use of the Hermes library adds a unique dimension, as it simplifies the generation of professional email templates. With the ability to customize branding, the email content aligns with the application's identity. This design is especially useful for startups or services aiming to create a polished first impression with their users.

The email sending process is handled by the sendEmail function, which takes both the recipient and content as parameters. It carefully assigns the plain text and HTML bodies using distinct commands to prevent overwriting. The modular helper function, setEmailBody, ensures that the email body-setting logic remains isolated, making the script cleaner and easier to maintain. For example, if a marketing team wants to test new email formats, this setup allows for quick experimentation without risking disruptions to the main logic. 🚀

Finally, the inclusion of error handling ensures reliability. Functions like fmt.Errorf() provide detailed error messages, making debugging straightforward. Additionally, closing the SMTP client after use with defer avoids resource leaks, a small but critical step for maintaining server performance. This setup is ideal for real-world applications where email delivery is a key feature, such as e-commerce platforms or notification systems. By adhering to best practices, these scripts are not just functional but also highly maintainable for long-term use.

package main
import (
    "context"
    "fmt"
    "github.com/matcornic/hermes/v2"
    "github.com/wneessen/go-mail"
)
// Initialize email client and Hermes
func initializeClient() (*mail.Client, hermes.Hermes, error) {
    client, err := mail.NewClient("smtp.example.com",
        mail.WithPort(587),
        mail.WithTLSPolicy(mail.TLSMandatory),
        mail.WithSMTPAuth(mail.SMTPAuthPlain),
        mail.WithUsername("user@example.com"),
        mail.WithPassword("password123"))
    if err != nil {
        return nil, hermes.Hermes{}, err
    }
    hermes := hermes.Hermes{
        Product: hermes.Product{
            Name: "Example App",
            Link: "https://example.com",
        },
    }
    return client, hermes, nil
}
// Send an email with separate HTML and plain text bodies
func sendEmail(client *mail.Client, hermes hermes.Hermes, recipient string) error {
    email := hermes.Email{
        Body: hermes.Body{
            Name: "User",
            Intros: []string{"Welcome to Example App! We’re glad to have you."},
            Outros: []string{"If you have questions, just reply to this email."},
        },
    }
    htmlBody, err := hermes.GenerateHTML(email)
    if err != nil {
        return fmt.Errorf("failed to generate HTML: %w", err)
    }
    textBody, err := hermes.GeneratePlainText(email)
    if err != nil {
        return fmt.Errorf("failed to generate plain text: %w", err)
    }
    msg := mail.NewMsg()
    msg.From("user@example.com")
    msg.To(recipient)
    msg.Subject("Welcome to Example App!")
    msg.SetBodyString(mail.TypeTextPlain, textBody)
    msg.SetBodyString(mail.TypeTextHTML, htmlBody)
    return client.DialAndSend(msg)
}
func main() {
    client, hermes, err := initializeClient()
    if err != nil {
        fmt.Println("Error initializing client:", err)
        return
    }
    defer client.Close()
    if err := sendEmail(client, hermes, "recipient@example.com"); err != nil {
        fmt.Println("Error sending email:", err)
    } else {
        fmt.Println("Email sent successfully!")
    }
}

package email
import (
    "github.com/wneessen/go-mail"
)
func setEmailBody(msg *mail.Msg, text, html string) error {
    if err := msg.SetBodyString(mail.TypeTextPlain, text); err != nil {
        return err
    }
    if err := msg.SetBodyString(mail.TypeTextHTML, html); err != nil {
        return err
    }
    return nil
}
func send(client *mail.Client, to, subject, textBody, htmlBody string) error {
    msg := mail.NewMsg()
    msg.From("user@example.com")
    msg.To(to)
    msg.Subject(subject)
    if err := setEmailBody(msg, textBody, htmlBody); err != nil {
        return err
    }
    return client.DialAndSend(msg)
}

Enhancing Email Functionality with Hermes and wneessen/go-mail

One crucial aspect of modern email handling is ensuring that your messages are accessible across different devices and user preferences. Many users prefer HTML emails for their polished design, while others prefer plain text for simplicity and clarity. Using Hermes and wneessen/go-mail, developers can seamlessly create emails that cater to both preferences, ensuring a broader reach. These tools are particularly valuable for applications requiring customizable templates and consistent branding, like newsletters or user notifications. 🚀

What makes this combination stand out is its modularity. Hermes generates well-structured HTML and plain text bodies, making it easier to maintain a unified email format across campaigns. This approach saves time and ensures consistency, especially in environments where regular email communication is essential. For instance, an e-commerce platform could use Hermes for promotional emails, while wneessen/go-mail handles secure delivery through SMTP with advanced configurations. This setup supports personalization, a key factor in improving user engagement. 💡

Additionally, the flexibility of wneessen/go-mail allows developers to set up secure email delivery with options like TLS and custom authentication. These configurations ensure that sensitive information remains secure during transmission, a critical feature for industries like banking or healthcare. Combining this with error-handling practices and resource management, the integration of these libraries becomes a robust solution for professional-grade email systems. This attention to detail is why developers often turn to these tools when building scalable and efficient email solutions.