How to Send Email from Google Cloud 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") } }
}

package emailfns

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"sync"

	"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/GoogleCloudPlatform/functions-framework-go/functions"
	"github.com/google/uuid"
)

var (
	sendOnce       sync.Once
	ahasendClient  *api.APIClient
	accountID      uuid.UUID
	sendInitErr    error
	webhookOnce    sync.Once
	verifier       *webhooks.WebhookVerifier
	webhookInitErr error
)

func init() {
	functions.HTTP("SendWelcome", sendWelcome)
	functions.HTTP("AhaSendWebhook", ahaSendWebhook)
}

func sendDependencies() (*api.APIClient, uuid.UUID, error) {
	sendOnce.Do(func() {
		apiKey := os.Getenv("AHASEND_API_KEY")
		if apiKey == "" {
			sendInitErr = errors.New("AHASEND_API_KEY is required")
			return
		}

		var err error
		accountID, err = uuid.Parse(os.Getenv("AHASEND_ACCOUNT_ID"))
		if err != nil {
			sendInitErr = fmt.Errorf("invalid AHASEND_ACCOUNT_ID: %w", err)
			return
		}
		ahasendClient = api.NewAPIClient(api.WithAPIKey(apiKey))
	})
	return ahasendClient, accountID, sendInitErr
}

func webhookVerifier() (*webhooks.WebhookVerifier, error) {
	webhookOnce.Do(func() {
		secret := os.Getenv("AHASEND_WEBHOOK_SECRET")
		if secret == "" {
			webhookInitErr = errors.New("AHASEND_WEBHOOK_SECRET is required")
			return
		}
		verifier, webhookInitErr = webhooks.NewWebhookVerifier(secret)
	})
	return verifier, webhookInitErr
}

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

func sendWelcome(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.Header().Set("Allow", http.MethodPost)
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 16*1024)
	decoder := json.NewDecoder(r.Body)
	decoder.DisallowUnknownFields()
	var in welcomeInput
	if err := decoder.Decode(&in); err != nil {
		var tooLarge *http.MaxBytesError
		if errors.As(err, &tooLarge) {
			w.WriteHeader(http.StatusRequestEntityTooLarge)
			return
		}
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	if in.Email == "" || len(in.Email) > 320 || len(in.Name) > 100 {
		w.WriteHeader(http.StatusBadRequest)
		return
	}
	eventID, err := uuid.Parse(in.EventID)
	if err != nil {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	client, accountID, err := sendDependencies()
	if err != nil {
		log.Print("AhaSend send function configuration is invalid")
		w.WriteHeader(http.StatusInternalServerError)
		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 := client.MessagesAPI.CreateMessage(
		r.Context(),
		accountID,
		message,
		api.WithIdempotencyKey("sandbox-welcome-"+eventID.String()),
	)
	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,
			)
			if apiErr.Type == api.ErrorTypeIdempotencyConflict {
				// An earlier send with this key is still in flight; the outcome
				// is undecided. Tell the caller to retry with the same event_id.
				w.Header().Set("Retry-After", strconv.Itoa(apiErr.RetryAfter))
				http.Error(w, "send already in progress", http.StatusConflict)
				return
			}
			http.Error(w, "failed to send email", http.StatusBadGateway)
			return
		}
		http.Error(w, "unexpected error", http.StatusInternalServerError)
		return
	}

	if len(response.Data) != 1 || response.Data[0].Status == "error" || response.Data[0].ID == nil {
		log.Printf("AhaSend recipients rejected: count=%d", len(response.Data))
		http.Error(w, "recipient was not accepted", http.StatusBadGateway)
		return
	}
	messageID := *response.Data[0].ID
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusAccepted)
	json.NewEncoder(w).Encode(map[string]string{"message_id": messageID})
}

func ahaSendWebhook(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		w.Header().Set("Allow", http.MethodPost)
		w.WriteHeader(http.StatusMethodNotAllowed)
		return
	}

	verifier, err := webhookVerifier()
	if err != nil {
		log.Print("AhaSend webhook function configuration is invalid")
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, 30_000_000)
	event, err := verifier.ParseRequest(r)
	if err != nil {
		var tooLarge *http.MaxBytesError
		if errors.As(err, &tooLarge) {
			w.WriteHeader(http.StatusRequestEntityTooLarge)
			return
		}
		if errors.Is(err, webhooks.ErrUnknownEventType) {
			w.WriteHeader(http.StatusNoContent)
			return
		}
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	log.Printf("AhaSend webhook accepted: type=%s", event.GetType())
	w.WriteHeader(http.StatusOK)
}

package main

import (
	"log"
	"os"

	"github.com/GoogleCloudPlatform/functions-framework-go/funcframework"

	_ "example.com/emailfns" // triggers init() and registers the functions
)

func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}
	// Loopback only. SendWelcome carries no authentication of its own — in
	// production Google IAM is the gate — so binding 0.0.0.0 here would hand
	// everyone on your network a mail relay for your domain.
	if err := funcframework.StartHostPort("127.0.0.1", port); err != nil {
		log.Fatalf("funcframework.StartHostPort: %v", err)
	}
}