feat: add retry option to graphql client (#168)

Author: japananh

graphql.go

@@ -5,10 +5,13 @@ import (
 	"compress/gzip"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"strings"
+	"time"
 
 	"github.com/hasura/go-graphql-client/pkg/jsonutil"
 )
@@ -19,6 +22,15 @@ type Doer interface {
 	Do(*http.Request) (*http.Response, error)
 }
 
+// ClientOption is used to configure client with options
+type ClientOption func(c *Client)
+
+func WithRetry(retries int) ClientOption {
+	return func(c *Client) {
+		c.retries = retries
+	}
+}
+
 // This function allows you to tweak the HTTP request. It might be useful to set authentication
 // headers  amongst other things
 type RequestModifier func(*http.Request)
@@ -29,19 +41,27 @@ type Client struct {
 	httpClient      Doer
 	requestModifier RequestModifier
 	debug           bool
+	retries         int // max number of retries, defaults to 0 for no retry see WithRetry option
 }
 
 // NewClient creates a GraphQL client targeting the specified GraphQL server URL.
 // If httpClient is nil, then http.DefaultClient is used.
-func NewClient(url string, httpClient Doer) *Client {
+func NewClient(url string, httpClient Doer, options ...ClientOption) *Client {
 	if httpClient == nil {
 		httpClient = http.DefaultClient
 	}
-	return &Client{
+
+	c := &Client{
 		url:             url,
 		httpClient:      httpClient,
 		requestModifier: nil,
 	}
+
+	for _, opt := range options {
+		opt(c)
+	}
+
+	return c
 }
 
 // Query executes a single GraphQL query request,
@@ -122,6 +142,37 @@ func (c *Client) buildQueryAndOptions(op operationType, v any, variables map[str
 
 // Request the common method that send graphql request
 func (c *Client) request(ctx context.Context, query string, variables map[string]any, options *constructOptionsOutput) ([]byte, []byte, *http.Response, io.Reader, Errors) {
+	var (
+		rawData, extensions []byte
+		resp                *http.Response
+		respReader          io.Reader
+		err                 Errors
+	)
+	c.withRetry(func() error {
+		rawData, extensions, resp, respReader, err = c.doRequest(ctx, query, variables, options)
+		return err
+	})
+	return rawData, extensions, resp, respReader, err
+}
+
+func (c *Client) withRetry(exec func() error) {
+	maxAttempts := c.retries + 1
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		err := exec()
+		if err == nil {
+			return
+		}
+
+		if attempt == maxAttempts || !c.shouldRetry(err) {
+			return
+		}
+
+		time.Sleep(time.Duration(attempt) * time.Second)
+	}
+}
+
+// doRequest sends graphql request.
+func (c *Client) doRequest(ctx context.Context, query string, variables map[string]any, options *constructOptionsOutput) ([]byte, []byte, *http.Response, io.Reader, Errors) {
 	in := GraphQLRequestPayload{
 		Query:     query,
 		Variables: variables,
@@ -256,6 +307,15 @@ func (c *Client) request(ctx context.Context, query string, variables map[string
 	return rawData, extensions, resp, respReader, nil
 }
 
+// shouldRetry determines whether a request should retry or not.
+func (c *Client) shouldRetry(err error) bool {
+	var uErr *url.Error
+	if errors.As(err, &uErr) {
+		return uErr.Timeout() || uErr.Temporary()
+	}
+	return true
+}
+
 // do executes a single GraphQL operation.
 // return raw message and error
 func (c *Client) doRaw(ctx context.Context, op operationType, v any, variables map[string]any, options ...Option) ([]byte, error) {

graphql_test.go

@@ -5,9 +5,11 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
+	"net"
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/hasura/go-graphql-client"
 )
@@ -619,3 +621,147 @@ func mustWrite(w io.Writer, s string) {
 		panic(err)
 	}
 }
+
+func TestClientOption_WithRetry_succeed(t *testing.T) {
+	var (
+		attempts    int
+		maxAttempts = 3
+	)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/graphql", func(w http.ResponseWriter, req *http.Request) {
+		attempts++
+		// Simulate a temporary network error except for the last attempt
+		if attempts <= maxAttempts-1 {
+			http.Error(w, "temporary error", http.StatusServiceUnavailable)
+			return
+		}
+		// Succeed on the last attempt
+		w.Header().Set("Content-Type", "application/json")
+		mustWrite(w, `{"data": {"user": {"name": "Gopher"}}}`)
+	})
+
+	client := graphql.NewClient("/graphql",
+		&http.Client{
+			Transport: localRoundTripper{
+				handler: mux,
+			},
+		},
+		graphql.WithRetry(maxAttempts-1),
+	)
+
+	var q struct {
+		User struct {
+			Name string
+		}
+	}
+
+	err := client.Query(context.Background(), &q, nil)
+	if err != nil {
+		t.Fatalf("got error: %v, want nil", err)
+	}
+
+	if attempts != maxAttempts {
+		t.Errorf("got %d attempts, want %d", attempts, maxAttempts)
+	}
+
+	if q.User.Name != "Gopher" {
+		t.Errorf("got q.User.Name: %q, want Gopher", q.User.Name)
+	}
+}
+
+func TestClientOption_WithRetry_maxRetriesExceeded(t *testing.T) {
+	var (
+		attempts    int
+		maxAttempts = 2
+	)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/graphql", func(w http.ResponseWriter, req *http.Request) {
+		attempts++
+		// Always fail with a temporary error
+		http.Error(w, "temporary error", http.StatusServiceUnavailable)
+	})
+
+	client := graphql.NewClient("/graphql",
+		&http.Client{
+			Transport: localRoundTripper{
+				handler: mux,
+			},
+		},
+		graphql.WithRetry(maxAttempts-1),
+	)
+
+	var q struct {
+		User struct {
+			Name string
+		}
+	}
+
+	err := client.Query(context.Background(), &q, nil)
+	if err == nil {
+		t.Fatal("got nil, want error")
+	}
+
+	// Check that we got the max retries exceeded error
+	var gqlErrs graphql.Errors
+	if !errors.As(err, &gqlErrs) {
+		t.Fatalf("got %T, want graphql.Errors", err)
+	}
+
+	if len(gqlErrs) != 1 {
+		t.Fatalf("got %d, want 1 error", len(gqlErrs))
+	}
+
+	// First request does not count
+	if attempts != maxAttempts {
+		t.Errorf("got %d attempts, want %d", attempts, maxAttempts)
+	}
+}
+
+// Define the custom RoundTripper type
+type roundTripperWithRetryCount struct {
+	Transport *http.Transport
+	attempts  *int
+}
+
+// Define RoundTrip method for the type
+func (c roundTripperWithRetryCount) RoundTrip(req *http.Request) (*http.Response, error) {
+	if c.attempts != nil {
+		*c.attempts++
+	}
+	return c.Transport.RoundTrip(req)
+}
+
+func TestClientOption_WithRetry_shouldNotRetry(t *testing.T) {
+	var attempts int
+
+	client := graphql.NewClient("/graphql",
+		&http.Client{
+			Transport: roundTripperWithRetryCount{
+				attempts: &attempts,
+				Transport: &http.Transport{
+					DialContext: (&net.Dialer{
+						Timeout:   3 * time.Second,
+						KeepAlive: 3 * time.Second,
+					}).DialContext,
+				},
+			},
+		},
+		graphql.WithRetry(3),
+	)
+
+	var q struct {
+		User struct {
+			Name string
+		}
+	}
+
+	err := client.Query(context.Background(), &q, nil)
+	if err == nil {
+		t.Fatal("got nil, want error")
+	}
+
+	// Should not retry on permanent URL errors
+	if attempts != 1 {
+		t.Errorf("got %d attempts, want 1", attempts)
+	}
+}