How to Send Email with Fiber (Go)

package main

import (
	"log"
	"os"
	"time"

	"github.com/AhaSend/ahasend-go/api"
	"github.com/AhaSend/ahasend-go/webhooks"
	"github.com/gofiber/fiber/v3"
	"github.com/gofiber/fiber/v3/middleware/limiter"
	"github.com/google/uuid"
)

// A route (inbound message) webhook carries the whole email, base64 attachments
// included, so this has to be sized for a full message rather than for JSON.
// BodyLimit is server-wide in Fiber, not per route, which is why the send route
// gets its own much smaller cap below.
const maxBodyBytes = 30_000_000

var (
	ahasendClient        *api.APIClient
	accountID            uuid.UUID
	verifier             *webhooks.WebhookVerifier
	welcomeEndpointToken string
)

func main() {
	apiKey := os.Getenv("AHASEND_API_KEY")
	if apiKey == "" {
		log.Fatal("AHASEND_API_KEY is required")
	}
	welcomeEndpointToken = os.Getenv("WELCOME_ENDPOINT_TOKEN")
	if welcomeEndpointToken == "" {
		log.Fatal("WELCOME_ENDPOINT_TOKEN is required")
	}
	webhookSecret := os.Getenv("AHASEND_WEBHOOK_SECRET")
	if webhookSecret == "" {
		log.Fatal("AHASEND_WEBHOOK_SECRET is required")
	}

	var err error
	accountID, err = uuid.Parse(os.Getenv("AHASEND_ACCOUNT_ID"))
	if err != nil {
		log.Fatal("AHASEND_ACCOUNT_ID must be a UUID")
	}
	verifier, err = webhooks.NewWebhookVerifier(webhookSecret)
	if err != nil {
		log.Fatal("AHASEND_WEBHOOK_SECRET is invalid")
	}

	ahasendClient = api.NewAPIClient(api.WithAPIKey(apiKey))

	app := fiber.New(fiber.Config{
		BodyLimit:    maxBodyBytes,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 30 * time.Second,
		IdleTimeout:  60 * time.Second,
	})

	// Authentication runs first so unauthenticated floods are rejected before
	// they can consume the limiter budget that legitimate callers share.
	sendLimit := limiter.New(limiter.Config{Max: 30, Expiration: time.Minute})
	app.Post("/api/welcome", requireWelcomeToken, sendLimit, limitSendBody, sendWelcome)
	app.Post("/webhooks/ahasend", handleAhaSendWebhook)
	log.Fatal(app.Listen(":8080"))
}

package main

import (
	"context"
	"crypto/subtle"
	"errors"
	"log"
	"net/mail"
	"strings"
	"time"

	"github.com/AhaSend/ahasend-go"
	"github.com/AhaSend/ahasend-go/api"
	"github.com/AhaSend/ahasend-go/models/common"
	"github.com/AhaSend/ahasend-go/models/requests"
	"github.com/gofiber/fiber/v3"
	"github.com/google/uuid"
)

// sandbox runs the send through validation and fires the matching webhooks
// without delivering anything. Flip it only when you intend to send real mail.
const sandbox = true

// The send route only ever receives a small JSON object, so cap it far below
// the server-wide BodyLimit that the webhook route needs.
const maxSendBodyBytes = 16 << 10

type welcomeInput struct {
	EventID string `json:"event_id"`
	Email   string `json:"email"`
	Name    string `json:"name"`
}

func requireWelcomeToken(c fiber.Ctx) error {
	provided := strings.TrimPrefix(c.Get(fiber.HeaderAuthorization), "Bearer ")
	if subtle.ConstantTimeCompare([]byte(provided), []byte(welcomeEndpointToken)) != 1 {
		return c.SendStatus(fiber.StatusUnauthorized)
	}
	return c.Next()
}

func limitSendBody(c fiber.Ctx) error {
	// Refusing Content-Encoding here keeps a few compressed kilobytes from
	// expanding into a BodyLimit-sized decode when the binder reads the body.
	if len(c.Request().Header.ContentEncoding()) > 0 {
		return c.SendStatus(fiber.StatusUnsupportedMediaType)
	}
	if len(c.BodyRaw()) > maxSendBodyBytes {
		return c.SendStatus(fiber.StatusRequestEntityTooLarge)
	}
	return c.Next()
}

func sendWelcome(c fiber.Ctx) error {
	var in welcomeInput
	if err := c.Bind().Body(&in); err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "invalid request body"})
	}
	// ParseAddress also accepts `Name <a@b.com>`, so reject anything that did
	// not arrive as a bare address rather than mailing the embedded one.
	address, err := mail.ParseAddress(in.Email)
	if err != nil || address.Address != in.Email {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "a plain email address is required"})
	}
	// event_id becomes an outbound header value, so pin it to a known shape
	// rather than forwarding whatever the caller sent.
	eventID, err := uuid.Parse(in.EventID)
	if err != nil {
		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{"error": "event_id must be a UUID"})
	}

	message := requests.CreateMessageRequest{
		From:        common.SenderAddress{Email: "hello@yourdomain.com", Name: ahasend.String("Your App")},
		Recipients:  []common.Recipient{{Email: in.Email, Name: ahasend.String(in.Name)}},
		Subject:     "Welcome to Your App!",
		HtmlContent: ahasend.String("<h1>Welcome aboard 🎉</h1><p>We're glad you're here.</p>"),
		TextContent: ahasend.String("Welcome aboard! We're glad you're here."),
		Sandbox:     ahasend.Bool(sandbox),
	}

	idempotencyKey := "live-welcome-" + eventID.String()
	if sandbox {
		idempotencyKey = "sandbox-welcome-" + eventID.String()
	}

	ctx, cancel := context.WithTimeout(c, 30*time.Second)
	defer cancel()

	response, _, err := ahasendClient.MessagesAPI.CreateMessage(
		ctx,
		accountID,
		message,
		api.WithIdempotencyKey(idempotencyKey),
	)
	if err != nil {
		var apiErr *api.APIError
		if errors.As(err, &apiErr) {
			log.Printf("AhaSend error status=%d type=%s request_id=%s", apiErr.StatusCode, apiErr.Type, apiErr.RequestID)
			return c.Status(fiber.StatusBadGateway).JSON(fiber.Map{"error": "failed to send email"})
		}
		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{"error": "unexpected error"})
	}

	queued, rejected := 0, 0
	for _, result := range response.Data {
		switch result.Status {
		case "queued", "scheduled":
			queued++
		default:
			rejected++
		}
	}
	if rejected > 0 || queued == 0 {
		log.Printf("AhaSend rejected recipients: count=%d", rejected)
		return c.Status(fiber.StatusBadGateway).JSON(fiber.Map{"error": "email was not accepted"})
	}
	return c.Status(fiber.StatusAccepted).JSON(fiber.Map{"queued": queued})
}

package main

import (
	"errors"
	"log"
	"net/http"

	"github.com/AhaSend/ahasend-go/webhooks"
	"github.com/gofiber/fiber/v3"
)

func handleAhaSendWebhook(c fiber.Ctx) error {
	headers := make(http.Header)
	headers.Set(webhooks.HeaderWebhookID, c.Get(webhooks.HeaderWebhookID))
	headers.Set(webhooks.HeaderWebhookTimestamp, c.Get(webhooks.HeaderWebhookTimestamp))
	headers.Set(webhooks.HeaderWebhookSignature, c.Get(webhooks.HeaderWebhookSignature))

	event, err := verifier.Parse(c.BodyRaw(), headers)
	if err != nil {
		switch {
		case errors.Is(err, webhooks.ErrUnknownEventType):
			return c.SendStatus(fiber.StatusOK)
		case errors.Is(err, webhooks.ErrMissingHeaders),
			errors.Is(err, webhooks.ErrInvalidSignature),
			errors.Is(err, webhooks.ErrExpiredTimestamp):
			return c.SendStatus(fiber.StatusUnauthorized)
		case errors.Is(err, webhooks.ErrInvalidPayload):
			return c.SendStatus(fiber.StatusBadRequest)
		default:
			// Every error Parse returns describes the delivery rather than a
			// fault on this side: an unparseable webhook-timestamp header
			// lands here. Answering 500 would let any unauthenticated caller
			// drive your server-error alerts.
			return c.SendStatus(fiber.StatusBadRequest)
		}
	}

	switch event.(type) {
	case *webhooks.MessageDeliveredEvent:
		log.Print("message delivered")
	case *webhooks.MessageBouncedEvent:
		log.Print("message bounced")
	case *webhooks.MessageOpenedEvent:
		log.Print("message opened")
	default:
		log.Printf("unhandled event type: %s", event.GetType())
	}

	return c.SendStatus(fiber.StatusOK)
}