feat: sync configurable OTP delivery providers

internal/otpdelivery/webhook/sender.go

@@ -0,0 +1,201 @@
+package webhook
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"go.uber.org/zap"
+
+	"telesrv/internal/otpdelivery"
+)
+
+const (
+	protocolVersion  = "1"
+	maxResponseBytes = 64 << 10
+)
+
+type Config struct {
+	URL     string
+	Secret  string
+	Timeout time.Duration
+	Client  *http.Client
+	Logger  *zap.Logger
+}
+
+type Sender struct {
+	endpoint *url.URL
+	secret   []byte
+	client   *http.Client
+	logger   *zap.Logger
+}
+
+func New(cfg Config) (*Sender, error) {
+	endpoint, err := url.Parse(strings.TrimSpace(cfg.URL))
+	if err != nil {
+		return nil, fmt.Errorf("parse OTP webhook URL: %w", err)
+	}
+	if endpoint.Scheme != "http" && endpoint.Scheme != "https" {
+		return nil, fmt.Errorf("OTP webhook URL scheme must be http or https")
+	}
+	if endpoint.Host == "" || endpoint.User != nil {
+		return nil, fmt.Errorf("OTP webhook URL must contain a host and no userinfo")
+	}
+	if cfg.Timeout <= 0 {
+		cfg.Timeout = 5 * time.Second
+	}
+	client := cfg.Client
+	if client == nil {
+		client = &http.Client{
+			Timeout: cfg.Timeout,
+			CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		}
+	}
+	logger := cfg.Logger
+	if logger == nil {
+		logger = zap.NewNop()
+	}
+	return &Sender{endpoint: endpoint, secret: []byte(cfg.Secret), client: client, logger: logger}, nil
+}
+
+type requestBody struct {
+	Version    string              `json:"version"`
+	DeliveryID string              `json:"delivery_id"`
+	Purpose    otpdelivery.Purpose `json:"purpose"`
+	Channel    otpdelivery.Channel `json:"channel"`
+	Recipient  string              `json:"recipient"`
+	Code       string              `json:"code"`
+	ExpiresAt  string              `json:"expires_at"`
+	ExpiresIn  int64               `json:"expires_in"`
+	Locale     string              `json:"locale,omitempty"`
+}
+
+type responseBody struct {
+	Accepted  *bool  `json:"accepted"`
+	MessageID string `json:"message_id"`
+	ErrorCode string `json:"error_code"`
+	Retryable bool   `json:"retryable"`
+}
+
+func (s *Sender) Deliver(ctx context.Context, delivery otpdelivery.Request) (otpdelivery.Result, error) {
+	now := time.Now()
+	if err := delivery.Validate(now); err != nil {
+		return otpdelivery.Result{}, err
+	}
+	expiresIn := int64(delivery.ExpiresAt.Sub(now) / time.Second)
+	if expiresIn < 1 {
+		expiresIn = 1
+	}
+	body, err := json.Marshal(requestBody{
+		Version:    protocolVersion,
+		DeliveryID: delivery.DeliveryID,
+		Purpose:    delivery.Purpose,
+		Channel:    delivery.Channel,
+		Recipient:  delivery.Recipient,
+		Code:       delivery.Code,
+		ExpiresAt:  delivery.ExpiresAt.UTC().Format(time.RFC3339),
+		ExpiresIn:  expiresIn,
+		Locale:     delivery.Locale,
+	})
+	if err != nil {
+		return otpdelivery.Result{}, fmt.Errorf("encode OTP webhook request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, s.endpoint.String(), bytes.NewReader(body))
+	if err != nil {
+		return otpdelivery.Result{}, fmt.Errorf("create OTP webhook request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Idempotency-Key", delivery.DeliveryID)
+	timestamp := fmt.Sprint(now.Unix())
+	req.Header.Set("X-Telesrv-Timestamp", timestamp)
+	if len(s.secret) > 0 {
+		req.Header.Set("X-Telesrv-Signature", signature(s.secret, timestamp, body))
+	}
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		s.logger.Warn("OTP webhook delivery outcome is unknown",
+			zap.String("delivery_id", delivery.DeliveryID),
+			zap.String("purpose", string(delivery.Purpose)),
+			zap.String("channel", string(delivery.Channel)),
+			zap.Error(err))
+		return otpdelivery.Result{}, &otpdelivery.OutcomeUnknownError{Cause: err}
+	}
+	defer resp.Body.Close()
+
+	payload, readErr := io.ReadAll(io.LimitReader(resp.Body, maxResponseBytes+1))
+	if readErr != nil || len(payload) > maxResponseBytes {
+		cause := readErr
+		if cause == nil {
+			cause = fmt.Errorf("response exceeds %d bytes", maxResponseBytes)
+		}
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			s.logger.Warn("OTP webhook acknowledgement is unreadable",
+				zap.String("delivery_id", delivery.DeliveryID),
+				zap.Int("status", resp.StatusCode),
+				zap.Error(cause))
+			return otpdelivery.Result{}, &otpdelivery.OutcomeUnknownError{Cause: cause}
+		}
+		return otpdelivery.Result{}, &otpdelivery.RejectedError{StatusCode: resp.StatusCode, Code: "RESPONSE_UNREADABLE", Retryable: resp.StatusCode >= 500}
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		provider := decodeResponse(payload)
+		return otpdelivery.Result{}, &otpdelivery.RejectedError{
+			StatusCode: resp.StatusCode,
+			Code:       provider.ErrorCode,
+			Retryable:  provider.Retryable || resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500,
+		}
+	}
+	if resp.StatusCode == http.StatusNoContent {
+		return otpdelivery.Result{}, nil
+	}
+	provider := decodeResponse(payload)
+	if provider.Accepted == nil {
+		cause := fmt.Errorf("2xx response is missing accepted")
+		s.logger.Warn("OTP webhook acknowledgement is invalid",
+			zap.String("delivery_id", delivery.DeliveryID),
+			zap.Int("status", resp.StatusCode),
+			zap.Error(cause))
+		return otpdelivery.Result{}, &otpdelivery.OutcomeUnknownError{Cause: cause}
+	}
+	if !*provider.Accepted {
+		return otpdelivery.Result{}, &otpdelivery.RejectedError{
+			StatusCode: resp.StatusCode,
+			Code:       provider.ErrorCode,
+			Retryable:  provider.Retryable,
+		}
+	}
+	return otpdelivery.Result{ProviderMessageID: provider.MessageID}, nil
+}
+
+func decodeResponse(payload []byte) responseBody {
+	var result responseBody
+	if len(bytes.TrimSpace(payload)) == 0 {
+		return result
+	}
+	if err := json.Unmarshal(payload, &result); err != nil {
+		return responseBody{}
+	}
+	return result
+}
+
+func signature(secret []byte, timestamp string, body []byte) string {
+	mac := hmac.New(sha256.New, secret)
+	_, _ = mac.Write([]byte(timestamp))
+	_, _ = mac.Write([]byte("."))
+	_, _ = mac.Write(body)
+	return "sha256=" + hex.EncodeToString(mac.Sum(nil))
+}