Go Email SDK (ahasend-go)

go mod init example.com/ahasend-go-sdk
go get github.com/AhaSend/ahasend-go
go get github.com/google/uuid

retryConfig := api.RetryConfig{
	Enabled:         true,
	MaxRetries:      3,
	BackoffStrategy: api.BackoffExponential,
	BaseDelay:       time.Second,
	MaxDelay:        30 * time.Second,
}

client := api.NewAPIClient(
	api.WithAPIKey(apiKey),
	api.WithRetryConfig(retryConfig),
)

// Keep aggregate requests across all client instances within your account limit.
client.SetSendMessageRateLimit(100, 200) // requests per second, burst

import (
	"errors"
	"net/http"

	"github.com/AhaSend/ahasend-go/api"
)

var apiErr *api.APIError
if errors.As(err, &apiErr) {
	switch apiErr.StatusCode {
	case http.StatusBadRequest:
		// validation problem with the request
	case http.StatusUnauthorized:
		// key malformed or revoked
	case http.StatusForbidden:
		// key lacks the required scope
	case http.StatusUnprocessableEntity:
		// idempotency key reused with a different request payload
	case http.StatusTooManyRequests:
		// configured retries are exhausted, or retries are disabled
	}
}

response, _, err := client.MessagesAPI.CreateMessage(
	ctx, accountID, message,
	api.WithIdempotencyKey(fmt.Sprintf("order-confirmation-%s", orderID)),
)

import (
	"context"
	"errors"
	"net/http"
	"os"

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

const maxWebhookBodyBytes int64 = 30_000_000

type webhookStore interface {
	// EnqueueOnce atomically records webhookID and durable work for event.
	// It returns false when that ID was already committed.
	EnqueueOnce(ctx context.Context, webhookID string, event webhooks.WebhookEvent) (bool, error)
}

func newWebhookHandler(store webhookStore) http.Handler {
	secret := os.Getenv("AHASEND_WEBHOOK_SECRET")
	if secret == "" {
		panic("AHASEND_WEBHOOK_SECRET is required")
	}
	verifier, err := webhooks.NewWebhookVerifier(secret)
	if err != nil {
		panic("invalid AHASEND_WEBHOOK_SECRET")
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		r.Body = http.MaxBytesReader(w, r.Body, maxWebhookBodyBytes)
		event, err := verifier.ParseRequest(r)
		if err != nil {
			var maxBytesErr *http.MaxBytesError
			switch {
			case errors.As(err, &maxBytesErr):
				w.WriteHeader(http.StatusRequestEntityTooLarge)
			case errors.Is(err, webhooks.ErrMissingHeaders),
				errors.Is(err, webhooks.ErrInvalidSignature),
				errors.Is(err, webhooks.ErrExpiredTimestamp):
				w.WriteHeader(http.StatusUnauthorized)
			case errors.Is(err, webhooks.ErrUnknownEventType):
				// Acknowledge a validly signed event this application does not use.
				w.WriteHeader(http.StatusNoContent)
			default:
				w.WriteHeader(http.StatusBadRequest)
			}
			return
		}

		webhookID := r.Header.Get(webhooks.HeaderWebhookID)
		accepted, err := store.EnqueueOnce(r.Context(), webhookID, event)
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		if !accepted {
			w.WriteHeader(http.StatusOK)
			return
		}

		w.WriteHeader(http.StatusAccepted)
	})
}