go-module-email

github.com/redelay/go-module-email delivers transactional emails. It subscribes to email.send events emitted by other modules (verification, auth, custom) and sends them via the configured sender backend.

Quick start

go get github.com/redelay/go-module-email

import _ "github.com/redelay/go-module-email"

How it works

1. Other modules emit email.send events with to, subject, and either a body (pre-rendered HTML) or a template name + data map.
2. The email module subscribes to these events via the Redelay event bus — consumer registration is auto-wired by the framework; no manual setup is needed.
3. It renders the template (if specified) and delivers the email via the configured backend.

Event payload

{
  "to": ["[email protected]"],
  "subject": "Verify your email",
  "template": "verification",
  "data": {
    "VerificationURL": "https://example.com/verify?token=abc123",
    "ExpiresIn": "30m"
  }
}

Or with a pre-rendered body:

{
  "to": ["[email protected]"],
  "subject": "Hello",
  "body": "<p>Hello from Redelay!</p>"
}

Full payload fields (all optional except to):

Built-in templates

Configuration

SMTP (default)

SendGrid

Mailgun (SMTP relay)

Mailjet (SMTP relay)

Amazon SES (SMTP relay)

Local development with Mailpit

Set TRANSPORT=memory (no broker required). Point SMTP at Mailpit:

TRANSPORT=memory
EMAIL_SENDER=smtp
EMAIL_SMTP_HOST=localhost
EMAIL_SMTP_PORT=1025

Mailpit UI: http://localhost:8025. All emails are caught locally — nothing is delivered externally.

Package structure

FlowDSL nodes

The flowdsl/ subpackage provides 3 FlowDSL nodes for email operations. Enable with:

import (
    _ "github.com/redelay/go-module-email"
    _ "github.com/redelay/go-module-email/flowdsl"   // 3 FlowDSL nodes
)

Consuming email.send events in flows. Use the generic redelay/event-source node from go-flowdsl/nodes with eventName: email.send. Per-event source nodes (like the old redelay/email-send-event) have been removed — one configurable node replaces them all.

Emitting email.send events from your module

EmailSendEvent and EmailSendPayload live in the lightweight go-module-email/events package (it depends only on go-events/typed) — no custom payload type needed:

import (
    "github.com/redelay/go-events/typed"
    emailevents "github.com/redelay/go-module-email/events"
)

// In your handler:
msg, _ := emailevents.EmailSendEvent.NewMessage(
    user.ID.Hex(),
    typed.Actor{Type: typed.ActorTypeSystem, ID: "mymodule"},
    emailevents.EmailSendPayload{
        To:       []string{user.Email},
        Subject:  "Verify your email",
        Template: "verification",
        Data: map[string]any{
            "VerificationURL": verifyURL,
            "ExpiresIn":       "30m",
        },
    },
)
deps.EventBus.Publish(ctx, msg)

Custom sender backend

Implement the sender.Sender interface to use any delivery provider:

import "github.com/redelay/go-module-email/sender"

type MySender struct{}

func (s *MySender) Send(ctx context.Context, msg *sender.Message) error {
    // deliver msg.To, msg.Subject, msg.Body
    return nil
}

Wire it in via email.NewModuleWithSender(mySender) for testing, or register a custom factory.