How to Send Email from Azure Functions (Go)

package main
import (
  "context"
  "os"
  "github.com/AhaSend/ahasend-go/api"
  "github.com/AhaSend/ahasend-go/models/common"
  "github.com/AhaSend/ahasend-go/models/requests"
  "github.com/google/uuid"
)
func main() {
  client := api.NewAPIClient(api.WithAPIKey(os.Getenv("AHASEND_API_KEY")))
  text, sandbox := "Hello from AhaSend", true
  result, response, err := client.MessagesAPI.CreateMessage(context.Background(), uuid.MustParse(os.Getenv("AHASEND_ACCOUNT_ID")), requests.CreateMessageRequest{
    From: common.SenderAddress{Email: os.Getenv("AHASEND_FROM")}, Recipients: []common.Recipient{{Email: "recipient@example.com"}},
    Subject: "My first sandbox email", TextContent: &text, Sandbox: &sandbox,
  })
  if err != nil { panic("Sandbox request failed; check credentials, sender and account") }
  if len(result.Data) == 0 { panic("No recipient results") }
  for _, item := range result.Data { println("HTTP", response.StatusCode, "recipient status", item.Status); if item.Status != "queued" && item.Status != "scheduled" { panic("Recipient rejected") } }
}

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "custom",
    "AHASEND_API_KEY": "aha-sk-...",
    "AHASEND_ACCOUNT_ID": "your-account-uuid",
    "AHASEND_WEBHOOK_SECRET": "aha-whsec-..."
  }
}

package main

import (
	"encoding/json"
	"errors"
	"log"
	"net/http"
	"net/mail"
	"os"

	"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/AhaSend/ahasend-go/webhooks"
	"github.com/google/uuid"
)

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

func main() {
	var err error
	accountID, err = uuid.Parse(os.Getenv("AHASEND_ACCOUNT_ID"))
	if err != nil {
		log.Fatalf("invalid AHASEND_ACCOUNT_ID: %v", err)
	}
	apiKey := os.Getenv("AHASEND_API_KEY")
	if apiKey == "" {
		log.Fatal("AHASEND_API_KEY is required")
	}
	webhookSecret := os.Getenv("AHASEND_WEBHOOK_SECRET")
	if webhookSecret == "" {
		log.Fatal("AHASEND_WEBHOOK_SECRET is required")
	}
	ahasendClient = api.NewAPIClient(api.WithAPIKey(apiKey))
	verifier, err = webhooks.NewWebhookVerifier(webhookSecret)
	if err != nil {
		log.Fatalf("failed to create webhook verifier: %v", err)
	}

	port := os.Getenv("FUNCTIONS_CUSTOMHANDLER_PORT")
	if port == "" {
		port = "8080" // running outside the Functions host
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/api/SendWelcome", sendWelcome)
	mux.HandleFunc("/api/AhaSendWebhook", handleAhaSendWebhook)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

const maxSendBodyBytes = 64 << 10

type welcomeInput struct {
	Email          string `json:"email"`
	Name           string `json:"name"`
	IdempotencyKey string `json:"idempotency_key"`
}

func sendWelcome(w http.ResponseWriter, r *http.Request) {
	r.Body = http.MaxBytesReader(w, r.Body, maxSendBodyBytes)

	var in welcomeInput
	if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
		var tooLarge *http.MaxBytesError
		if errors.As(err, &tooLarge) {
			http.Error(w, "request body too large", http.StatusRequestEntityTooLarge)
			return
		}
		http.Error(w, "request body must be JSON", http.StatusBadRequest)
		return
	}

	// Reject anything that isn't a bare address, so a display name can't be
	// smuggled in through the email field.
	addr, err := mail.ParseAddress(in.Email)
	if err != nil || addr.Address != in.Email {
		http.Error(w, "email must be a bare address such as user@example.com", http.StatusBadRequest)
		return
	}
	if in.IdempotencyKey == "" || len(in.IdempotencyKey) > 255 {
		http.Error(w, "idempotency_key is required and must be at most 255 characters", http.StatusBadRequest)
		return
	}
	if len(in.Name) > 100 {
		http.Error(w, "name must be at most 100 characters", http.StatusBadRequest)
		return
	}

	message := requests.CreateMessageRequest{
		Sandbox: ahasend.Bool(true),
		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."),
	}

	response, _, err := ahasendClient.MessagesAPI.CreateMessage(
		r.Context(), accountID, message,
		api.WithIdempotencyKey(in.IdempotencyKey),
	)
	if err != nil {
		var apiErr *api.APIError
		if errors.As(err, &apiErr) {
			// Log identifiers only. The raw response body echoes the
			// recipient address and belongs nowhere near your logs.
			log.Printf("AhaSend send failed: status=%d type=%s request_id=%s",
				apiErr.StatusCode, apiErr.Type, apiErr.RequestID)
			http.Error(w, "failed to send email", http.StatusBadGateway)
			return
		}
		log.Print("AhaSend send failed before a response arrived")
		http.Error(w, "unexpected error", http.StatusInternalServerError)
		return
	}

	// A 202 reports one result per recipient, so success is per entry: a
	// rejected recipient comes back with status "error" and a nil ID.
	if len(response.Data) == 0 {
		log.Print("AhaSend returned no per-recipient result")
		http.Error(w, "failed to send email", http.StatusBadGateway)
		return
	}
	result := response.Data[0]
	if result.Status == "error" || result.ID == nil {
		log.Printf("AhaSend rejected the recipient: status=%s", result.Status)
		http.Error(w, "failed to send email", http.StatusBadGateway)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(map[string]string{"message_id": *result.ID}); err != nil {
		log.Printf("failed to write response: %v", err)
	}
}

package main

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

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

// Delivery-status payloads are a few KB. Keep the cap tight: this endpoint is
// anonymous, and the body is buffered before the signature can be checked.
const maxWebhookBodyBytes = 30_000_000

func handleAhaSendWebhook(w http.ResponseWriter, r *http.Request) {
	r.Body = http.MaxBytesReader(w, r.Body, maxWebhookBodyBytes)
	event, err := verifier.ParseRequest(r)
	if err != nil {
		var tooLarge *http.MaxBytesError
		switch {
		case errors.As(err, &tooLarge):
			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):
			// The signature was verified before the type was classified, so this
			// is a genuine event this SDK version doesn't know yet. Acknowledge
			// it: AhaSend disables a webhook after more than 100 consecutive failed attempts.
			w.WriteHeader(http.StatusOK)
		default:
			w.WriteHeader(http.StatusBadRequest)
		}
		return
	}

	// Log the message ID, not the recipient: Application Insights is not the
	// place to accumulate your users' email addresses.
	switch e := event.(type) {
	case *webhooks.MessageDeliveredEvent:
		log.Printf("delivered: message=%s", e.Data.ID)
	case *webhooks.MessageBouncedEvent:
		log.Printf("bounced: message=%s", e.Data.ID)
	case *webhooks.MessageOpenedEvent:
		// Scanners and prefetchers trip open tracking constantly, so anything
		// you act on should exclude them.
		log.Printf("opened: message=%s bot=%t", e.Data.ID, e.Data.IsBot)
	default:
		log.Printf("unhandled event type: %s", event.GetType())
	}

	w.WriteHeader(http.StatusOK)
}