fixup! Add self-sufficient cache and abandon outdated library.

In high frequency environment the allegro bigcache caused significant
memory usage overhead. This commit replaces it with something much lighter.

base.go

@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/allegro/bigcache"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
 
 	"golang.org/x/net/http2"
 
@@ -22,11 +21,10 @@ import (
 func NewConnection() *BaseClient {
 
 	b := &BaseClient{
-		client:             &http.Client{},
+		client:         &http.Client{},
-		concurrencyManager: concurrency.NewPool(-1),
+		MaxGoRoutines:  -1,
-		MaxGoRoutines:      -1,
+		LoggingLevel:   logger.Warn,
-		LoggingLevel:       logger.Warn,
+		LoggerColorful: true,
-		LoggerColorful:     true,
 	}
 
 	if b.LoggerWriter == nil {
@@ -43,9 +41,7 @@ func NewConnection() *BaseClient {
 	b.retries.max = envutil.GetInt("GRAPHQL_RETRIES_MAX", 1)
 	b.retries.delay = envutil.GetInt("GRAPHQL_RETRIES_DELAY", 300)
 
-	if b.cache.enabled {
+	b.enableCache()
-		b.enableCache()
-	}
 
 	b_tmp_log_level := envutil.Getenv("LOG_LEVEL", "info")
 
@@ -68,9 +64,20 @@ func NewConnection() *BaseClient {
 	})
 
 	var httpClient *http.Client
+
+	httpTransport := &http.Transport{
+		MaxIdleConns:          10,
+		IdleConnTimeout:       15 * time.Second,
+		ResponseHeaderTimeout: 15 * time.Second,
+		DisableKeepAlives:     false,
+	}
+
 	if strings.HasPrefix(b.endpoint, "http://") {
 		httpClient = &http.Client{
-			Transport: http.DefaultTransport,
+			Transport: httpTransport,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
 		}
 	} else {
 		tlsClientConfig := &tls.Config{}
@@ -80,6 +87,8 @@ func NewConnection() *BaseClient {
 		http2Transport := &http2.Transport{
 			AllowHTTP:       true,
 			TLSClientConfig: tlsClientConfig,
+			ReadIdleTimeout: 15 * time.Second,
+			PingTimeout:     15 * time.Second,
 		}
 		httpClient = &http.Client{
 			Transport: http2Transport,
@@ -102,7 +111,7 @@ func (b *BaseClient) SetOutput(output string) {
 
 func (b *BaseClient) enableCache() {
 	var err error
-	b.cache.client, err = bigcache.NewBigCache(bigcache.DefaultConfig(time.Duration(b.cache.ttl) * time.Second))
+	b.cache.client = libpack_cache.New(time.Duration(b.cache.ttl) * time.Second * 2)
 	if err != nil {
 		fmt.Println(">> Error while creating cache client;", "error", err.Error())
 		panic(err)
@@ -112,5 +121,4 @@ func (b *BaseClient) enableCache() {
 func (b *BaseClient) disableCache() {
 	b.Logger.Debug(b, "Disabling cache")
 	b.cache.enabled = false
-	b.cache.client = nil
 }

base_test.go

@@ -10,16 +10,32 @@ import (
 
 func TestNewConnection(t *testing.T) {
 	tests := []struct {
-		want *BaseClient
+		want     *BaseClient
-		name string
+		cache    bool
+		endpoint string
+		output   string
+		name     string
 	}{
 		{
-			name: "Test NewConnection",
+			name:     "Test NewConnection https",
+			endpoint: "https://api.github.com/graphql",
+			output:   "string",
+			cache:    true,
 			want: &BaseClient{
 				endpoint:     "https://api.github.com/graphql",
 				responseType: "string",
 			},
 		},
+		{
+			name:     "Test NewConnection http",
+			endpoint: "http://api.github.com/graphql",
+			output:   "mapstring",
+			cache:    false,
+			want: &BaseClient{
+				endpoint:     "http://api.github.com/graphql",
+				responseType: "mapstring",
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -27,11 +43,19 @@ func TestNewConnection(t *testing.T) {
 			// and GRAPHQL_OUTPUT to string
 			current := os.Getenv("GRAPHQL_ENDPOINT")
 			defer os.Setenv("GRAPHQL_ENDPOINT", current)
-			os.Setenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql")
+			os.Setenv("GRAPHQL_ENDPOINT", tt.endpoint)
-
 			got := NewConnection()
+			got.SetEndpoint(tt.endpoint)
+			got.SetOutput(tt.output)
+			if tt.cache {
+				got.enableCache()
+			} else {
+				got.disableCache()
+			}
+
 			assert.Equal(t, tt.want.endpoint, got.endpoint)
 			assert.Equal(t, tt.want.responseType, got.responseType)
+			assert.Equal(t, tt.cache, got.cache.enabled)
 		})
 	}
 }

cache.go

@@ -2,10 +2,10 @@ package gql
 
 func (c *BaseClient) cacheLookup(hash string) []byte {
 	if c.cache.client != nil {
-		g, err := c.cache.client.Get(hash)
+		obj, found := c.cache.client.Get(hash)
-		if err == nil {
+		if found {
 			c.Logger.Debug(c, "Cache hit;", "hash", hash)
-			return g
+			return obj
 		}
 		// if error is not nil it means that hash is not present in cache
 		c.Logger.Debug(c, "Cache miss;", "hash", hash)

go.mod

@@ -1,29 +1,27 @@
 module github.com/lukaszraczylo/go-simple-graphql
 
-go 1.20
+go 1.21
 
 require (
-	github.com/allegro/bigcache v1.2.1
+	github.com/avast/retry-go/v4 v4.5.0
-	github.com/avast/retry-go/v4 v4.3.3
+	github.com/gookit/goutil v0.6.13
-	github.com/gookit/goutil v0.6.8
 	github.com/json-iterator/go v1.1.12
-	github.com/stretchr/testify v1.8.2
+	github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.3
-	golang.org/x/net v0.9.0
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/net v0.17.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gookit/color v1.5.3 // indirect
+	github.com/gookit/color v1.5.4 // indirect
-	github.com/kr/pretty v0.3.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/exp v0.0.0-20221126150942-6ab00d035af9 // indirect
+	golang.org/x/sync v0.4.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/sys v0.13.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/term v0.13.0 // indirect
-	golang.org/x/term v0.7.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,25 +1,22 @@
-github.com/allegro/bigcache v1.2.1 h1:hg1sY1raCwic3Vnsvje6TT7/pnZba83LeFck5NrFKSc=
+github.com/avast/retry-go/v4 v4.5.0 h1:QoRAZZ90cj5oni2Lsgl2GW8mNTnUCnmpx/iKpwVisHg=
-github.com/allegro/bigcache v1.2.1/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/avast/retry-go/v4 v4.5.0/go.mod h1:7hLEXp0oku2Nir2xBAsg0PTphp9z71bN5Aq1fboC3+I=
-github.com/avast/retry-go/v4 v4.3.3 h1:G56Bp6mU0b5HE1SkaoVjscZjlQb0oy4mezwY/cGH19w=
-github.com/avast/retry-go/v4 v4.3.3/go.mod h1:rg6XFaiuFYII0Xu3RDbZQkxCofFwruZKW8oEF1jpWiU=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/gookit/color v1.5.3 h1:twfIhZs4QLCtimkP7MOxlF3A0U/5cDPseRT9M/+2SCE=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
-github.com/gookit/color v1.5.3/go.mod h1:NUzwzeehUfl7GIb36pqId+UGmRfQcU/WiiyTTeNjHtE=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
-github.com/gookit/goutil v0.6.8 h1:B2XXSCGav5TXWtKRT9i/s/owOLXXB7sY6UsfqeSLroE=
+github.com/gookit/goutil v0.6.13 h1:ttg7yMda6Q9fkE4P+YTwozd2wH1Le0CQldTAtOFBr7o=
-github.com/gookit/goutil v0.6.8/go.mod h1:u+Isykc6RQcZ4GQzulsaGm+Famd97U5Tzp3aQyo+jyA=
+github.com/gookit/goutil v0.6.13/go.mod h1:YyDBddefmjS+mU2PDPgCcjVzTDM5WgExiDv5ZA/b8I8=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.3 h1:0BVn4/PyKDzo8XkZ4AGUBn7Fvg+ZU2zKAerQlUp9usY=
+github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.3/go.mod h1:AHNrWWwe1LsfrknP8CLZlRn0E0GQX9Jak4pmY1FUlZ0=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -27,35 +24,28 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-golang.org/x/exp v0.0.0-20221126150942-6ab00d035af9 h1:yZNXmy+j/JpX19vZkVktWqAo7Gny4PBWYYK3zskGpx4=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20221126150942-6ab00d035af9/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
+golang.org/x/term v0.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

query.go

@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
-
 	"github.com/gookit/goutil/strutil"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
 
 	jsoniter "github.com/json-iterator/go"
 )
@@ -69,68 +68,45 @@ 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) {
+
+	compiledQuery := c.NewQuery(queryContent, queryVariables)
+	parseQueryHeaders, enabledCache, headersModified, enabledRetries := compiledQuery.parseQueryHeaders(queryHeaders)
+
+	var should_cache, retries_enabled bool
 	var queryHash string
-	var cachedResponse []byte
 
-	query := c.NewQuery(queryContent, queryVariables)
+	if headersModified {
-
+		should_cache = enabledCache
-	localClientlocal := *c
+		retries_enabled = enabledRetries
-	localClient := &localClientlocal
+	} else {
-
+		should_cache = c.cache.enabled
-	// Check for library specific headers
+		retries_enabled = c.retries.enabled
-	if len(queryHeaders) > 0 {
-		queryHeadersModified, cache_enabled, headers_modified := c.parseQueryHeaders(queryHeaders)
-
-		if headers_modified {
-			queryHeaders = queryHeadersModified
-			c.Logger.Debug(c, fmt.Sprintf("Switching cache %s as per single-request header", strconv.FormatBool(cache_enabled)))
-			if cache_enabled {
-
-				// this doesn't make sense - cache is created but its ttl is longer than query execution so it'll be disappeared before it's used
-				localClient.enableCache()
-			} else {
-				localClient.disableCache()
-			}
-		}
 	}
 
-	if localClient.cache.enabled {
+	// if queryContent does not start with `query` then we don't want to cache it
-		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", query.compiledQuery, queryHeaders))
+	// because it's probably a mutation or subscription.
-		c.Logger.Debug(c, "Hash calculated;", "hash:", queryHash)
+	if !strutil.HasPrefix(queryContent, "query") {
-
+		should_cache = false
-		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")
-		}
 	}
 
-	response, err := localClient.executeQuery(query.compiledQuery, queryHeaders)
+	if should_cache {
-	if err != nil {
+		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", compiledQuery.compiledQuery, queryHeaders))
-		c.Logger.Error(c, "Error while executing query;", "error", err.Error())
-		return nil, err
 	}
 
-	jsonData, err := json.Marshal(response)
+	q := &queryExecutor{
-	if err != nil {
+		client:          c,
-		c.Logger.Error(c, "Error while converting to json;", "error", err.Error())
+		query:           compiledQuery.compiledQuery,
-		return nil, err
+		headers:         parseQueryHeaders,
+		context:         context.Background(),
+		should_cache:    should_cache,
+		retries_enabled: retries_enabled,
+		hash:            queryHash,
 	}
 
-	if localClient.cache.enabled && c.cache.client != nil && jsonData != nil && queryHash != "" {
+	q.execute()
-		err = c.cache.client.Set(queryHash, jsonData)
+	defer q.done()
-		if err != nil {
-			c.Logger.Error(c, "Error while setting cache key;", "error", err.Error())
-		}
-	} else if localClient.cache.enabled && c.cache.enabled && jsonData == nil {
-		c.Logger.Warn(c, "Response is empty")
-	} else if localClient.cache.enabled && c.cache.enabled && queryHash == "" {
-		c.Logger.Warn(c, "Query hash is empty")
-	}
 
-	return c.decodeResponse(jsonData), err
+	return q.result.data, q.result.errors
 }
 
 func (c *BaseClient) decodeResponse(jsonData []byte) any {
@@ -153,19 +129,24 @@ func (c *BaseClient) decodeResponse(jsonData []byte) any {
 	}
 }
 
-func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}, cache_enabled bool, headers_modified bool) {
+func (q *Query) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}, cache_enabled bool, headers_modified bool, retries_enabled bool) {
 	returnHeaders = make(map[string]interface{})
+	var err error
+
 	for k, v := range queryHeaders {
 		if k == "gqlcache" {
-			cache_enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			cache_enabled, err = strconv.ParseBool(fmt.Sprintf("%v", v))
+			if err != nil {
+				panic(fmt.Sprintf("Unable to parse gqlcache value %s", err.Error()))
+			}
 			headers_modified = true
 			continue
 		}
 		if k == "gqlretries" {
-			c.retries.enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			retries_enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
 			continue
 		}
 		returnHeaders[k] = v
 	}
-	return returnHeaders, cache_enabled, headers_modified
+	return returnHeaders, cache_enabled, headers_modified, retries_enabled
 }

query_test.go

@@ -41,6 +41,17 @@ func TestBaseClient_convertToJson(t *testing.T) {
 			},
 			want: []byte(`{"query":"query { hello }","variables":{"name":"John"}}`),
 		},
+		{
+			name:   "Test NewQuery with modifier",
+			fields: fields{},
+			args: args{
+				v: map[string]interface{}{
+					"query":     "query @cached(ttl: 120) { hello }",
+					"variables": map[string]interface{}{"name": "John"},
+				},
+			},
+			want: []byte(`{"query":"query @cached(ttl: 120) { hello }","variables":{"name":"John"}}`),
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -89,6 +100,19 @@ func TestBaseClient_NewQuery(t *testing.T) {
 				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query { hello }"}`),
 			},
 		},
+		{
+			name:   "Test NewQuery with modifier",
+			fields: fields{},
+			args: args{
+				q: []any{
+					"query @cached(ttl: 120) { hello }",
+					map[string]interface{}{"name": "John"},
+				},
+			},
+			want: &Query{
+				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query @cached(ttl: 120) { hello }"}`),
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -134,6 +158,20 @@ func TestBaseClient_decodeResponse(t *testing.T) {
 			},
 			want: []byte(`{"data":{"hello":"world"}}`),
 		},
+		{
+			name: "Test decodeResponse - mapstring",
+			fields: fields{
+				responseType: "mapstring",
+			},
+			args: args{
+				jsonData: []byte(`{"data":{"hello":"world"}}`),
+			},
+			want: map[string]interface{}{
+				"data": map[string]interface{}{
+					"hello": "world",
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -298,10 +336,10 @@ func TestBaseClient_parseQueryHeaders(t *testing.T) {
 		queryHeaders map[string]interface{}
 	}
 	tests := []struct {
-		name              string
 		fields            fields
 		args              args
 		wantReturnHeaders map[string]interface{}
+		name              string
 	}{
 		{
 			name:   "Test parseQueryHeaders - no change",
@@ -333,8 +371,8 @@ func TestBaseClient_parseQueryHeaders(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := NewConnection()
+			q := &Query{}
-			if gotReturnHeaders, _, _ := c.parseQueryHeaders(tt.args.queryHeaders); !reflect.DeepEqual(gotReturnHeaders, tt.wantReturnHeaders) {
+			if gotReturnHeaders, _, _, _ := q.parseQueryHeaders(tt.args.queryHeaders); !reflect.DeepEqual(gotReturnHeaders, tt.wantReturnHeaders) {
 				t.Errorf("BaseClient.parseQueryHeaders() = %v, want %v", gotReturnHeaders, tt.wantReturnHeaders)
 			}
 		})
@@ -517,8 +555,8 @@ func TestBaseClient_QueryCacheRandomizedRaceViaHeader(t *testing.T) {
 			}
 
 			for i := 0; i < 10; i++ {
-				tt.args.queryHeaders["gqlcache"] = rand.Intn(2) == 0
 				go func() {
+					tt.args.queryHeaders["gqlcache"] = rand.Intn(2) == 0
 					_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
 					if !tt.wantErr {
 						assert.NoError(t, err)

request.go

@@ -3,7 +3,7 @@ package gql
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"time"
 
@@ -22,6 +22,11 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 		httpRequest.Header.Add(key, fmt.Sprintf("%s", value))
 	}
 
+	var retries_available = c.retries.max
+	if !c.retries.enabled {
+		retries_available = 1
+	}
+
 	var httpResponse *http.Response
 
 	err = retry.Do(
@@ -31,13 +36,14 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 				c.Logger.Error(c, "Error while executing http request;", "error", err.Error())
 				return err
 			}
+			defer io.Copy(io.Discard, httpResponse.Body) // equivalent to `cp body /dev/null`
 			defer httpResponse.Body.Close()
 
 			if httpResponse.StatusCode <= 200 && httpResponse.StatusCode >= 204 {
 				return err
 			}
 
-			body, err := ioutil.ReadAll(httpResponse.Body)
+			body, err := io.ReadAll(httpResponse.Body)
 			if err != nil {
 				c.Logger.Error(c, "Error while reading http response;", "error", err.Error())
 				return err
@@ -54,7 +60,7 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 		retry.OnRetry(func(n uint, err error) {
 			c.Logger.Error(c, "Retrying query", "error", err.Error())
 		}),
-		retry.Attempts(uint(c.retries.max)),
+		retry.Attempts(uint(retries_available)),
 		retry.DelayType(retry.BackOffDelay),
 		retry.Delay(time.Duration(c.retries.delay)*time.Second),
 		retry.LastErrorOnly(true),
@@ -65,3 +71,45 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 	}
 	return queryResult.Data, nil
 }
+
+func (q *queryExecutor) execute() {
+	if q.should_cache {
+		cachedResponse := q.client.cacheLookup(q.hash)
+		if cachedResponse != nil {
+			q.client.Logger.Debug(q.client, "Found cached response")
+			q.result.data = q.client.decodeResponse(cachedResponse)
+			return // return cached response
+		} else {
+			q.client.Logger.Debug(q.client, "No cached response found")
+		}
+	}
+
+	if q.retries_enabled {
+		q.client.Logger.Debug(q.client, "Retries enabled")
+		q.client.retries.enabled = true
+	}
+
+	response, err := q.client.executeQuery(q.query, q.headers)
+	if err != nil {
+		q.client.Logger.Error(q.client, "Error while executing query;", "error", err.Error())
+		q.result.errors = err
+		return
+	}
+
+	jsonData, err := json.Marshal(response)
+	if err != nil {
+		q.client.Logger.Error(q.client, "Error while converting to json;", "error", err.Error())
+		q.result.errors = err
+		return
+	}
+
+	if q.should_cache {
+		q.client.cache.client.Set(q.hash, jsonData, time.Duration(q.client.cache.ttl)*time.Second)
+	}
+
+	q.result.data = q.client.decodeResponse(jsonData)
+}
+
+func (q *queryExecutor) done() {
+	q = nil
+}

structs.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"net/http"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
-
+	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	"github.com/allegro/bigcache"
 )
 
 type cacheStore struct {
-	client  *bigcache.BigCache
+	client  *libpack_cache.Cache
 	ttl     int
 	enabled bool
 }
@@ -23,18 +21,17 @@ type retriesConfig struct {
 }
 
 type BaseClient struct {
-	Logger             Logger
+	Logger         Logger
-	LoggerWriter       Writer
+	LoggerWriter   Writer
-	client             *http.Client
+	client         *http.Client
-	concurrencyManager *concurrency.Pool
+	endpoint       string
-	endpoint           string
+	responseType   string
-	responseType       string
+	cache          cacheStore
-	cache              cacheStore
+	MaxGoRoutines  int
-	MaxGoRoutines      int
+	LoggingLevel   logger.LogLevel
-	LoggingLevel       logger.LogLevel
+	LoggerColorful bool
-	LoggerColorful     bool
+	validate       bool
-	validate           bool
+	retries        retriesConfig
-	retries            retriesConfig
 }
 
 type Query struct {
@@ -44,6 +41,22 @@ type Query struct {
 	compiledQuery []byte         `json:"compiledQuery"`
 }
 
+type queryExecutor struct {
+	result          queryExecutorResult
+	context         context.Context
+	client          *BaseClient
+	headers         map[string]interface{}
+	hash            string
+	query           []byte
+	should_cache    bool
+	retries_enabled bool
+}
+
+type queryExecutorResult struct {
+	data   interface{}
+	errors error
+}
+
 type request struct {
 	Variables any    `json:"variables"`
 	Query     string `json:"query"`

utils/concurrency/concurrency.go

@@ -1,30 +0,0 @@
-package concurrency
-
-type Pool struct {
-	queue chan struct{}
-	jobs  int
-}
-
-func NewPool(size int) *Pool {
-	if size < 0 {
-		size = 0
-	}
-	return &Pool{
-		jobs:  size,
-		queue: make(chan struct{}, size),
-	}
-}
-
-func (p *Pool) Enqueue(job func(params ...any), params ...any) {
-	if p.jobs == 0 {
-		go job(params...)
-		return
-	}
-	p.queue <- struct{}{}
-	go func() {
-		defer func() {
-			<-p.queue
-		}()
-		job(params...)
-	}()
-}

utils/concurrency/concurrency_test.go

@@ -1,74 +0,0 @@
-package concurrency
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewPool(t *testing.T) {
-	type args struct {
-		size int
-	}
-	tests := []struct {
-		want *Pool
-		name string
-		args args
-	}{
-		{
-			name: "TestNewPool",
-			args: args{
-				size: 0,
-			},
-			want: &Pool{
-				jobs:  0,
-				queue: make(chan struct{}, 0),
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := NewPool(tt.args.size)
-			assert.Equal(t, got.jobs, tt.want.jobs)
-			assert.Equal(t, cap(got.queue), cap(tt.want.queue))
-		})
-	}
-}
-
-func TestPool_Enqueue(t *testing.T) {
-	type fields struct {
-		queue chan struct{}
-		jobs  int
-	}
-	type args struct {
-		job    func(params ...any)
-		params []any
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		{
-			name: "TestPool_Enqueue",
-			fields: fields{
-				queue: make(chan struct{}, 0),
-				jobs:  0,
-			},
-			args: args{
-				job: func(params ...any) {
-					return
-				},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			p := &Pool{
-				queue: tt.fields.queue,
-				jobs:  tt.fields.jobs,
-			}
-			p.Enqueue(tt.args.job, tt.args.params...)
-		})
-	}
-}

utils/logger/logger.go

@@ -1,16 +1,10 @@
 package logger
 
 import (
+	"encoding/json"
 	"reflect"
-
-	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/ordered_map"
-
-	jsoniter "github.com/json-iterator/go"
 )
 
-var json = jsoniter.ConfigCompatibleWithStandardLibrary
-
 const (
 	reset      = "\033[0m"
 	redBold    = "\033[1;31m"
@@ -34,25 +28,25 @@ type Config struct {
 	LogLevel LogLevel
 }
 
-func Serialize(v any) (string, error) {
+func Serialize(v interface{}) ([]byte, error) {
-	marshal, err := json.Marshal(internalSerialize(v))
+	b, err := json.Marshal(internalSerialize(v))
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	return helpers.BytesToString(marshal), nil
+	return b, nil
 }
 
-func internalSerialize(v any) any {
+func internalSerialize(v interface{}) interface{} {
 	if v != nil {
 		switch reflect.TypeOf(v).Kind() {
 		case reflect.Struct:
-			r := ordered_map.New()
+			r := make(map[string]interface{})
 			name := reflect.TypeOf(v).Name()
 			if name != "" {
-				r.Set("_", reflect.TypeOf(v).String())
+				r["_"] = reflect.TypeOf(v).String()
 			}
 			for i := 0; i < reflect.ValueOf(v).NumField(); i++ {
-				r.Set(reflect.TypeOf(v).Field(i).Name, internalSerialize(reflect.ValueOf(v).Field(i).Interface()))
+				r[reflect.TypeOf(v).Field(i).Name] = internalSerialize(reflect.ValueOf(v).Field(i).Interface())
 			}
 			return r
 		case reflect.Ptr:
@@ -60,7 +54,7 @@ func internalSerialize(v any) any {
 				return internalSerialize(reflect.ValueOf(v).Elem().Interface())
 			}
 		case reflect.Slice:
-			var r []any
+			var r []interface{}
 			tmpSlice := reflect.ValueOf(v)
 			for i := 0; i < tmpSlice.Len(); i++ {
 				r = append(r, internalSerialize(tmpSlice.Index(i).Interface()))

utils/ordered_map/ordered_map.go

@@ -55,10 +55,67 @@ type customJsonEncoder struct {
 }
 
 func (e *customJsonEncoder) Encode(v interface{}) error {
-	data, err := json.Marshal(v)
+	if v == nil {
+		e.buf.WriteString("null")
+		return nil
+	}
+
+	switch val := v.(type) {
+	case *OrderedMap:
+		data, err := json.Marshal(val.values)
+		if err != nil {
+			return err
+		}
+		e.buf.Write(data)
+	default:
+		data, err := json.Marshal(val)
+		if err != nil {
+			return err
+		}
+		e.buf.Write(data)
+	}
+	return nil
+}
+
+func (o OrderedMap) Keys() []string {
+	return o.keys
+}
+
+func (o OrderedMap) Values() []interface{} {
+	var values []interface{}
+	for _, k := range o.keys {
+		values = append(values, o.values[k])
+	}
+	return values
+}
+
+func (o *OrderedMap) Delete(key string) {
+	delete(o.values, key)
+	for i, k := range o.keys {
+		if k == key {
+			o.keys = append(o.keys[:i], o.keys[i+1:]...)
+			break
+		}
+	}
+}
+
+func (o OrderedMap) Exists(key string) bool {
+	_, exists := o.values[key]
+	return exists
+}
+
+func (o *OrderedMap) UnmarshalJSON(data []byte) error {
+	var values map[string]interface{}
+	err := json.Unmarshal(data, &values)
 	if err != nil {
 		return err
 	}
-	e.buf.Write(data)
+
+	o.keys = []string{}
+	o.values = map[string]interface{}{}
+	for k, v := range values {
+		o.Set(k, v)
+	}
+
 	return nil
 }