Revert default output to string for backwards compatibility.

Brings neat and testable codebase with minimum allocations in mind.

.gitignore

@@ -1,3 +1,4 @@
 *.out
 *.test
-coverage.txt
+coverage.txt
+*.DS_Store

Makefile

@@ -11,11 +11,23 @@ help:  ## display this help
 
 .PHONY: test
 test: ## run tests on library
-	@go test $(ADDITIONAL_BUILD_FLAGS) -v -cover ./...
+	@LOG_LEVEL=debug go test $(ADDITIONAL_BUILD_FLAGS) -v -cover ./... -race
 
 .PHONY: test-packages
 test-packages: ## run tests on packages
 	@go test -v -cover ./pkg/...
 
 .PHONY: all
-all: test-packages test
+all: test-packages test
+
+.PHONY: update
+update: ## update dependencies
+	@go get -u -v ./...
+	@go mod tidy -v
+
+sonar:
+	sonar-scanner \
+  -Dsonar.projectKey=golang-simple-graphql \
+  -Dsonar.sources=. \
+  -Dsonar.host.url=http://localhost:9000 \
+  -Dsonar.login=555ba78b315faa07b3231a3be0f3cbb24ab33814

README.md

@@ -9,13 +9,15 @@ Ps. It's Hasura friendly.
   - [Features](#features)
   - [Usage example](#usage-example)
     - [Environment variables](#environment-variables)
+    - [Cache](#cache)
     - [Example reader code](#example-reader-code)
+    - [Tips](#tips)
   - [Working with results](#working-with-results)
 
 ## Reasoning
 
-I've tried to run few graphQL clients with hasura, all of them required conversion of the data into
-the appropriate structures, causing issues with non-existing types ( thanks to Hasura ), for example `bigint` which was difficult to export.
+I've tried to run a few GraphQL clients with Hasura, all of them required conversion of the data into
+the appropriate structures, causing issues with non-existing types ( thanks to Hasura ), for example, `bigint` which was difficult to export.
 Therefore, I present you the simple client to which you can copy & paste your graphQL query, variables and you are good to go.
 
 ## Features
@@ -23,13 +25,40 @@ Therefore, I present you the simple client to which you can copy & paste your gr
 * Executing GraphQL queries as they are, without types declaration
 * HTTP2 support!
 * Support for additional headers
+* Query cache
 
 ## Usage example
 
 ### Environment variables
 
 * `GRAPHQL_ENDPOINT` - Your GraphQL endpoint. Default: `http://127.0.0.1:9090/v1/graphql`
-* `LOG_LEVEL` - Logging level. Default: `info`
+* `GRAPHQL_CACHE_ENABLED` -  Should the query cache be enabled? Default: `false`
+* `GRAPHQL_CACHE_TTL` -  Cache TTL in seconds for SELECT type of queries. Default: `5`
+* `GRAPHQL_OUTPUT` - Output format. Default: `string`, available: `byte`, `string`, `mapstring`
+* `LOG_LEVEL` - Logging level. Default: `info` available: `debug`, `info`, `warn`, `error`
+* `GRAPHQL_RETRIES_ENABLE` - Should retries be enabled? Default: `true`
+* `GRAPHQL_RETRIES_NUMBER` - Number of retries: Default: `1`
+* `GRAPHQL_RETRIES_DELAY` - Delay in retries in milliseconds. Default: `250`
+
+### Cache
+
+You have two options to enable the cache:
+
+* Use `GRAPHQL_CACHE_ENABLED` environment variable which will enable the cache globally. It may be desired if you want to use the cache for all queries.
+* Add `gqlcache: true` header for your query which will enable the cache for this query only with `GRAPHQL_CACHE_TTL` TTL.
+* You can check the list of supported per-query modifiers below
+
+Example:
+
+```go
+// following values passed as headers will modify behaviour of the query
+// and disregard settings provided via environment variables
+headers := map[string]interface{}{
+  ...
+  "gqlcache": true, // sets the cache as on for this query only
+  "gqlretries": false, // disables retries for this query only
+}
+```
 
 ### Example reader code
 
@@ -37,35 +66,42 @@ Therefore, I present you the simple client to which you can copy & paste your gr
 ```go
 import (
   fmt
-  gql "github.com/lukaszraczylo/simple-gql-client"
+  graphql "github.com/lukaszraczylo/go-simple-graphql"
 )
 
-headers := map[string]interface{}{
-  "x-hasura-user-id":   37,
-  "x-hasura-user-uuid": "bde3262e-b42e-4151-ac10-d43f0bef44a5",
-}
-
-variables := map[string]interface{}{
-"fileHash": "123deadc0w321",
-}
-var query = `query searchFileKnown($fileHash: String) {
-  tbl_file_scans(where: {file_hash: {_eq: $fileHash}}) {
-  	porn
-  	racy
-  	violence
-  	virus
+func main() {
+  headers := map[string]interface{}{
+    "x-hasura-user-id":   37,
+    "x-hasura-user-uuid": "bde1962e-b42e-1212-ac10-d43fa27f44a5",
   }
-}
 
-graphql := NewConnection()
-result, err := graphql.Query(query, variables, nil)
-if err != nil {
-  fmt.Println("Query error", err)
-  return
+  variables := map[string]interface{}{
+    "fileHash": "123deadc0w321",
+  }
+
+  query := `query searchFileKnown($fileHash: String) {
+    tbl_file_scans(where: {file_hash: {_eq: $fileHash}}) {
+    	racy
+    	violence
+    	virus
+    }
+  }`
+
+  gql := graphql.NewConnection()
+  result, err := gql.Query(query, variables, headers)
+  if err != nil {
+    fmt.Println("Query error", err)
+    return
+  }
+  fmt.Println(result)
 }
-fmt.Println(result)
 ```
 
+### Tips
+
+* Connection handler ( `gql := graphql.NewConnection()` ) should be created once and reused in the application especially if you run dozens of queries per second. It will allow you also to use cache and http2 to its full potential.
+
+
 **Result**
 
 ```json
@@ -74,10 +110,12 @@ fmt.Println(result)
 
 ## Working with results
 
-I'm using an amazing library [tidwall/gjson](https://github.com/tidwall/gjson) to parse the results and extract information required in further steps and I strongly recommend this approach as the easiest and close to painless.
+Currently attempting to switch to the fork of the [`ask` library](https://github.com/lukaszraczylo/ask)
+
+Before, I used an amazing library [tidwall/gjson](https://github.com/tidwall/gjson) to parse the results and extract the information required in further steps and I strongly recommend this approach as the easiest and close to painless, for example:
 
 ```go
-result = gjson.Get(result, "tbl_user_group_admins.0.is_admin").Bool()
+result := gjson.Get(result, "tbl_user_group_admins.0.is_admin").Bool()
 if result {
   fmt.Println("User is an admin")
 }

base.go

@@ -0,0 +1,104 @@
+package gql
+
+import (
+	"crypto/tls"
+	"time"
+
+	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+
+	"golang.org/x/net/http2"
+
+	"log"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/allegro/bigcache"
+	"github.com/gookit/goutil/envutil"
+)
+
+func NewConnection() *BaseClient {
+
+	b := &BaseClient{
+		client:             &http.Client{},
+		concurrencyManager: concurrency.NewPool(-1),
+		MaxGoRoutines:      -1,
+		LoggingLevel:       logger.Warn,
+		LoggerColorful:     true,
+	}
+
+	if b.LoggerWriter == nil {
+		b.LoggerWriter = log.New(os.Stdout, "", log.LstdFlags)
+	}
+
+	b.endpoint = envutil.Getenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql")
+	b.responseType = envutil.Getenv("GRAPHQL_OUTPUT", "string")
+	b.validate = envutil.GetBool("GRAPHQL_VALIDATE", false)
+	b.cache.enabled = envutil.GetBool("GRAPHQL_CACHE_ENABLED", true)
+	b.cache.ttl = envutil.GetInt("GRAPHQL_CACHE_TTL", 60)
+
+	b.retries.enabled = envutil.GetBool("GRAPHQL_RETRIES_ENABLED", true)
+	b.retries.max = envutil.GetInt("GRAPHQL_RETRIES_MAX", 1)
+	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_tmp_log_level := envutil.Getenv("LOG_LEVEL", "info")
+
+	switch b_tmp_log_level {
+	case "silent":
+		b.LoggingLevel = logger.Silent
+	case "error":
+		b.LoggingLevel = logger.Error
+	case "warn":
+		b.LoggingLevel = logger.Warn
+	case "info":
+		b.LoggingLevel = logger.Info
+	case "debug":
+		b.LoggingLevel = logger.Debug
+	}
+
+	b.Logger = NewLogger(b.LoggerWriter, logger.Config{
+		Colorful: b.LoggerColorful,
+		LogLevel: b.LoggingLevel,
+	})
+
+	var httpClient *http.Client
+	if strings.HasPrefix(b.endpoint, "http://") {
+		httpClient = &http.Client{
+			Transport: http.DefaultTransport,
+		}
+	} else {
+		tlsClientConfig := &tls.Config{}
+		if strings.HasPrefix(b.endpoint, "https://") {
+			tlsClientConfig.InsecureSkipVerify = true
+		}
+		http2Transport := &http2.Transport{
+			AllowHTTP:       true,
+			TLSClientConfig: tlsClientConfig,
+		}
+		httpClient = &http.Client{
+			Transport: http2Transport,
+		}
+	}
+	b.client = httpClient
+
+	b.Logger.Debug(b, "graphQL client initialized;", "endpoint", b.endpoint, "responseType", b.responseType, "validate", b.validate, "cache", b.cache.enabled, "cacheTTL", b.cache.ttl, "maxGoRoutines", b.MaxGoRoutines, "loggingLevel", b_tmp_log_level, "loggerColorful", b.LoggerColorful)
+	b.Logger.Info(b, "graphQL client initialized;")
+	return b
+}
+
+func (b *BaseClient) SetEndpoint(endpoint string) {
+	b.endpoint = endpoint
+}
+
+func (b *BaseClient) SetOutput(output string) {
+	b.responseType = output
+}

base_test.go

@@ -0,0 +1,131 @@
+package gql
+
+import (
+	"os"
+	"testing"
+
+	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewConnection(t *testing.T) {
+	tests := []struct {
+		want *BaseClient
+		name string
+	}{
+		{
+			name: "Test NewConnection",
+			want: &BaseClient{
+				endpoint:     "https://api.github.com/graphql",
+				responseType: "string",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// temporarily set GRAPHQL_ENDPOINT env variable to https://api.github.com/graphql
+			// 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")
+
+			got := NewConnection()
+			assert.Equal(t, tt.want.endpoint, got.endpoint)
+			assert.Equal(t, tt.want.responseType, got.responseType)
+		})
+	}
+}
+
+func TestNewConnectionLogLevels(t *testing.T) {
+	tests := []struct {
+		want *BaseClient
+		name string
+		env  string
+	}{
+		{
+			name: "Test NewConnection with log level set to debug",
+			env:  "debug",
+			want: &BaseClient{
+				endpoint:     "https://api.github.com/graphql",
+				responseType: "string",
+				LoggingLevel: logger.Debug,
+			},
+		},
+
+		{
+			name: "Test NewConnection with log level set to info",
+			env:  "info",
+			want: &BaseClient{
+				endpoint:     "https://api.github.com/graphql",
+				responseType: "string",
+				LoggingLevel: logger.Info,
+			},
+		},
+
+		{
+			name: "Test NewConnection with log level set to warn",
+			env:  "warn",
+			want: &BaseClient{
+				endpoint:     "https://api.github.com/graphql",
+				responseType: "string",
+				LoggingLevel: logger.Warn,
+			},
+		},
+
+		{
+			name: "Test NewConnection with log level set to error",
+			env:  "error",
+			want: &BaseClient{
+				endpoint:     "https://api.github.com/graphql",
+				responseType: "string",
+				LoggingLevel: logger.Error,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// temporarily set GRAPHQL_ENDPOINT env variable to https://api.github.com/graphql
+			// 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")
+			current_log_level := os.Getenv("LOG_LEVEL")
+			defer os.Setenv("LOG_LEVEL", current_log_level)
+			os.Setenv("LOG_LEVEL", tt.env)
+
+			got := NewConnection()
+			assert.Equal(t, tt.want.endpoint, got.endpoint)
+			assert.Equal(t, tt.want.responseType, got.responseType)
+			assert.Equal(t, tt.want.LoggingLevel, got.LoggingLevel)
+		})
+	}
+}
+
+func TestBaseClient_SetEndpoint(t *testing.T) {
+	type fields struct {
+	}
+	type args struct {
+		endpoint string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   string
+	}{
+		{
+			name: "Test SetEndpoint",
+			args: args{
+				endpoint: "https://potato/graphql",
+			},
+			want: "https://potato/graphql",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := NewConnection()
+			b.SetEndpoint(tt.args.endpoint)
+			assert.Equal(t, tt.want, b.endpoint)
+		})
+	}
+}

cache.go

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

go.mod

@@ -1,22 +1,29 @@
 module github.com/lukaszraczylo/go-simple-graphql
 
-go 1.17
+go 1.20
 
 require (
-	github.com/buger/jsonparser v1.1.1
+	github.com/allegro/bigcache v1.2.1
+	github.com/avast/retry-go/v4 v4.3.3
+	github.com/gookit/goutil v0.6.8
 	github.com/json-iterator/go v1.1.12
-	github.com/lukaszraczylo/pandati v0.0.10
-	github.com/rs/zerolog v1.25.0
-	github.com/stretchr/testify v1.7.0
-	golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6
+	github.com/stretchr/testify v1.8.2
+	golang.org/x/net v0.9.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/imdario/mergo v0.3.12 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
+	github.com/gookit/color v1.5.3 // indirect
+	github.com/kr/pretty v0.3.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
-	golang.org/x/text v0.3.6 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // 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.1.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/term v0.7.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,62 +1,61 @@
-github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
-github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
-github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/allegro/bigcache v1.2.1 h1:hg1sY1raCwic3Vnsvje6TT7/pnZba83LeFck5NrFKSc=
+github.com/allegro/bigcache v1.2.1/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+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/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
-github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
+github.com/gookit/color v1.5.3 h1:twfIhZs4QLCtimkP7MOxlF3A0U/5cDPseRT9M/+2SCE=
+github.com/gookit/color v1.5.3/go.mod h1:NUzwzeehUfl7GIb36pqId+UGmRfQcU/WiiyTTeNjHtE=
+github.com/gookit/goutil v0.6.8 h1:B2XXSCGav5TXWtKRT9i/s/owOLXXB7sY6UsfqeSLroE=
+github.com/gookit/goutil v0.6.8/go.mod h1:u+Isykc6RQcZ4GQzulsaGm+Famd97U5Tzp3aQyo+jyA=
 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/lukaszraczylo/pandati v0.0.10 h1:ZXmLjxb/UYRBVyAKwXmUcJgZ2FYNwGY4YDJsQQMYAXI=
-github.com/lukaszraczylo/pandati v0.0.10/go.mod h1:1lE/x4X4LfO1yerAQoiR7AVb/wIabH/zITDGnqTdyH8=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+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/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=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.25.0 h1:Rj7XygbUHKUlDPcVdoLyR91fJBsduXj5fRxyqIQj/II=
-github.com/rs/zerolog v1.25.0/go.mod h1:7KHcEGe0QZPOm2IE4Kpb5rTh6n1h2hIgS5OOnu1rUaI=
+github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 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.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6 h1:Z04ewVs7JhXaYkmDhBERPi41gnltfQpMWDnTnQbaCqk=
-golang.org/x/net v0.0.0-20210929193557-e81a3d93ecf6/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+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-20221126150942-6ab00d035af9/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+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=

gql.go

@@ -1,64 +0,0 @@
-// Package go-simple-graphql is a wrapper for GraphQL queries execution.
-// It's sole purpose is to allow developer to execute queries without specific fields / types mapping
-// which can be really confusing and even impossible whilst dealing with Hasura custom generated types.
-//
-// Library supports advanced error reporting on unsuccessful queries.
-// Library also uses HTTP2 for communication with GraphQL API if it's supported by server
-
-// Environment variables:
-// GRAPHQL_ENDPOINT - GraphQL endpoint to use. Default: http://127.0.0.1:9090/v1/graphql
-// LOG_LEVEL - Log level to use. Default: INFO
-//	 					 Available log levels: DEBUG, INFO, WARN, ERROR, FATAL
-
-package gql
-
-import (
-	"crypto/tls"
-	"fmt"
-	"net"
-	"net/http"
-	"os"
-	"time"
-
-	jsoniter "github.com/json-iterator/go"
-	"github.com/lukaszraczylo/go-simple-graphql/pkg/logging"
-	"golang.org/x/net/http2"
-)
-
-var (
-	json = jsoniter.ConfigCompatibleWithStandardLibrary
-)
-
-type GraphQL struct {
-	Endpoint   string
-	HttpClient *http.Client
-	Log        *logging.LogConfig
-}
-
-func pickGraphqlEndpoint() (graphqlEndpoint string) {
-	value, present := os.LookupEnv("GRAPHQL_ENDPOINT")
-	if present && value != "" {
-		graphqlEndpoint = value
-	} else {
-		graphqlEndpoint = "http://127.0.0.1:9090/v1/graphql"
-		fmt.Println("Setting default endpoint", graphqlEndpoint)
-	}
-	return graphqlEndpoint
-}
-
-func NewConnection() *GraphQL {
-	return &GraphQL{
-		Endpoint: pickGraphqlEndpoint(),
-		HttpClient: &http.Client{
-			Transport: &http2.Transport{
-				DisableCompression: false,
-				AllowHTTP:          true,
-				PingTimeout:        5 * time.Second,
-				DialTLS: func(network, addr string, cfg *tls.Config) (net.Conn, error) {
-					return net.Dial(network, addr)
-				},
-			},
-		},
-		Log: logging.NewLogger(),
-	}
-}

gql_test.go

@@ -1,66 +0,0 @@
-package gql
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-func mockGraphQLServerResponses(responseQuery string) (*httptest.Server, string) {
-	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
-		rw.Write([]byte(responseQuery))
-	}))
-	serverURL := server.URL + "/v1/graphql"
-	return server, serverURL
-}
-
-type TestSuite struct {
-	suite.Suite
-}
-
-func (suite *TestSuite) SetupTest() {
-	os.Unsetenv("GRAPHQL_ENDPOINT")
-}
-
-func TestSuiteRun(t *testing.T) {
-	suite.Run(t, new(TestSuite))
-}
-
-func (suite *TestSuite) TestNewConnection() {
-	type args struct {
-		endpoint string
-	}
-	tests := []struct {
-		name string
-		args args
-		want *GraphQL
-	}{
-		{
-			name: "New connection: Env variable endpoint",
-			args: args{
-				endpoint: "http://localhost:8080/graphql",
-			},
-			want: &GraphQL{
-				Endpoint: "http://localhost:8080/graphql",
-			},
-		},
-		{
-			name: "New connection: No env variable endpoint",
-			args: args{},
-			want: &GraphQL{
-				Endpoint: "http://127.0.0.1:9090/v1/graphql",
-			},
-		},
-	}
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			os.Setenv("GRAPHQL_ENDPOINT", tt.args.endpoint)
-			got := NewConnection()
-			assert.Equal(t, tt.want.Endpoint, got.Endpoint)
-		})
-	}
-}

logger.go

@@ -0,0 +1,141 @@
+package gql
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+
+	"github.com/gookit/goutil/timex"
+)
+
+func NewLogger(writer Writer, config logger.Config) Logger {
+	colorfulPrint := "%s[%s]%s %%s %%s"
+	closeColor, debugColor, infoColor, warnColor, errorColor := "\033[0m", "\033[1;34m", "\033[1;32m", "\033[1;33m", "\033[1;31m"
+	if !config.Colorful {
+		closeColor, debugColor, infoColor, warnColor, errorColor = "", "", "", "", ""
+	}
+	debugStr := fmt.Sprintf(colorfulPrint, debugColor, "DEBUG", closeColor)
+	infoStr := fmt.Sprintf(colorfulPrint, infoColor, "INFO", closeColor)
+	warnStr := fmt.Sprintf(colorfulPrint, warnColor, "WARN", closeColor)
+	errStr := fmt.Sprintf(colorfulPrint, errorColor, "ERROR", closeColor)
+
+	return &logging{
+		Writer:   writer,
+		Config:   config,
+		infoStr:  infoStr,
+		warnStr:  warnStr,
+		errStr:   errStr,
+		debugStr: debugStr,
+	}
+}
+
+func setDate() string {
+	tx := time.Now()
+	return timex.DateFormat(tx, "Y-m-d H:I:S")
+}
+
+func (l logging) Debug(client *BaseClient, msg string, data ...any) {
+	if l.LogLevel >= logger.Debug {
+		t := setDate()
+		msg, data = censorSensitiveInfo(client, msg, data...)
+		if client != nil {
+			l.Printf(l.debugStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
+		} else {
+			l.Printf(l.debugStr, msg, sprint(data...))
+		}
+	}
+}
+
+func (l logging) Info(client *BaseClient, msg string, data ...any) {
+	if l.LogLevel >= logger.Info {
+		t := setDate()
+		msg, data = censorSensitiveInfo(client, msg, data...)
+		if client != nil {
+			l.Printf(l.infoStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
+		} else {
+			l.Printf(l.infoStr, msg, sprint(data...))
+		}
+	}
+}
+
+func (l logging) Warn(client *BaseClient, msg string, data ...any) {
+	if l.LogLevel >= logger.Warn {
+		t := setDate()
+		msg, data = censorSensitiveInfo(client, msg, data...)
+		if client != nil {
+			l.Printf(l.warnStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
+		} else {
+			l.Printf(l.warnStr, msg, sprint(data...))
+		}
+	}
+}
+
+func (l logging) Error(client *BaseClient, msg string, data ...any) {
+	if l.LogLevel >= logger.Error {
+		t := setDate()
+		msg, data = censorSensitiveInfo(client, msg, data...)
+		if client != nil {
+			l.Printf(l.errStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
+		} else {
+			l.Printf(l.errStr, msg, sprint(data...))
+		}
+	}
+}
+
+type Logger interface {
+	Debug(*BaseClient, string, ...any)
+	Info(*BaseClient, string, ...any)
+	Warn(*BaseClient, string, ...any)
+	Error(*BaseClient, string, ...any)
+}
+
+type Writer interface {
+	Printf(string, ...any)
+}
+
+type logging struct {
+	Writer
+	debugStr string
+	infoStr  string
+	warnStr  string
+	errStr   string
+	logger.Config
+}
+
+func censorSensitiveInfo(client *BaseClient, a string, b ...any) (string, []any) {
+	// if client == nil || client.Token == "" {
+	// 	return a, b
+	// }
+	// tokenFixed := strings.Split(client.Token, ":")[1]
+	// for t := range b {
+	// 	if b[t] != nil {
+	// 		rV := reflect.TypeOf(b[t]).Kind()
+	// 		if rV == reflect.String {
+	// 			b[t] = strings.ReplaceAll(b[t].(string), tokenFixed, strings.Repeat("X", len(tokenFixed)))
+	// 		}
+	// 	}
+	// }
+	// a = strings.ReplaceAll(a, tokenFixed, strings.Repeat("X", len(tokenFixed)))
+	// return a, b
+	return a, b
+}
+
+func sprint(a ...any) string {
+	for t := range a {
+		if a[t] != nil {
+			rV := reflect.TypeOf(a[t]).Kind()
+			if rV == reflect.Ptr {
+				a[t] = reflect.ValueOf(a[t]).Elem().Interface()
+			}
+			rV = reflect.TypeOf(a[t]).Kind()
+			if rV == reflect.Struct || rV == reflect.Map || rV == reflect.Slice {
+				a[t], _ = logger.Serialize(a[t])
+			}
+		}
+	}
+	r := fmt.Sprintln(a...)
+	r = r[:len(r)-1]
+	return r
+}

pkg/logging/logging.go

@@ -1,77 +0,0 @@
-package logging
-
-import (
-	"fmt"
-	stdlog "log"
-	"os"
-	"time"
-
-	"github.com/lukaszraczylo/pandati"
-	"github.com/rs/zerolog"
-)
-
-type LogConfig struct {
-	DefaultOutput *os.File
-	Logger        zerolog.Logger
-}
-
-func NewLogger() *LogConfig {
-	log := new(LogConfig)
-	switch dll := os.Getenv("LOG_LEVEL"); dll {
-	case "debug":
-		zerolog.SetGlobalLevel(zerolog.DebugLevel)
-	case "warn":
-		zerolog.SetGlobalLevel(zerolog.WarnLevel)
-	case "error":
-		zerolog.SetGlobalLevel(zerolog.ErrorLevel)
-	default:
-		zerolog.SetGlobalLevel(zerolog.InfoLevel)
-	}
-	zerolog.TimeFieldFormat = time.RFC3339
-	zerolog.MessageFieldName = "short_message"
-	zerolog.TimestampFieldName = "timestamp"
-	zerolog.LevelFatalValue = "critical"
-	log.Logger = log.Logger.With().Timestamp().Logger()
-	stdlog.SetFlags(0)
-	stdlog.SetOutput(log.Logger)
-	return log
-}
-
-func (l *LogConfig) Critical(message string, v ...map[string]interface{}) {
-	w := l.Logger.Output(os.Stderr)
-	log(w.Fatal(), message, v...)
-}
-
-func (l *LogConfig) Error(message string, v ...map[string]interface{}) {
-	w := l.Logger.Output(os.Stderr)
-	log(w.Error(), message, v...)
-}
-
-func (l *LogConfig) Warning(message string, v ...map[string]interface{}) {
-	w := l.Logger.Output(os.Stdout)
-	log(w.Warn(), message, v...)
-}
-
-func (l *LogConfig) Info(message string, v ...map[string]interface{}) {
-	w := l.Logger.Output(os.Stdout)
-	log(w.Info(), message, v...)
-}
-
-func (l *LogConfig) Debug(message string, v ...map[string]interface{}) {
-	w := l.Logger.Output(os.Stdout)
-	log(w.Debug(), message, v...)
-}
-
-func log(contextLog *zerolog.Event, message string, v ...map[string]interface{}) {
-	if len(v) > 0 {
-		for _, m := range v {
-			for k, v := range m {
-				if !pandati.IsZero(v) && !pandati.IsZero(k) {
-					contextLog.Str(k, fmt.Sprintf("%v", v))
-				}
-			}
-		}
-	}
-	// contextLog.Str("_stack_trace", pandati.Trace())
-	contextLog.Msg(message)
-}

pkg/logging/logging_test.go

@@ -1,373 +0,0 @@
-package logging
-
-import (
-	"errors"
-	"io/ioutil"
-	"os"
-	"reflect"
-	"testing"
-
-	"github.com/buger/jsonparser"
-	"github.com/stretchr/testify/suite"
-)
-
-type LoggingTestSuite struct {
-	suite.Suite
-}
-
-var (
-	testsLogger *LogConfig
-)
-
-type stdoutCapture struct {
-	oldStdout *os.File
-	readPipe  *os.File
-}
-
-func (sc *stdoutCapture) StartCapture() {
-	sc.oldStdout = os.Stdout
-	sc.readPipe, os.Stdout, _ = os.Pipe()
-}
-
-func (sc *stdoutCapture) StopCapture() (string, error) {
-	if sc.oldStdout == nil || sc.readPipe == nil {
-		return "", errors.New("StartCapture not called before StopCapture on Stdout")
-	}
-	os.Stdout.Close()
-	os.Stdout = sc.oldStdout
-	bytes, err := ioutil.ReadAll(sc.readPipe)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-type stderrCapture struct {
-	oldStderr *os.File
-	readPipe  *os.File
-}
-
-func (sc *stderrCapture) StartCapture() {
-	sc.oldStderr = os.Stderr
-	sc.readPipe, os.Stderr, _ = os.Pipe()
-}
-
-func (sc *stderrCapture) StopCapture() (string, error) {
-	if sc.oldStderr == nil || sc.readPipe == nil {
-		return "", errors.New("StartCapture not called before StopCapture on Stderr")
-	}
-	os.Stderr.Close()
-	os.Stderr = sc.oldStderr
-	bytes, err := ioutil.ReadAll(sc.readPipe)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-func (suite *LoggingTestSuite) SetupTest() {
-}
-
-func TestLoggingTestSuite(t *testing.T) {
-	suite.Run(t, new(LoggingTestSuite))
-}
-
-func (suite *LoggingTestSuite) TestLogConfig_AllHandlers() {
-	type args struct {
-		message string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		wantLevel      string
-		wantMessage    string
-		envMinLogLevel string
-		stdOutExpect   bool
-		stdErrExpect   bool
-		loggerType     string
-	}{
-		{
-			name:       "Test log: Error",
-			loggerType: "Error",
-			args: args{
-				message: "This is a error message",
-			},
-			wantLevel:    "error",
-			wantMessage:  "This is a error message",
-			stdErrExpect: true,
-			stdOutExpect: false,
-		},
-		{
-			name:       "Test log: Warning",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "info",
-		},
-		{
-			name:       "Test log: Warning | Min level: Debug",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "debug",
-		},
-		{
-			name:       "Test log: Info",
-			loggerType: "Info",
-			args: args{
-				message: "This is a info message",
-			},
-			wantLevel:    "info",
-			wantMessage:  "This is a info message",
-			stdErrExpect: false,
-			stdOutExpect: true,
-		},
-		{
-			name:       "Test log: Info | Min level: Warn",
-			loggerType: "Info",
-			args: args{
-				message: "This is a info message",
-			},
-			wantLevel:      "",
-			wantMessage:    "",
-			stdErrExpect:   false,
-			stdOutExpect:   false,
-			envMinLogLevel: "warn",
-		},
-		{
-			name:       "Test log: Warning | Min level: Warn",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "warn",
-		},
-		{
-			name:       "Test log: Warning | Min level: Error",
-			loggerType: "Warning",
-			args: args{
-				message: "This is an error message",
-			},
-			wantLevel:      "",
-			wantMessage:    "",
-			stdErrExpect:   false,
-			stdOutExpect:   false,
-			envMinLogLevel: "error",
-		},
-		{
-			name:       "Test log: Debug | Min level: Debug",
-			loggerType: "Debug",
-			args: args{
-				message: "This is a debug message",
-			},
-			wantLevel:      "debug",
-			wantMessage:    "This is a debug message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "debug",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			if tt.envMinLogLevel != "" {
-				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
-				defer os.Unsetenv("LOG_LEVEL")
-			}
-			testsLogger = NewLogger()
-
-			captureStdout := stdoutCapture{}
-			captureStdout.StartCapture()
-			captureStderr := stderrCapture{}
-			captureStderr.StartCapture()
-
-			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{reflect.ValueOf(tt.args.message)})
-
-			stdoutOut, err := captureStdout.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			stderrOut, err := captureStderr.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			if tt.stdErrExpect && !tt.stdOutExpect {
-				gotLvl, gotMsg, err := getResponseValues(stderrOut, "short_message")
-				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
-				suite.Equal("", stdoutOut, "Failed in [STDERR]: "+tt.name)
-			}
-			if tt.stdOutExpect && !tt.stdErrExpect {
-				gotLvl, gotMsg, err := getResponseValues(stdoutOut, "short_message")
-				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal("", stderrOut, "Failed in [STDOUT]: "+tt.name)
-			}
-			if !tt.stdErrExpect && !tt.stdOutExpect {
-				suite.Equal("", stderrOut, "Failed in [NEITHER]: "+tt.name)
-				suite.Equal("", stdoutOut, "Failed in [NEITHER]: "+tt.name)
-			}
-			os.Unsetenv("LOG_LEVEL")
-		})
-	}
-}
-
-func (suite *LoggingTestSuite) TestFullMessage() {
-	type args struct {
-		message     string
-		extraFields map[string]interface{}
-	}
-	extraFields := make(map[string]interface{})
-	extraFields["_full_message"] = "full message"
-
-	tests := []struct {
-		name           string
-		args           args
-		wantLevel      string
-		wantMessage    string
-		envMinLogLevel string
-		stdOutExpect   bool
-		stdErrExpect   bool
-		loggerType     string
-	}{
-		{
-			name:       "Test log: Error",
-			loggerType: "Error",
-			args: args{
-				message:     "This is a error message",
-				extraFields: extraFields,
-			},
-			wantLevel:    "error",
-			wantMessage:  extraFields["_full_message"].(string),
-			stdErrExpect: true,
-			stdOutExpect: false,
-		},
-		{
-			name:       "Test log: Info",
-			loggerType: "Info",
-			args: args{
-				message:     "This is a info message",
-				extraFields: extraFields,
-			},
-			wantMessage:  extraFields["_full_message"].(string),
-			stdErrExpect: false,
-			stdOutExpect: true,
-		},
-	}
-
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			if tt.envMinLogLevel != "" {
-				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
-				defer os.Unsetenv("LOG_LEVEL")
-			}
-			testsLogger = NewLogger()
-
-			captureStdout := stdoutCapture{}
-			captureStdout.StartCapture()
-			captureStderr := stderrCapture{}
-			captureStderr.StartCapture()
-
-			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{
-				reflect.ValueOf(tt.args.message),
-				reflect.ValueOf(tt.args.extraFields),
-			})
-
-			stdoutOut, err := captureStdout.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			stderrOut, err := captureStderr.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			if tt.stdErrExpect && !tt.stdOutExpect {
-				_, gotMsg, err := getResponseValues(stderrOut, "_full_message")
-				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
-			}
-			if tt.stdOutExpect && !tt.stdErrExpect {
-				_, gotMsg, err := getResponseValues(stdoutOut, "_full_message")
-				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
-			}
-			os.Unsetenv("LOG_LEVEL")
-		})
-	}
-}
-
-func Test_getResponseValues(t *testing.T) {
-	type args struct {
-		sourceJson string
-	}
-	tests := []struct {
-		name       string
-		args       args
-		wantGotLvl string
-		wantGotMsg string
-		wantErr    bool
-	}{
-		{
-			name: "Test with json",
-			args: args{
-				sourceJson: `{"level": "debug", "short_message": "hello world"`,
-			},
-			wantGotLvl: "debug",
-			wantGotMsg: "hello world",
-			wantErr:    false,
-		},
-		{
-			name: "Test with json, wrong message field",
-			args: args{
-				sourceJson: `{"level": "debug", "message": "hello world"`,
-			},
-			wantGotLvl: "debug",
-			wantGotMsg: "",
-			wantErr:    true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotGotLvl, gotGotMsg, err := getResponseValues(tt.args.sourceJson, "short_message")
-			if (err != nil) != tt.wantErr {
-				t.Errorf("getResponseValues() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if gotGotLvl != tt.wantGotLvl {
-				t.Errorf("getResponseValues() gotGotLvl = %v, want %v", gotGotLvl, tt.wantGotLvl)
-			}
-			if gotGotMsg != tt.wantGotMsg {
-				t.Errorf("getResponseValues() gotGotMsg = %v, want %v", gotGotMsg, tt.wantGotMsg)
-			}
-		})
-	}
-}
-
-func getResponseValues(sourceJson string, key string) (gotLvl, gotMsg string, err error) {
-	gotLvl, err = jsonparser.GetString([]byte(sourceJson), "level")
-	if err != nil {
-		return
-	}
-	gotMsg, err = jsonparser.GetString([]byte(sourceJson), key)
-	return
-}

query.go

@@ -1,95 +1,155 @@
 package gql
 
 import (
-	"bytes"
-	"errors"
+	"context"
 	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
+	"reflect"
+	"strconv"
 
-	"github.com/lukaszraczylo/pandati"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
+
+	"github.com/gookit/goutil/strutil"
+
+	jsoniter "github.com/json-iterator/go"
 )
 
-type requestBase struct {
-	Query     string      `json:"query"`
-	Variables interface{} `json:"variables"`
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+
+func (c *BaseClient) convertToJson(v any) []byte {
+	json, err := json.Marshal(v)
+	if err != nil {
+		c.Logger.Error(c, "Can't convert to json;", "error", err.Error())
+		return nil
+	}
+	return json
 }
 
-type queryResults struct {
-	Data   interface{} `json:"data"`
-	Errors []struct {
-		Message interface{} `json:"message"`
-	} `json:"errors"`
+func (c *BaseClient) NewQuery(q ...any) *Query {
+	query := &Query{}
+
+	if len(q) > 0 {
+		for _, v := range q {
+			switch val := v.(type) {
+			case string:
+				query.query = val
+			case map[string]interface{}:
+				query.variables = val
+			case context.Context:
+				query.context = val
+			}
+		}
+	}
+
+	query.compiledQuery = c.convertToJson(request{
+		Query:     query.query,
+		Variables: query.variables,
+	})
+
+	c.Logger.Debug(c, "Clearing previously prepared variables and query")
+	query.variables = nil
+
+	if query.context == nil {
+		query.context = context.Background()
+	}
+
+	if c.validate {
+		c.Logger.Warn(c, "Validating query is not active")
+	}
+
+	query.query = ""
+	c.Logger.Debug(c, "Query prepared;", "query", helpers.BytesToString(query.compiledQuery))
+
+	return query
 }
 
-func (g *GraphQL) queryBuilder(queryContent string, queryVariables interface{}) ([]byte, error) {
-	var qb = &requestBase{
-		Query:     queryContent,
-		Variables: queryVariables,
+// Query is a function that sends a query to the server
+// It takes 3 arguments:
+// 1. queryContent: the query string
+// 2. queryVariables: the variables for the query
+// 3. queryHeaders: the headers for the 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
+
+	// Check for library specific headers
+	if len(queryHeaders) > 0 {
+		cacheBaseClient = reflect.ValueOf(*c).Interface().(BaseClient)
+		queryHeaders = c.parseQueryHeaders(queryHeaders)
 	}
 
-	// j := new(bytes.Buffer)
-	j2, err := json.Marshal(qb)
-	if err != nil {
-		g.Log.Critical("Unable to marshal the query", map[string]interface{}{"_error": err.Error(), "_query": queryContent, "_variables": queryVariables})
-		return []byte{}, err
+	if c.cache.enabled {
+		queryHash = strutil.Md5(query.compiledQuery)
+		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 err = json.Compact(j, j2); err != nil {
-	// 	g.Log.Critical("Unable to compact the query", map[string]interface{}{"error": err.Error()})
-	// 	return []byte{}, err
-	// }
-	return j2, err
+
+	response, err := c.executeQuery(query.compiledQuery, queryHeaders)
+	if err != nil {
+		c.Logger.Error(c, "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())
+		return nil, err
+	}
+
+	if c.cache.enabled {
+		c.cache.client.Set(queryHash, jsonData)
+	}
+
+	if len(queryHeaders) > 0 {
+		*c = cacheBaseClient
+	}
+
+	return c.decodeResponse(jsonData), err
 }
 
-func (g *GraphQL) Query(queryContent string, queryVariables interface{}, queryHeaders map[string]interface{}) (responseContent string, err error) {
-	g.Log.Debug("Query details", map[string]interface{}{"_query": queryContent, "_variables": queryVariables})
-	query, err := g.queryBuilder(queryContent, queryVariables)
-	if err != nil {
-		g.Log.Error("Unable to build the query", map[string]interface{}{"_error": err.Error()})
-		return "", err
+func (c *BaseClient) decodeResponse(jsonData []byte) any {
+	switch c.responseType {
+	case "mapstring":
+		var response map[string]interface{}
+		err := json.Unmarshal(jsonData, &response)
+		if err != nil {
+			c.Logger.Error(c, "Error while converting to map[string]interface{};", "error", err.Error())
+			return nil
+		}
+		return response
+	case "string":
+		return helpers.BytesToString(jsonData)
+	case "byte":
+		return jsonData
+	default:
+		c.Logger.Error(c, "Unknown response type", "response", c.responseType)
+		return nil
 	}
-	httpRequest, err := http.NewRequest("POST", g.Endpoint, bytes.NewBuffer(query))
-	httpRequest.Header.Add("Content-Type", "application/json")
-	for header, value := range queryHeaders {
-		httpRequest.Header.Add(fmt.Sprintf("%v", header), fmt.Sprintf("%v", value))
-	}
-
-	httpResponse, err := g.HttpClient.Do(httpRequest)
-	if err != nil {
-		g.Log.Error("Unable to send the query", map[string]interface{}{"_error": err.Error()})
-		return "", err
-	}
-	defer io.Copy(ioutil.Discard, httpResponse.Body)
-	defer httpResponse.Body.Close()
-
-	body, err := ioutil.ReadAll(httpResponse.Body)
-	if err != nil {
-		g.Log.Critical("Unable to read the response", map[string]interface{}{"_error": err.Error()})
-		return "", err
-	}
-	var queryResult *queryResults
-	err = json.Unmarshal(body, &queryResult)
-	if err != nil {
-		g.Log.Error("Unable to unmarshal the query", map[string]interface{}{"_error": err.Error()})
-		return "", err
-	}
+}
 
-	if !pandati.IsZero(queryResult.Errors) {
-		g.Log.Error("Query returned error", map[string]interface{}{"_query": queryContent, "_variables": queryVariables, "_error": fmt.Sprintf("%v", queryResult.Errors)})
-		return "", fmt.Errorf("%v", queryResult.Errors[0].Message)
+func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}) {
+	returnHeaders = make(map[string]interface{})
+	for k, v := range queryHeaders {
+		if k == "gqlcache" {
+			c.cache.enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			continue
+		}
+		if k == "gqlretries" {
+			c.retries.enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			continue
+		}
+		returnHeaders[k] = v
 	}
-
-	if pandati.IsZero(queryResult.Data) {
-		g.Log.Error("Query returned no data", map[string]interface{}{"_query": queryContent, "_variables": queryVariables})
-		return "", errors.New("Query returned no data")
-	}
-
-	responseContent, err = json.MarshalToString(queryResult.Data)
-	if err != nil {
-		g.Log.Error("Invalid data result", map[string]interface{}{"_query": queryContent, "_variables": queryVariables, "_result": responseContent})
-		return "", err
-	}
-
-	return
+	return returnHeaders
 }

query_bench_test.go

@@ -1,69 +0,0 @@
-package gql
-
-import (
-	"testing"
-)
-
-func Benchmark_GraphQL_Query(t *testing.B) {
-	if testing.Short() {
-		t.Skip("Skipping test in short / CI mode")
-	}
-	type args struct {
-		queryContent   string
-		queryVariables interface{}
-	}
-	tests := []struct {
-		name        string
-		endpoint    string
-		isLocal     bool
-		args        args
-		wantResult  string
-		mockedReply string
-		wantErr     bool
-	}{
-		{
-			name:     "Valid query",
-			endpoint: "http://hasura.local/v1/graphql",
-			isLocal:  false,
-			args: args{
-				queryContent: `query listUserBots {
-					tbl_bots(limit: 1) {
-						bot_name
-					}
-				}`,
-				queryVariables: nil,
-			},
-			wantResult:  `{"tbl_bots":[{"bot_name":"littleMentionBot"}]}`,
-			mockedReply: `{"data":{"tbl_bots":[{"bot_name":"littleMentionBot"}]}}`,
-			wantErr:     false,
-		},
-		{
-			name:     "Invalid query",
-			endpoint: "http://hasura.local/v1/graphql",
-			isLocal:  false,
-			args: args{
-				queryContent: `query listUserBots {
-					tbl_botz(limit: 1) {
-						bot_name
-					}
-				}`,
-				queryVariables: nil,
-			},
-			mockedReply: `{"errors":[{"message":"Unknown field \"tbl_botz\" on type \"Query\""}]}`,
-			wantResult:  ``,
-			wantErr:     true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.B) {
-			g := NewConnection()
-			server, serverURL := mockGraphQLServerResponses(tt.mockedReply)
-			g.Endpoint = serverURL
-			for n := 0; n < t.N; n++ {
-				g.Query(tt.args.queryContent, tt.args.queryVariables, nil)
-			}
-			server.Close()
-		})
-	}
-}

query_test.go

@@ -1,113 +1,341 @@
 package gql
 
 import (
-	"os"
+	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
-func (suite *TestSuite) Test_GraphQL_queryBuilder() {
-
+func TestBaseClient_convertToJson(t *testing.T) {
+	type fields struct {
+	}
 	type args struct {
-		queryContent   string
-		queryVariables interface{}
+		v any
 	}
 	tests := []struct {
-		name    string
+		name   string
+		fields fields
+		args   args
+		want   []byte
+	}{
+		{
+			name:   "Test convertToJson",
+			fields: fields{},
+			args: args{
+				v: map[string]interface{}{
+					"query": "query { hello }",
+				},
+			},
+			want: []byte(`{"query":"query { hello }"}`),
+		},
+		{
+			name:   "Test convertToJson with variables",
+			fields: fields{},
+			args: args{
+				v: map[string]interface{}{
+					"query":     "query { hello }",
+					"variables": map[string]interface{}{"name": "John"},
+				},
+			},
+			want: []byte(`{"query":"query { hello }","variables":{"name":"John"}}`),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &BaseClient{}
+			if got := c.convertToJson(tt.args.v); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("BaseClient.convertToJson() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBaseClient_NewQuery(t *testing.T) {
+	type fields struct {
+	}
+	type args struct {
+		q []any
+	}
+	tests := []struct {
+		fields fields
+		want   *Query
+		name   string
+		args   args
+	}{
+		{
+			name:   "Test NewQuery",
+			fields: fields{},
+			args: args{
+				q: []any{
+					"query { hello }",
+				},
+			},
+			want: &Query{
+				compiledQuery: []byte(`{"variables":null,"query":"query { hello }"}`),
+			},
+		},
+		{
+			name:   "Test NewQuery with variables",
+			fields: fields{},
+			args: args{
+				q: []any{
+					"query { hello }",
+					map[string]interface{}{"name": "John"},
+				},
+			},
+			want: &Query{
+				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query { hello }"}`),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			gotQuery := c.NewQuery(tt.args.q...)
+			assert.Equal(t, tt.want.query, gotQuery.query)
+			assert.Equal(t, tt.want.variables, gotQuery.variables)
+			assert.Equal(t, tt.want.compiledQuery, gotQuery.compiledQuery)
+		})
+	}
+}
+
+func TestBaseClient_decodeResponse(t *testing.T) {
+	type fields struct {
+		responseType string
+	}
+	type args struct {
+		jsonData []byte
+	}
+	tests := []struct {
+		fields fields
+		want   any
+		name   string
+		args   args
+	}{
+		{
+			name: "Test decodeResponse - string",
+			fields: fields{
+				responseType: "string",
+			},
+			args: args{
+				jsonData: []byte(`{"data":{"hello":"world"}}`),
+			},
+			want: `{"data":{"hello":"world"}}`,
+		},
+		{
+			name: "Test decodeResponse - byte",
+			fields: fields{
+				responseType: "byte",
+			},
+			args: args{
+				jsonData: []byte(`{"data":{"hello":"world"}}`),
+			},
+			want: []byte(`{"data":{"hello":"world"}}`),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			c.responseType = tt.fields.responseType
+			if got := c.decodeResponse(tt.args.jsonData); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("BaseClient.decodeResponse() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBaseClient_Query(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		repeat           int
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
 		args    args
-		want    []byte
+		name    string
+		fields  fields
 		wantErr bool
 	}{
 		{
-			name: "Valid query",
-			args: args{
-				queryContent:   `query listUserBots { tbl_bots { bot_name } }`,
-				queryVariables: nil,
+			name: "Test Query - failing",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
 			},
-			want:    []byte(`{"query":"query listUserBots { tbl_bots { bot_name } }","variables":null}`),
-			wantErr: false,
+			args: args{
+				queryContent: "query { hello }",
+			},
+			want:    ``,
+			wantErr: true,
 		},
 		{
-			name: "Valid query with variables",
+			name: "Test Query - success",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
 			args: args{
-				queryContent:   `query listUserBots { tbl_bots { bot_name } }`,
-				queryVariables: map[string]interface{}{"user_id": 1},
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
 			},
-			want:    []byte(`{"query":"query listUserBots { tbl_bots { bot_name } }","variables":{"user_id":1}}`),
 			wantErr: false,
+			want:    `{"dragons":[{"name":"Dragon 1"},{"name":"Dragon 2"}]}`,
+		},
+		{
+			name: "Test Query - success",
+			fields: fields{
+				repeat:           2,
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+						first_flight
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang-Cached",
+					"content-type":            "application/json",
+				},
+			},
+			wantErr: false,
+			want:    `{"dragons":[{"first_flight":"2010-12-08","name":"Dragon 1"},{"first_flight":"2019-03-02","name":"Dragon 2"}]}`,
 		},
 	}
 	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			q := NewConnection()
-			got, gotErr := q.queryBuilder(tt.args.queryContent, tt.args.queryVariables)
-			assert.Equal(t, tt.want, got)
-			if tt.wantErr {
-				assert.Error(t, gotErr)
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			repeat := 1
+			if tt.fields.repeat != 0 {
+				repeat = tt.fields.repeat
+			}
+
+			for i := 0; i < repeat; i++ {
+
+				got, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+
+				if err != nil && tt.wantErr {
+					assert.Error(t, err)
+				} else {
+					assert.NoError(t, err)
+					assert.Equal(t, tt.want, got)
+				}
 			}
 		})
 	}
 }
 
-func (suite *TestSuite) Test_GraphQL_Query() {
-	if testing.Short() {
-		suite.T().Skip("Skipping test in short / CI mode")
+/// benchmarks
+
+func BenchmarkBaseClient_convertToJson(b *testing.B) {
+	c := NewConnection()
+	query := c.NewQuery("query { hello }")
+	for i := 0; i < b.N; i++ {
+		_ = c.convertToJson(query)
+	}
+}
+
+func BenchmarkNewQuery(b *testing.B) {
+	c := NewConnection()
+	for i := 0; i < b.N; i++ {
+		_ = c.NewQuery("query { hello }")
+	}
+}
+
+func BenchmarkDecodeResponse(b *testing.B) {
+	c := NewConnection()
+	for i := 0; i < b.N; i++ {
+		_ = c.decodeResponse([]byte(`{"data":{"hello":"world"}}`))
+	}
+}
+
+func BenchmarkQueryNoCache(b *testing.B) {
+	c := NewConnection()
+	c.cache.enabled = false
+	for i := 0; i < b.N; i++ {
+		_, _ = c.Query(`query MyQuery {
+			bots {
+				bot_name
+			}
+		}`, nil, nil)
+	}
+}
+
+func BenchmarkQueryWithCache(b *testing.B) {
+	c := NewConnection()
+	c.cache.enabled = true
+	for i := 0; i < b.N; i++ {
+		_, _ = c.Query(`query MyQuery {
+			bots {
+				bot_name
+			}
+		}`, nil, nil)
+	}
+}
+
+func TestBaseClient_parseQueryHeaders(t *testing.T) {
+	type fields struct {
 	}
 	type args struct {
-		queryContent   string
-		queryVariables interface{}
+		queryHeaders map[string]interface{}
 	}
 	tests := []struct {
-		name       string
-		endpoint   string
-		isLocal    bool
-		args       args
-		wantResult string
-		wantErr    bool
+		name              string
+		fields            fields
+		args              args
+		wantReturnHeaders map[string]interface{}
 	}{
 		{
-			name:     "Valid query",
-			endpoint: "http://hasura.local/v1/graphql",
-			isLocal:  true,
+			name:   "Test parseQueryHeaders - no change",
+			fields: fields{},
 			args: args{
-				queryContent: `query listUserBots {
-					tbl_bots(limit: 1) {
-						bot_name
-					}
-				}`,
-				queryVariables: nil,
+				queryHeaders: map[string]interface{}{
+					"x-test-header":      "test",
+					"x-test-header-next": true,
+				},
+			},
+			wantReturnHeaders: map[string]interface{}{
+				"x-test-header":      "test",
+				"x-test-header-next": true,
 			},
-			wantResult: `{"tbl_bots":[{"bot_name":"littleMentionBot"}]}`,
-			wantErr:    false,
 		},
 		{
-			name:     "Invalid query",
-			endpoint: "http://hasura.local/v1/graphql",
-			isLocal:  true,
+			name:   "Test parseQueryHeaders - lib-headers removed",
+			fields: fields{},
 			args: args{
-				queryContent: `query listUserBots {
-					tbl_botz(limit: 1) {
-						bot_name
-					}
-				}`,
-				queryVariables: nil,
+				queryHeaders: map[string]interface{}{
+					"x-test-header": "test",
+					"gqlcache":      true,
+				},
+			},
+			wantReturnHeaders: map[string]interface{}{
+				"x-test-header": "test",
 			},
-			wantResult: ``,
-			wantErr:    true,
 		},
 	}
 	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			if tt.isLocal {
-				os.Setenv("GRAPHQL_ENDPOINT", tt.endpoint)
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			if gotReturnHeaders := c.parseQueryHeaders(tt.args.queryHeaders); !reflect.DeepEqual(gotReturnHeaders, tt.wantReturnHeaders) {
+				t.Errorf("BaseClient.parseQueryHeaders() = %v, want %v", gotReturnHeaders, tt.wantReturnHeaders)
 			}
-			g := NewConnection()
-			gotResult, gotErr := g.Query(tt.args.queryContent, tt.args.queryVariables, nil)
-			if tt.wantErr {
-				assert.Error(t, gotErr)
-			}
-			assert.Equal(t, tt.wantResult, gotResult)
 		})
 	}
 }

request.go

@@ -0,0 +1,59 @@
+package gql
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/avast/retry-go/v4"
+)
+
+func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err error) {
+	var queryResult queryResults
+	httpRequest, err := http.NewRequest("POST", c.endpoint, bytes.NewBuffer(query))
+	if err != nil {
+		c.Logger.Error(c, "Error while creating http request;", "error", err.Error())
+		return
+	}
+
+	for key, value := range headers.(map[string]interface{}) {
+		httpRequest.Header.Add(key, fmt.Sprintf("%s", value))
+	}
+
+	var httpResponse *http.Response
+
+	err = retry.Do(
+		func() error {
+			httpResponse, err = c.client.Do(httpRequest)
+			if err != nil {
+				c.Logger.Error(c, "Error while executing http request;", "error", err.Error())
+				return err
+			}
+			defer httpResponse.Body.Close()
+
+			if httpResponse.StatusCode <= 200 && httpResponse.StatusCode >= 204 {
+				return err
+			}
+
+			body, err := ioutil.ReadAll(httpResponse.Body)
+			if err != nil {
+				c.Logger.Error(c, "Error while reading http response;", "error", err.Error())
+				return err
+			}
+
+			err = json.Unmarshal(body, &queryResult)
+			if err != nil {
+				c.Logger.Error(c, "Error while unmarshalling http response;", "error", err.Error())
+				return err
+			}
+
+			return nil
+		},
+	)
+
+	if len(queryResult.Errors) > 0 {
+		return nil, fmt.Errorf("%v", queryResult.Errors)
+	}
+	return queryResult.Data, nil
+}

sample/client.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+
+	graphql "github.com/lukaszraczylo/go-simple-graphql"
+)
+
+func main() {
+	gql := graphql.NewConnection()
+
+	query := `query MyQuery {
+		bots {
+			bot_name
+			ddd
+		}
+	}`
+	_, err := gql.Query(query, nil, nil)
+	if err != nil {
+		fmt.Println("Error returned from query:", err)
+	}
+
+	query = `query MyQuery {
+		badwords(distinct_on: word) {
+			word
+		}
+	}`
+	gql.Query(query, nil, nil)
+
+	// Repeated to use the cached response
+	query = `query MyQuery {
+		badwords(distinct_on: word) {
+			word
+		}
+	}`
+	gql.Query(query, nil, nil)
+}

semver.yaml

@@ -1,8 +1,9 @@
 version: 1
 force:
   major: 1
-  minor: 0
+  minor: 1
   patch: 0
+  commit: 6a8f99f6ef8f65a303dad74c272ff12bf9fe526f
 wording:
   minor:
     - minor-release

structs.go

@@ -0,0 +1,57 @@
+package gql
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+
+	"github.com/allegro/bigcache"
+)
+
+type cacheStore struct {
+	client  *bigcache.BigCache
+	ttl     int
+	enabled bool
+}
+
+type retriesConfig struct {
+	enabled bool
+	max     int
+	delay   int
+}
+
+type BaseClient struct {
+	Logger             Logger
+	LoggerWriter       Writer
+	client             *http.Client
+	concurrencyManager *concurrency.Pool
+	endpoint           string
+	responseType       string
+	cache              cacheStore
+	MaxGoRoutines      int
+	LoggingLevel       logger.LogLevel
+	LoggerColorful     bool
+	validate           bool
+	retries            retriesConfig
+}
+
+type Query struct {
+	context       context.Context
+	variables     map[string]any `json:"variables"`
+	query         string         `json:"query"`
+	compiledQuery []byte         `json:"compiledQuery"`
+}
+
+type request struct {
+	Variables any    `json:"variables"`
+	Query     string `json:"query"`
+}
+
+type queryResults struct {
+	Data   interface{} `json:"data"`
+	Errors []struct {
+		Message interface{} `json:"message"`
+	} `json:"errors"`
+}

utils/concurrency/concurrency.go

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,74 @@
+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/helpers/helpers.go

@@ -0,0 +1,13 @@
+package helpers
+
+import (
+	"unsafe"
+)
+
+func StringToBytes(s string) []byte {
+	return unsafe.Slice(unsafe.StringData(s), len(s))
+}
+
+func BytesToString(b []byte) string {
+	return unsafe.String(unsafe.SliceData(b), len(b))
+}

utils/helpers/helpers_test.go

@@ -0,0 +1,70 @@
+package helpers
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestStringToBytes(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []byte
+	}{
+		{
+			name: "TestStringToBytes",
+			args: args{
+				s: "hello world",
+			},
+			want: []byte("hello world"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := StringToBytes(tt.args.s); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("StringToBytes() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBytesToString(t *testing.T) {
+	type args struct {
+		b []byte
+	}
+	tests := []struct {
+		name string
+		want string
+		args args
+	}{
+		{
+			name: "TestBytesToString",
+			args: args{
+				b: []byte("hello world"),
+			},
+			want: "hello world",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := BytesToString(tt.args.b); got != tt.want {
+				t.Errorf("BytesToString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func BenchmarkStringToBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		StringToBytes("hello world")
+	}
+}
+
+func BenchmarkBytesToString(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		BytesToString([]byte("hello world"))
+	}
+}

utils/logger/logger.go

@@ -0,0 +1,72 @@
+package logger
+
+import (
+	"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"
+	greenBold  = "\033[1;32m"
+	yellowBold = "\033[1;33m"
+	blueBold   = "\033[1;34m"
+)
+
+type LogLevel int
+
+const (
+	Silent LogLevel = iota
+	Error
+	Warn
+	Info
+	Debug
+)
+
+type Config struct {
+	Colorful bool
+	LogLevel LogLevel
+}
+
+func Serialize(v any) (string, error) {
+	marshal, err := json.Marshal(internalSerialize(v))
+	if err != nil {
+		return "", err
+	}
+	return helpers.BytesToString(marshal), nil
+}
+
+func internalSerialize(v any) any {
+	if v != nil {
+		switch reflect.TypeOf(v).Kind() {
+		case reflect.Struct:
+			r := ordered_map.New()
+			name := reflect.TypeOf(v).Name()
+			if name != "" {
+				r.Set("_", 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()))
+			}
+			return r
+		case reflect.Ptr:
+			if !reflect.ValueOf(v).IsNil() {
+				return internalSerialize(reflect.ValueOf(v).Elem().Interface())
+			}
+		case reflect.Slice:
+			var r []any
+			tmpSlice := reflect.ValueOf(v)
+			for i := 0; i < tmpSlice.Len(); i++ {
+				r = append(r, internalSerialize(tmpSlice.Index(i).Interface()))
+			}
+			return r
+		}
+	}
+	return v
+}

utils/logger/logger_test.go

@@ -0,0 +1,84 @@
+package logger
+
+import "testing"
+
+type Person struct {
+	Name string
+	Age  int
+}
+
+func TestSerializeStruct(t *testing.T) {
+	person := Person{Name: "Alice", Age: 30}
+	expected := `{"_":"logger.Person","Name":"Alice","Age":30}`
+	actual, err := Serialize(person)
+	if err != nil {
+		t.Errorf("Error: %v", err)
+	}
+	if actual != expected {
+		t.Errorf("Expected: %v\nActual: %v", expected, actual)
+	}
+}
+
+func TestSerializeNilPointer(t *testing.T) {
+	var person *Person
+	expected := `null`
+	actual, err := Serialize(person)
+	if err != nil {
+		t.Errorf("Error: %v", err)
+	}
+	if actual != expected {
+		t.Errorf("Expected: %v\nActual: %v", expected, actual)
+	}
+}
+
+func TestSerializeNonNilPointer(t *testing.T) {
+	person := &Person{Name: "Alice", Age: 30}
+	expected := `{"_":"logger.Person","Name":"Alice","Age":30}`
+	actual, err := Serialize(person)
+	if err != nil {
+		t.Errorf("Error: %v", err)
+	}
+	if actual != expected {
+		t.Errorf("Expected: %v\nActual: %v", expected, actual)
+	}
+}
+
+func TestSerializeSlice(t *testing.T) {
+	people := []Person{
+		{Name: "Alice", Age: 30},
+		{Name: "Bob", Age: 40},
+	}
+	expected := `[{"_":"logger.Person","Name":"Alice","Age":30},{"_":"logger.Person","Name":"Bob","Age":40}]`
+	actual, err := Serialize(people)
+	if err != nil {
+		t.Errorf("Error: %v", err)
+	}
+	if actual != expected {
+		t.Errorf("Expected: %v\nActual: %v", expected, actual)
+	}
+}
+
+func TestSerializeSliceOfPointers(t *testing.T) {
+	people := []*Person{
+		{Name: "Alice", Age: 30},
+		{Name: "Bob", Age: 40},
+	}
+	expected := `[{"_":"logger.Person","Name":"Alice","Age":30},{"_":"logger.Person","Name":"Bob","Age":40}]`
+
+	actual, err := Serialize(people)
+	if err != nil {
+		t.Errorf("Error: %v", err)
+	}
+	if actual != expected {
+		t.Errorf("Expected: %v\nActual: %v", expected, actual)
+	}
+}
+
+func TestSerializeUnsupportedType(t *testing.T) {
+	type UnsupportedType chan int
+	unsupportedType := make(UnsupportedType)
+	_, err := Serialize(unsupportedType)
+	if err == nil {
+		t.Errorf("Expected an error, but got nil")
+	}
+}

utils/ordered_map/ordered_map.go

@@ -0,0 +1,64 @@
+package ordered_map
+
+import (
+	"bytes"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+
+type OrderedMap struct {
+	values map[string]interface{}
+	keys   []string
+}
+
+func New() *OrderedMap {
+	o := OrderedMap{}
+	o.keys = []string{}
+	o.values = map[string]interface{}{}
+	return &o
+}
+
+func (o *OrderedMap) Set(key string, value interface{}) {
+	_, exists := o.values[key]
+	if !exists {
+		o.keys = append(o.keys, key)
+	}
+	o.values[key] = value
+}
+
+func (o OrderedMap) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	buf.WriteByte('{')
+	encoder := json.NewEncoder(&buf)
+	encoder.SetEscapeHTML(false)
+	encoder.SetIndent("", "")
+	for i, k := range o.keys {
+		if i > 0 {
+			buf.WriteByte(',')
+		}
+		buf.WriteByte('"')
+		buf.WriteString(k)
+		buf.WriteString(`":`)
+		customEncoder := &customJsonEncoder{buf: &buf}
+		if err := customEncoder.Encode(o.values[k]); err != nil {
+			return nil, err
+		}
+	}
+	buf.WriteByte('}')
+	return buf.Bytes(), nil
+}
+
+type customJsonEncoder struct {
+	buf *bytes.Buffer
+}
+
+func (e *customJsonEncoder) Encode(v interface{}) error {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	e.buf.Write(data)
+	return nil
+}

utils/ordered_map/ordered_map_test.go

@@ -0,0 +1,164 @@
+package ordered_map
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNew(t *testing.T) {
+	tests := []struct {
+		want *OrderedMap
+		name string
+	}{
+		{
+			name: "TestNew",
+			want: &OrderedMap{
+				keys:   []string{},
+				values: map[string]interface{}{},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := New(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("New() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestOrderedMap_Set(t *testing.T) {
+	type fields struct {
+		values map[string]interface{}
+		keys   []string
+	}
+	type args struct {
+		value interface{}
+		key   string
+	}
+	tests := []struct {
+		args   args
+		name   string
+		fields fields
+	}{
+		{
+			name: "TestOrderedMap_Set",
+			fields: fields{
+				values: map[string]interface{}{},
+				keys:   []string{},
+			},
+			args: args{},
+		},
+		{
+			name: "TestOrderedMap_Set2",
+			fields: fields{
+				values: map[string]interface{}{
+					"hello": "world",
+				},
+				keys: []string{"hello"},
+			},
+			args: args{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			o := &OrderedMap{
+				values: tt.fields.values,
+				keys:   tt.fields.keys,
+			}
+			o.Set(tt.args.key, tt.args.value)
+			for _, key := range o.keys {
+				if _, ok := o.values[key]; !ok {
+					t.Errorf("OrderedMap.Set() key not found in values map")
+				}
+			}
+		})
+	}
+}
+
+func TestOrderedMap_MarshalJSON(t *testing.T) {
+	type fields struct {
+		values map[string]interface{}
+		keys   []string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		want    []byte
+		wantErr bool
+	}{
+		{
+			name: "TestOrderedMap_MarshalJSON",
+			fields: fields{
+				values: map[string]interface{}{
+					"hello": "world",
+				},
+				keys: []string{"hello"},
+			},
+			want:    []byte(`{"hello":"world"}`),
+			wantErr: false,
+		},
+		{
+			name: "TestOrderedMap_MarshalJSON2",
+			fields: fields{
+				values: map[string]interface{}{
+					"hello": "world",
+					"foo":   "bar",
+				},
+				keys: []string{"hello", "foo"},
+			},
+			want:    []byte(`{"hello":"world","foo":"bar"}`),
+			wantErr: false,
+		},
+		{
+			name: "TestOrderedMap_MarshalJSON_with_error",
+			fields: fields{
+				values: map[string]interface{}{
+					"hello": "world",
+					"foo":   make(chan int),
+				},
+				keys: []string{"hello", "foo"},
+			},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			o := OrderedMap{
+				values: tt.fields.values,
+				keys:   tt.fields.keys,
+			}
+			got, err := o.MarshalJSON()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("OrderedMap.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("OrderedMap.MarshalJSON() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func BenchmarkOrderedMapTest(b *testing.B) {
+	m := New()
+	for i := 0; i < b.N; i++ {
+		m.Set("hello", "world")
+	}
+}
+
+func BenchmarkOrderedMarshalJSON(b *testing.B) {
+	m := New()
+	for i := 0; i < b.N; i++ {
+		m.Set("hello", "world")
+		m.MarshalJSON()
+	}
+}
+
+func BenchmarkMapTest(b *testing.B) {
+	m := make(map[string]interface{})
+	for i := 0; i < b.N; i++ {
+		m["hello"] = "world"
+	}
+}