request.go

package d1http

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"math"
	"net/http"
	"net/url"
	"strings"
	"time"
)

func (c *Client) do(ctx context.Context, method, path string, query url.Values, body any, out any) error {
	if err := c.cfg.validateBase(); err != nil {
		return err
	}
	var bodyBytes []byte
	var err error
	if body != nil {
		bodyBytes, err = json.Marshal(body)
		if err != nil {
			return err
		}
	}
	attempts := c.cfg.Retry.MaxRetries + 1
	var lastErr error
	for attempt := 0; attempt < attempts; attempt++ {
		if attempt > 0 {
			wait := c.backoff(attempt)
			select {
			case <-ctx.Done():
				return ctx.Err()
			case <-time.After(wait):
			}
		}
		lastErr = c.doOnce(ctx, method, path, query, bodyBytes, out)
		if lastErr == nil || !IsRetryable(lastErr) || attempt == attempts-1 {
			return lastErr
		}
	}
	return lastErr
}

func (c *Client) doOnce(ctx context.Context, method, path string, query url.Values, bodyBytes []byte, out any) error {
	u := c.cfg.BaseURL + path
	if len(query) > 0 {
		u += "?" + query.Encode()
	}
	var body io.Reader
	if bodyBytes != nil {
		body = bytes.NewReader(bodyBytes)
	}
	req, err := http.NewRequestWithContext(ctx, method, u, body)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+c.cfg.APIToken)
	req.Header.Set("User-Agent", c.cfg.UserAgent)
	if bodyBytes != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	resp, err := c.cfg.HTTPClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return decodeAPIError(resp.StatusCode, respBody)
	}
	if out == nil {
		return nil
	}
	if err := json.Unmarshal(respBody, out); err != nil {
		return fmt.Errorf("decode cloudflare response: %w", err)
	}
	return nil
}

func decodeAPIError(status int, body []byte) error {
	var env envelope[json.RawMessage]
	if err := json.Unmarshal(body, &env); err == nil && (len(env.Errors) > 0 || len(env.Messages) > 0) {
		return &APIError{StatusCode: status, Errors: env.Errors, Messages: env.Messages, Body: string(body)}
	}
	return &APIError{StatusCode: status, Body: string(body)}
}

func (c *Client) backoff(attempt int) time.Duration {
	min := c.cfg.Retry.MinBackoff
	max := c.cfg.Retry.MaxBackoff
	d := time.Duration(float64(min) * math.Pow(2, float64(attempt-1)))
	if d > max {
		return max
	}
	return d
}

func apiPath(parts ...string) string {
	clean := make([]string, 0, len(parts))
	for _, p := range parts {
		clean = append(clean, strings.Trim(p, "/"))
	}
	return "/" + strings.Join(clean, "/")
}