fixup! fixup! Finally - fixed the cache version for single query if its enabled via header.

README.md

@@ -9,6 +9,7 @@ Ps. It's Hasura friendly.
   - [Features](#features)
   - [Usage example](#usage-example)
     - [Environment variables](#environment-variables)
+    - [Modifiers on the fly](#modifiers-on-the-fly)
     - [Cache](#cache)
     - [Example reader code](#example-reader-code)
     - [Tips](#tips)
@@ -40,6 +41,11 @@ Therefore, I present you the simple client to which you can copy & paste your gr
 * `GRAPHQL_RETRIES_NUMBER` - Number of retries: Default: `1`
 * `GRAPHQL_RETRIES_DELAY` - Delay in retries in milliseconds. Default: `250`
 
+### Modifiers on the fly
+
+* `gql.SetEndpoint('your-endpoint-url')` - modifies endpoint, without the need to set the environment variable
+* `gql.SetOutput('byte')` - modifies output format, without the need to set the environment variable
+
 ### Cache
 
 You have two options to enable the cache:

base.go

@@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"time"
 
+	"github.com/allegro/bigcache"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
 
@@ -14,7 +15,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/allegro/bigcache"
 	"github.com/gookit/goutil/envutil"
 )
 
@@ -43,11 +43,7 @@ func NewConnection() *BaseClient {
 	b.retries.delay = envutil.GetInt("GRAPHQL_RETRIES_DELAY", 300)
 
 	if b.cache.enabled {
-		var err error
-		b.cache.client, err = bigcache.NewBigCache(bigcache.DefaultConfig(time.Duration(b.cache.ttl) * time.Second))
-		if err != nil {
-			b.Logger.Error(b, "Error while creating cache client;", "error", err.Error())
-		}
+		b.enableCache()
 	}
 
 	b_tmp_log_level := envutil.Getenv("LOG_LEVEL", "info")
@@ -102,3 +98,11 @@ func (b *BaseClient) SetEndpoint(endpoint string) {
 func (b *BaseClient) SetOutput(output string) {
 	b.responseType = output
 }
+
+func (b *BaseClient) enableCache() {
+	var err error
+	b.cache.client, err = bigcache.NewBigCache(bigcache.DefaultConfig(time.Duration(b.cache.ttl) * time.Second))
+	if err != nil {
+		b.Logger.Error(b, "Error while creating cache client;", "error", err.Error())
+	}
+}

query.go

@@ -70,51 +70,61 @@ func (c *BaseClient) NewQuery(q ...any) *Query {
 // It looks a bit weird because of the backward compatibility
 
 func (c *BaseClient) Query(queryContent string, queryVariables interface{}, queryHeaders map[string]interface{}) (any, error) {
-	query := c.NewQuery(queryContent, queryVariables)
-
 	var queryHash string
 	var cachedResponse []byte
-	var cacheBaseClient BaseClient
+
+	cbc := reflect.ValueOf(*c).Interface().(BaseClient)
+	cacheBaseClient := &cbc
+
+	query := cacheBaseClient.NewQuery(queryContent, queryVariables)
 
 	// Check for library specific headers
 	if len(queryHeaders) > 0 {
-		cacheBaseClient = reflect.ValueOf(*c).Interface().(BaseClient)
-		queryHeaders = c.parseQueryHeaders(queryHeaders)
-		defer func() {
-			*c = cacheBaseClient
-		}()
-	}
+		queryHeadersModified := cacheBaseClient.parseQueryHeaders(queryHeaders)
+		// compare if there are any changes
 
-	if c.cache.enabled {
-		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", query.compiledQuery, queryHeaders))
-		c.Logger.Debug(c, "Hash calculated;", "hash:", queryHash)
-
-		cachedResponse = c.cacheLookup(queryHash)
-		if cachedResponse != nil {
-			c.Logger.Debug(c, "Found cached response")
-			return c.decodeResponse(cachedResponse), nil
-		} else {
-			c.Logger.Debug(c, "No cached response found")
+		if !reflect.DeepEqual(queryHeadersModified, queryHeaders) {
+			if cacheBaseClient.cache.enabled != c.cache.enabled && cacheBaseClient.cache.enabled {
+				cacheBaseClient.Logger.Debug(cacheBaseClient, "Switching cache on as per single-request header")
+				c.enableCache()
+			}
 		}
 	}
 
-	response, err := c.executeQuery(query.compiledQuery, queryHeaders)
+	if cacheBaseClient.cache.enabled {
+		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", query.compiledQuery, queryHeaders))
+		cacheBaseClient.Logger.Debug(cacheBaseClient, "Hash calculated;", "hash:", queryHash)
+
+		cachedResponse = c.cacheLookup(queryHash)
+		if cachedResponse != nil {
+			cacheBaseClient.Logger.Debug(cacheBaseClient, "Found cached response")
+			return cacheBaseClient.decodeResponse(cachedResponse), nil
+		} else {
+			cacheBaseClient.Logger.Debug(cacheBaseClient, "No cached response found")
+		}
+	}
+
+	response, err := cacheBaseClient.executeQuery(query.compiledQuery, queryHeaders)
 	if err != nil {
-		c.Logger.Error(c, "Error while executing query;", "error", err.Error())
+		cacheBaseClient.Logger.Error(cacheBaseClient, "Error while executing query;", "error", err.Error())
 		return nil, err
 	}
 
 	jsonData, err := json.Marshal(response)
 	if err != nil {
-		c.Logger.Error(c, "Error while converting to json;", "error", err.Error())
+		cacheBaseClient.Logger.Error(cacheBaseClient, "Error while converting to json;", "error", err.Error())
 		return nil, err
 	}
 
-	if c.cache.enabled {
+	if cacheBaseClient.cache.enabled && jsonData != nil && queryHash != "" {
 		c.cache.client.Set(queryHash, jsonData)
+	} else if cacheBaseClient.cache.enabled && jsonData == nil {
+		cacheBaseClient.Logger.Warn(cacheBaseClient, "Response is empty")
+	} else if cacheBaseClient.cache.enabled && queryHash == "" {
+		cacheBaseClient.Logger.Warn(cacheBaseClient, "Query hash is empty")
 	}
 
-	return c.decodeResponse(jsonData), err
+	return cacheBaseClient.decodeResponse(jsonData), err
 }
 
 func (c *BaseClient) decodeResponse(jsonData []byte) any {

query_test.go

@@ -1,6 +1,7 @@
 package gql
 
 import (
+	"math/rand"
 	"reflect"
 	"testing"
 
@@ -339,3 +340,193 @@ func TestBaseClient_parseQueryHeaders(t *testing.T) {
 		})
 	}
 }
+
+func TestBaseClient_QueryCache(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+				cache_enabled:    true,
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+		{
+			name: "Test QueryCache - disabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+				cache_enabled:    false,
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			c.cache.enabled = tt.fields.cache_enabled
+
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+			if !tt.wantErr {
+				assert.NoError(t, err)
+			} else {
+				assert.Error(t, err)
+			}
+		})
+	}
+}
+
+func TestBaseClient_QueryCacheRandomizedRace(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			for i := 0; i < 10; i++ {
+				c.cache.enabled = rand.Intn(2) == 0
+				go func() {
+					_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+					if !tt.wantErr {
+						assert.NoError(t, err)
+					} else {
+						assert.Error(t, err)
+					}
+				}()
+			}
+		})
+	}
+}
+
+func TestBaseClient_QueryCacheRandomizedRaceViaHeader(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			for i := 0; i < 10; i++ {
+				tt.args.queryHeaders["gqlcache"] = rand.Intn(2) == 0
+				go func() {
+					_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+					if !tt.wantErr {
+						assert.NoError(t, err)
+					} else {
+						assert.Error(t, err)
+					}
+				}()
+			}
+		})
+	}
+}