How to Send Email with Gin (Go)

package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/AhaSend/ahasend-go/api"
	"github.com/AhaSend/ahasend-go/webhooks"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

var (
	ahasendClient *api.APIClient
	accountID     uuid.UUID
)

func main() {
	var err error
	accountID, err = uuid.Parse(mustEnv("AHASEND_ACCOUNT_ID"))
	if err != nil {
		log.Fatal("invalid AHASEND_ACCOUNT_ID")
	}

	retryConfig := api.DefaultRetryConfig()
	retryConfig.MaxRetries = 1
	ahasendClient = api.NewAPIClient(
		api.WithAPIKey(mustEnv("AHASEND_API_KEY")),
		api.WithHTTPClient(&http.Client{Timeout: 10 * time.Second}),
		api.WithRetryConfig(retryConfig),
	)
	verifier, err = webhooks.NewWebhookVerifier(mustEnv("AHASEND_WEBHOOK_SECRET"))
	if err != nil {
		log.Fatal("failed to create webhook verifier")
	}

	gin.SetMode(gin.ReleaseMode)
	r := gin.New()
	r.Use(gin.Logger(), gin.Recovery())
	if err := r.SetTrustedProxies(nil); err != nil {
		log.Fatal("failed to configure trusted proxies")
	}

	internal := r.Group("/api", gin.BasicAuth(gin.Accounts{
		mustEnv("WELCOME_API_USER"): mustEnv("WELCOME_API_PASSWORD"),
	}))
	internal.POST("/welcome", sendWelcome)
	r.POST("/webhooks/ahasend", handleAhaSendWebhook)

	server := &http.Server{
		Addr:              ":8080",
		Handler:           r,
		ReadHeaderTimeout: 5 * time.Second,
		ReadTimeout:       10 * time.Second,
		WriteTimeout:      30 * time.Second,
		IdleTimeout:       60 * time.Second,
	}

	serverErrors := make(chan error, 1)
	go func() { serverErrors <- server.ListenAndServe() }()

	shutdownSignal, stop := signal.NotifyContext(
		context.Background(),
		syscall.SIGINT,
		syscall.SIGTERM,
	)
	defer stop()

	select {
	case <-shutdownSignal.Done():
	case err := <-serverErrors:
		if !errors.Is(err, http.ErrServerClosed) {
			log.Fatal("server failed")
		}
		return
	}

	shutdownContext, cancel := context.WithTimeout(context.Background(), 35*time.Second)
	defer cancel()
	if err := server.Shutdown(shutdownContext); err != nil {
		log.Print("server shutdown failed")
	}
}

func mustEnv(name string) string {
	value := os.Getenv(name)
	if value == "" {
		log.Fatalf("%s is required", name)
	}
	return value
}

package main

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"log"
	"net/http"
	"strconv"
	"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/gin-gonic/gin"
)

type welcomeInput struct {
	SignupID string `json:"signup_id" binding:"required,max=128"`
	Email    string `json:"email" binding:"required,email"`
	Name     string `json:"name" binding:"max=200"`
}

func sendWelcome(c *gin.Context) {
	c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, 16<<10)

	var in welcomeInput
	if err := c.ShouldBindJSON(&in); err != nil {
		var tooLarge *http.MaxBytesError
		if errors.As(err, &tooLarge) {
			c.JSON(http.StatusRequestEntityTooLarge, gin.H{"error": "request too large"})
			return
		}
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
		return
	}

	recipient := common.Recipient{Email: in.Email}
	if in.Name != "" {
		recipient.Name = ahasend.String(in.Name)
	}

	message := requests.CreateMessageRequest{
		From:        common.SenderAddress{Email: "hello@yourdomain.com", Name: ahasend.String("Your App")},
		Recipients:  []common.Recipient{recipient},
		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."),
	}

	digest := sha256.Sum256([]byte(in.SignupID))
	idempotencyKey := "welcome-" + hex.EncodeToString(digest[:])
	ctx, cancel := context.WithTimeout(c.Request.Context(), 25*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 request failed status=%d type=%s request_id=%s",
				apiErr.StatusCode,
				apiErr.Type,
				apiErr.RequestID,
			)
			switch apiErr.Type {
			case api.ErrorTypeIdempotency:
				// This key was already used with a different payload. Retrying
				// can never succeed, so do not answer with a 5xx.
				c.JSON(http.StatusConflict, gin.H{"error": "idempotency key reused with a different payload"})
				return
			case api.ErrorTypeIdempotencyConflict:
				// An earlier send with this key is still running upstream.
				c.Header("Retry-After", strconv.Itoa(apiErr.RetryAfter))
				c.JSON(http.StatusServiceUnavailable, gin.H{"error": "send already in progress"})
				return
			case api.ErrorTypeValidation,
				api.ErrorTypeAuthentication,
				api.ErrorTypePermission,
				api.ErrorTypeNotFound:
				// A rejected message, a revoked key, or a missing scope is a
				// deployment fault: every retry fails identically. Alert on
				// this rather than inviting callers to hammer it.
				c.JSON(http.StatusInternalServerError, gin.H{"error": "email service is misconfigured"})
				return
			case api.ErrorTypeRateLimit:
				// The SDK already backed off and retried. Hand the remaining
				// wait to the caller instead of hiding it behind a bare 502.
				if apiErr.RetryAfter > 0 {
					c.Header("Retry-After", strconv.Itoa(apiErr.RetryAfter))
				}
				c.JSON(http.StatusServiceUnavailable, gin.H{"error": "send rate limited"})
				return
			}
		} else {
			log.Print("AhaSend request failed")
		}
		c.JSON(http.StatusBadGateway, gin.H{"error": "failed to send email"})
		return
	}

	if response == nil || len(response.Data) != 1 {
		log.Print("AhaSend returned an unexpected result count")
		c.JSON(http.StatusBadGateway, gin.H{"error": "unexpected email result"})
		return
	}

	result := response.Data[0]
	if result.Status == "error" {
		log.Print("AhaSend rejected 1 recipient")
		c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "recipient rejected"})
		return
	}
	c.JSON(http.StatusAccepted, gin.H{"status": result.Status, "message_id": result.ID})
}

package main

import (
	"errors"
	"net/http"

	"github.com/AhaSend/ahasend-go/webhooks"
	"github.com/gin-gonic/gin"
)

var verifier *webhooks.WebhookVerifier

const maxWebhookBodyBytes int64 = 1 << 20

func handleAhaSendWebhook(c *gin.Context) {
	c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxWebhookBodyBytes)
	_, err := verifier.ParseRequest(c.Request)
	if err != nil {
		var tooLarge *http.MaxBytesError
		switch {
		case errors.As(err, &tooLarge):
			c.Status(http.StatusRequestEntityTooLarge)
		case errors.Is(err, webhooks.ErrUnknownEventType):
			// ParseRequest verifies the signature before classifying the event.
			c.Status(http.StatusNoContent)
		default:
			c.Status(http.StatusBadRequest)
		}
		return
	}

	// This minimal receiver has no business side effect.
	c.Status(http.StatusNoContent)
}