Error Handling

params := &resend.SendEmailRequest{
	To:      []string{"[email protected]"},
	From:    "[email protected]",
	Text:    "hello world",
	Subject: "Hello from Golang",
}

sent, err := client.Emails.SendWithContext(ctx, params)
if err != nil {
	// Log the error
	log.Printf("Failed to send email: %v", err)
	
	// Handle based on error type
	// ... see sections below
	
	return err
}

log.Printf("Email sent successfully: %s", sent.Id)

import (
	"errors"
	"math"
	"time"
)

func sendEmailWithRetry(ctx context.Context, client *resend.Client, params *resend.SendEmailRequest, maxRetries int) (*resend.SendEmailResponse, error) {
	var sent *resend.SendEmailResponse
	var err error

	for attempt := 0; attempt <= maxRetries; attempt++ {
		sent, err = client.Emails.SendWithContext(ctx, params)
		
		// Success
		if err == nil {
			return sent, nil
		}

		// Check if it's a rate limit error
		if errors.Is(err, resend.ErrRateLimit) {
			var rateLimitErr *resend.RateLimitError
			if errors.As(err, &rateLimitErr) {
				// Use RetryAfter from API if available
				if retryAfter, parseErr := strconv.Atoi(rateLimitErr.RetryAfter); parseErr == nil {
					waitDuration := time.Duration(retryAfter) * time.Second
					fmt.Printf("Rate limited. Waiting %v before retry %d/%d\n",
						waitDuration, attempt+1, maxRetries)
					time.Sleep(waitDuration)
					continue
				}
			}
		}

		// For other errors, use exponential backoff
		if attempt < maxRetries {
			backoff := time.Duration(math.Pow(2, float64(attempt))) * time.Second
			fmt.Printf("Request failed (attempt %d/%d): %v. Retrying in %v...\n",
				attempt+1, maxRetries, err, backoff)
			time.Sleep(backoff)
			continue
		}

		// Max retries exceeded
		break
	}

	return nil, fmt.Errorf("failed after %d retries: %w", maxRetries, err)
}

// Usage
sent, err := sendEmailWithRetry(ctx, client, params, 3)
if err != nil {
	log.Printf("Failed to send email after retries: %v", err)
}

func sendEmailWithTimeout(ctx context.Context, client *resend.Client, params *resend.SendEmailRequest, timeout time.Duration) (*resend.SendEmailResponse, error) {
	ctx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	attempt := 0
	for {
		attempt++
		
		sent, err := client.Emails.SendWithContext(ctx, params)
		if err == nil {
			return sent, nil
		}

		// Check if context is done
		select {
		case <-ctx.Done():
			return nil, fmt.Errorf("timeout after %d attempts: %w", attempt, ctx.Err())
		default:
		}

		// Handle rate limit
		if errors.Is(err, resend.ErrRateLimit) {
			var rateLimitErr *resend.RateLimitError
			if errors.As(err, &rateLimitErr) {
				if retryAfter, parseErr := strconv.Atoi(rateLimitErr.RetryAfter); parseErr == nil {
					waitDuration := time.Duration(retryAfter) * time.Second
					
					// Check if we have time to wait
					select {
					case <-time.After(waitDuration):
						continue
					case <-ctx.Done():
						return nil, fmt.Errorf("timeout while waiting for rate limit: %w", ctx.Err())
					}
				}
			}
		}

		// For other errors, wait briefly before retry
		select {
		case <-time.After(1 * time.Second):
			continue
		case <-ctx.Done():
			return nil, fmt.Errorf("timeout: %w", ctx.Err())
		}
	}
}

// Usage: Retry for up to 30 seconds
sent, err := sendEmailWithTimeout(ctx, client, params, 30*time.Second)
if err != nil {
	log.Printf("Failed to send email: %v", err)
}

sent, err := client.Emails.SendWithContext(ctx, params)
if err != nil {
	// Check for validation errors
	if strings.Contains(err.Error(), "Invalid request") ||
	   strings.Contains(err.Error(), "validation") {
		log.Printf("Validation error: %v", err)
		
		// Don't retry validation errors - fix the input instead
		return fmt.Errorf("invalid email parameters: %w", err)
	}
	
	// Handle other errors
	return err
}

batchParams := []*resend.SendEmailRequest{
	{
		To:      []string{"[email protected]"},
		From:    "[email protected]",
		Subject: "Welcome",
		Text:    "Hello user 1",
	},
	{
		To:      []string{"invalid-email"},
		From:    "[email protected]",
		Subject: "Welcome",
		Text:    "Hello user 2",
	},
}

resp, err := client.Batch.SendWithContext(ctx, batchParams)
if err != nil {
	log.Printf("Batch request failed: %v", err)
	return err
}

// Check for partial failures
if len(resp.Errors) > 0 {
	fmt.Printf("Some emails failed:\n")
	for _, batchErr := range resp.Errors {
		fmt.Printf("  - Email at index %d failed: %s\n",
			batchErr.Index, batchErr.Message)
	}
}

// Process successful emails
fmt.Printf("Successfully sent %d emails:\n", len(resp.Data))
for i, sent := range resp.Data {
	fmt.Printf("  - Email %d: %s\n", i, sent.Id)
}