fixup! Library improvements.

Signed-off-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/workflows/autoupdate.yaml

@@ -0,0 +1,73 @@
+name: Autoupdate go.mod and go.sum
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 3 * * *"
+
+env:
+  GO_VERSION: ">=1.21"
+
+jobs:
+  # This job is responsible for preparation of the build
+  # environment variables.
+  prepare:
+    name: Preparing build context
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        id: cache
+        with:
+          go-version: ${{env.GO_VERSION}}
+          cache-dependency-path: "**/*.sum"
+
+      - name: Go get dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          go get ./...
+
+  # This job is responsible for running tests and linting the codebase
+  test:
+    name: "Unit testing"
+    runs-on: ubuntu-latest
+    container: golang:1
+    needs: [prepare]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Ensure full history is checked out
+          token: ${{ secrets.GHCR_TOKEN }}
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{env.GO_VERSION}}
+          cache-dependency-path: "**/*.sum"
+
+      - name: Install dependencies
+        run: |
+          apt-get update
+          apt-get install ca-certificates make -y
+          update-ca-certificates
+          go mod tidy
+          go get -u -v ./...
+          go mod tidy -v
+
+      - name: Run unit tests
+        run: |
+          CI_RUN=${CI} make test
+          git config --global --add safe.directory /__w/go-simple-graphql/go-simple-graphql
+
+      - name: Commit changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "Update go.mod and go.sum"
+          commit_options: "--no-verify --signoff"
+          file_pattern: "go.mod go.sum"

.github/workflows/test.yaml

@@ -12,6 +12,6 @@ jobs:
   shared:
     uses: telegram-bot-app/ci-scripts/.github/workflows/library-test-publish.yaml@main
     with:
-      enable-code-scans: true
+      enable-code-scans: false
     secrets:
       ghcr-token: ${{ secrets.GHCR_TOKEN }}

README.md

@@ -9,6 +9,7 @@ Ps. It's Hasura friendly.
   - [Features](#features)
   - [Usage example](#usage-example)
     - [Environment variables](#environment-variables)
+    - [Modifiers on the fly](#modifiers-on-the-fly)
     - [Cache](#cache)
     - [Example reader code](#example-reader-code)
     - [Tips](#tips)
@@ -34,25 +35,34 @@ Therefore, I present you the simple client to which you can copy & paste your gr
 * `GRAPHQL_ENDPOINT` - Your GraphQL endpoint. Default: `http://127.0.0.1:9090/v1/graphql`
 * `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: `byte`, available: `byte`, `string`
+* `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`
 
+### Modifiers on the fly
+
+* `gql.SetEndpoint('your-endpoint-url')` - modifies endpoint, without the need to set the environment variable
+* `gql.SetOutput('byte')` - modifies output format, without the need to set the environment variable
+
 ### Cache
 
 You have two options to enable the cache:
 
 * 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,
+  "gqlcache": true, // sets the cache as on for this query only
+  "gqlretries": false, // disables retries for this query only
 }
 ```
 

base.go

@@ -1,98 +0,0 @@
-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)
-	} else {
-		b.LoggerWriter = b.LoggerWriter
-	}
-
-	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
-}

base_test.go

@@ -1,103 +0,0 @@
-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)
-		})
-	}
-}

buffer_pool_bench_test.go

@@ -0,0 +1,181 @@
+package gql
+
+import (
+	"bytes"
+	"testing"
+)
+
+// Benchmark tiered buffer pools vs single pool
+func BenchmarkBufferPools(b *testing.B) {
+	// Test data of different sizes
+	smallData := make([]byte, 512)
+	mediumData := make([]byte, 2048)
+	largeData := make([]byte, 8192)
+
+	for i := range smallData {
+		smallData[i] = byte(i % 256)
+	}
+	for i := range mediumData {
+		mediumData[i] = byte(i % 256)
+	}
+	for i := range largeData {
+		largeData[i] = byte(i % 256)
+	}
+
+	b.Run("SmallBuffer_GetPut", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := getBuffer(len(smallData))
+			buf.Write(smallData)
+			putBuffer(buf)
+		}
+	})
+
+	b.Run("MediumBuffer_GetPut", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := getBuffer(len(mediumData))
+			buf.Write(mediumData)
+			putBuffer(buf)
+		}
+	})
+
+	b.Run("LargeBuffer_GetPut", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := getBuffer(len(largeData))
+			buf.Write(largeData)
+			putBuffer(buf)
+		}
+	})
+
+	// Compare with old single pool approach
+	b.Run("SinglePool_Small", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := bufferPool.Get().(*bytes.Buffer)
+			buf.Reset()
+			buf.Write(smallData)
+			bufferPool.Put(buf)
+		}
+	})
+
+	b.Run("SinglePool_Medium", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := bufferPool.Get().(*bytes.Buffer)
+			buf.Reset()
+			buf.Write(mediumData)
+			bufferPool.Put(buf)
+		}
+	})
+
+	b.Run("SinglePool_Large", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			buf := bufferPool.Get().(*bytes.Buffer)
+			buf.Reset()
+			buf.Write(largeData)
+			bufferPool.Put(buf)
+		}
+	})
+}
+
+// Benchmark buffer allocation patterns
+func BenchmarkBufferAllocation(b *testing.B) {
+	b.Run("TieredPools_Mixed", func(b *testing.B) {
+		sizes := []int{256, 512, 1024, 2048, 4096, 8192, 16384}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			size := sizes[i%len(sizes)]
+			buf := getBuffer(size)
+			data := make([]byte, size)
+			buf.Write(data)
+			putBuffer(buf)
+		}
+	})
+
+	b.Run("DirectAllocation_Mixed", func(b *testing.B) {
+		sizes := []int{256, 512, 1024, 2048, 4096, 8192, 16384}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			size := sizes[i%len(sizes)]
+			buf := bytes.NewBuffer(make([]byte, 0, size))
+			data := make([]byte, size)
+			buf.Write(data)
+		}
+	})
+}
+
+// Test buffer pool correctness
+func TestBufferPoolCorrectness(t *testing.T) {
+	testData := []byte("Hello, World! This is test data for buffer pool testing.")
+
+	// Test small buffer
+	buf := getBuffer(len(testData))
+	buf.Write(testData)
+	if buf.Len() != len(testData) {
+		t.Errorf("Buffer length mismatch: expected %d, got %d", len(testData), buf.Len())
+	}
+	if !bytes.Equal(buf.Bytes(), testData) {
+		t.Error("Buffer content mismatch")
+	}
+	putBuffer(buf)
+
+	// Test that buffer is properly reset when returned to pool
+	buf2 := getBuffer(10)
+	if buf2.Len() != 0 {
+		t.Error("Buffer not properly reset")
+	}
+	putBuffer(buf2)
+
+	// Test large buffer
+	largeData := make([]byte, 10000)
+	for i := range largeData {
+		largeData[i] = byte(i % 256)
+	}
+
+	largeBuf := getBuffer(len(largeData))
+	largeBuf.Write(largeData)
+	if largeBuf.Len() != len(largeData) {
+		t.Errorf("Large buffer length mismatch: expected %d, got %d", len(largeData), largeBuf.Len())
+	}
+	putBuffer(largeBuf)
+}
+
+// Test buffer pool size selection
+func TestBufferPoolSizeSelection(t *testing.T) {
+	testCases := []struct {
+		size         int
+		expectedPool string
+	}{
+		{100, "small"},
+		{1024, "small"},
+		{1025, "medium"},
+		{4096, "medium"},
+		{4097, "large"},
+		{16384, "large"},
+		{20000, "large"},
+	}
+
+	for _, tc := range testCases {
+		buf := getBuffer(tc.size)
+		capacity := buf.Cap()
+
+		var poolType string
+		switch {
+		case capacity <= 1024:
+			poolType = "small"
+		case capacity <= 4096:
+			poolType = "medium"
+		default:
+			poolType = "large"
+		}
+
+		if poolType != tc.expectedPool {
+			t.Errorf("Size %d: expected %s pool, got %s pool (capacity: %d)",
+				tc.size, tc.expectedPool, poolType, capacity)
+		}
+		putBuffer(buf)
+	}
+}

cache.go

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

cache/cache.go

@@ -0,0 +1,275 @@
+package libpack_cache
+
+import (
+	"bytes"
+	"compress/gzip"
+	"hash/fnv"
+	"io"
+	"sync"
+	"time"
+)
+
+type CacheEntry struct {
+	ExpiresAt    time.Time
+	Value        []byte
+	IsCompressed bool
+}
+
+const shardCount = 256 // Must be power of 2
+
+type shard struct {
+	entries map[string]CacheEntry
+	sync.RWMutex
+}
+
+type Cache struct {
+	compressPool   sync.Pool
+	decompressPool sync.Pool
+	shards         [shardCount]*shard
+	globalTTL      time.Duration
+	cleanupChan    chan struct{}
+	stopChan       chan struct{}
+	stopped        bool
+	mu             sync.RWMutex
+}
+
+// getShard returns the appropriate shard for a given key
+func (c *Cache) getShard(key string) *shard {
+	hash := fnv.New32a()
+	hash.Write([]byte(key))
+	return c.shards[hash.Sum32()%shardCount]
+}
+
+func New(globalTTL time.Duration) *Cache {
+	cache := &Cache{
+		globalTTL:   globalTTL,
+		cleanupChan: make(chan struct{}, 1),
+		stopChan:    make(chan struct{}),
+		compressPool: sync.Pool{
+			New: func() interface{} {
+				w := gzip.NewWriter(nil)
+				return w
+			},
+		},
+		decompressPool: sync.Pool{
+			New: func() interface{} {
+				r, _ := gzip.NewReader(bytes.NewReader([]byte{}))
+				return r
+			},
+		},
+	}
+
+	// Initialize shards
+	for i := 0; i < shardCount; i++ {
+		cache.shards[i] = &shard{
+			entries: make(map[string]CacheEntry),
+		}
+	}
+
+	go cache.lazyCleanupWorker()
+	go cache.periodicCleanupRoutine(globalTTL)
+	return cache
+}
+
+func (c *Cache) lazyCleanupWorker() {
+	for {
+		select {
+		case <-c.cleanupChan:
+			c.mu.RLock()
+			if c.stopped {
+				c.mu.RUnlock()
+				return
+			}
+			c.mu.RUnlock()
+			c.CleanExpiredEntries()
+		case <-c.stopChan:
+			return
+		}
+	}
+}
+
+func (c *Cache) periodicCleanupRoutine(globalTTL time.Duration) {
+	// Use a shorter cleanup interval for better responsiveness, but not less than 1 second
+	cleanupInterval := globalTTL / 4
+	if cleanupInterval < time.Second {
+		cleanupInterval = time.Second
+	}
+
+	ticker := time.NewTicker(cleanupInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			c.mu.RLock()
+			if c.stopped {
+				c.mu.RUnlock()
+				return
+			}
+			c.mu.RUnlock()
+			c.CleanExpiredEntries()
+		case <-c.stopChan:
+			return
+		}
+	}
+}
+
+func (c *Cache) triggerLazyCleanup() {
+	c.mu.RLock()
+	if c.stopped {
+		c.mu.RUnlock()
+		return
+	}
+	c.mu.RUnlock()
+
+	select {
+	case c.cleanupChan <- struct{}{}:
+		// Cleanup triggered
+	default:
+		// Cleanup already pending, skip
+	}
+}
+
+func (c *Cache) Stop() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.stopped {
+		return // Already stopped
+	}
+
+	c.stopped = true
+	close(c.stopChan)
+}
+
+func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
+	shard := c.getShard(key)
+	shard.Lock()
+	defer shard.Unlock()
+
+	const compressionThreshold = 1024 // 1KB threshold
+	var finalValue []byte
+	var isCompressed bool
+
+	if len(value) >= compressionThreshold {
+		compressedValue, err := c.compress(value)
+		if err != nil {
+			// If compression fails, store uncompressed
+			finalValue = value
+			isCompressed = false
+		} else {
+			// Only use compression if it actually reduces size
+			if len(compressedValue) < len(value) {
+				finalValue = compressedValue
+				isCompressed = true
+			} else {
+				finalValue = value
+				isCompressed = false
+			}
+		}
+	} else {
+		finalValue = value
+		isCompressed = false
+	}
+
+	shard.entries[key] = CacheEntry{
+		Value:        finalValue,
+		ExpiresAt:    time.Now().Add(ttl),
+		IsCompressed: isCompressed,
+	}
+}
+
+func (c *Cache) Get(key string) ([]byte, bool) {
+	shard := c.getShard(key)
+	shard.RLock()
+	entry, ok := shard.entries[key]
+	if !ok {
+		shard.RUnlock()
+		return nil, false
+	}
+
+	if entry.ExpiresAt.Before(time.Now()) {
+		shard.RUnlock()
+		// Trigger lazy cleanup instead of immediate deletion
+		c.triggerLazyCleanup()
+		return nil, false
+	}
+	shard.RUnlock()
+
+	var value []byte
+	var err error
+
+	if entry.IsCompressed {
+		value, err = c.decompress(entry.Value)
+		if err != nil {
+			return nil, false
+		}
+	} else {
+		value = entry.Value
+	}
+
+	return value, true
+}
+
+func (c *Cache) Delete(key string) {
+	shard := c.getShard(key)
+	shard.Lock()
+	delete(shard.entries, key)
+	shard.Unlock()
+}
+
+func (c *Cache) CleanExpiredEntries() {
+	now := time.Now()
+	for _, shard := range c.shards {
+		shard.Lock()
+		for key, entry := range shard.entries {
+			if entry.ExpiresAt.Before(now) {
+				delete(shard.entries, key)
+			}
+		}
+		shard.Unlock()
+	}
+}
+
+func (c *Cache) compress(data []byte) ([]byte, error) {
+	w := c.compressPool.Get().(*gzip.Writer)
+	defer c.compressPool.Put(w)
+
+	var buf bytes.Buffer
+	w.Reset(&buf)
+	if _, err := w.Write(data); err != nil {
+		return nil, err
+	}
+	if err := w.Close(); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func (c *Cache) decompress(data []byte) ([]byte, error) {
+	r, ok := c.decompressPool.Get().(*gzip.Reader)
+	if !ok || r == nil {
+		// If r is nil or type assertion fails, create a new gzip.Reader
+		var err error
+		r, err = gzip.NewReader(bytes.NewReader(data))
+		if err != nil {
+			return nil, err // Handle the error if gzip.NewReader fails
+		}
+	} else {
+		// Reset the existing reader with new data
+		if err := r.Reset(bytes.NewReader(data)); err != nil {
+			return nil, err // Handle the error if Reset fails
+		}
+	}
+	defer r.Close()
+
+	// Ensure the reader is returned to the pool
+	defer c.decompressPool.Put(r)
+
+	// Read all the data from the reader
+	decompressedData, err := io.ReadAll(r)
+	if err != nil {
+		return nil, err // Handle the error if reading fails
+	}
+	return decompressedData, nil
+}

cache/cache_bench_test.go

@@ -0,0 +1,50 @@
+package libpack_cache
+
+import (
+	"testing"
+	"time"
+)
+
+// Assume that New function initializes the cache and it is defined somewhere in the libpack_cache package.
+
+func BenchmarkCacheSet(b *testing.B) {
+	cache := New(5 * time.Second) // Use shorter TTL for tests
+	defer cache.Stop()
+	key := "benchmark-key"
+	value := []byte("benchmark-value")
+
+	b.ResetTimer() // Reset the timer to exclude the setup time from the benchmark
+
+	for i := 0; i < b.N; i++ {
+		cache.Set(key, value, 2*time.Second)
+	}
+}
+
+func BenchmarkCacheGet(b *testing.B) {
+	cache := New(5 * time.Second) // Use shorter TTL for tests
+	defer cache.Stop()
+	key := "benchmark-key"
+	value := []byte("benchmark-value")
+	cache.Set(key, value, 2*time.Second) // Pre-set a value to retrieve
+
+	b.ResetTimer() // Start timing
+
+	for i := 0; i < b.N; i++ {
+		_, _ = cache.Get(key)
+	}
+}
+
+func BenchmarkCacheExpire(b *testing.B) {
+	cache := New(5 * time.Second) // Use shorter TTL for tests and reuse cache
+	defer cache.Stop()
+	value := []byte("benchmark-value")
+	ttl := 5 * time.Millisecond // Setting a short TTL for quick expiration
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		key := "benchmark-expire-key-" + string(rune(i)) // Use unique keys
+		cache.Set(key, value, ttl)
+		time.Sleep(ttl + time.Millisecond) // Wait for the key to expire with buffer
+		_, _ = cache.Get(key)
+	}
+}

cache/cache_test.go

@@ -0,0 +1,319 @@
+package libpack_cache
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type CacheTestSuite struct {
+	suite.Suite
+}
+
+func (suite *CacheTestSuite) SetupTest() {
+}
+
+func TestCachingTestSuite(t *testing.T) {
+	suite.Run(t, new(CacheTestSuite))
+}
+
+func (suite *CacheTestSuite) Test_New() {
+	suite.T().Run("should return a new cache", func(t *testing.T) {
+		cache := New(2 * time.Second)
+		defer cache.Stop()
+		suite.NotNil(cache)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheUse() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	tests := []struct {
+		name        string
+		cache_value string
+	}{
+		{
+			name:        "test1",
+			cache_value: "test1-123",
+		},
+		{
+			name:        "test2",
+			cache_value: "test2-123",
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			cache.Set(tt.name, []byte(tt.name), 2*time.Second)
+			c, ok := cache.Get(tt.name)
+			suite.Equal(true, ok)
+			suite.Equal(tt.name, string(c))
+		})
+	}
+}
+
+func (suite *CacheTestSuite) Test_CacheDelete() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	tests := []struct {
+		name        string
+		cache_value string
+	}{
+		{
+			name:        "test1",
+			cache_value: "test1-123",
+		},
+		{
+			name:        "test2",
+			cache_value: "test2-123",
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			cache.Set(tt.name, []byte(tt.name), 2*time.Second)
+			c, ok := cache.Get(tt.name)
+			suite.Equal(true, ok)
+			suite.Equal(tt.name, string(c))
+			cache.Delete(tt.name)
+			c, ok = cache.Get(tt.name)
+			suite.Equal(false, ok)
+			suite.Equal("", string(c))
+		})
+	}
+}
+
+func (suite *CacheTestSuite) Test_CacheExpire() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	tests := []struct {
+		name        string
+		cache_value string
+		ttl         time.Duration
+	}{
+		{
+			name:        "test1",
+			cache_value: "test1-123",
+			ttl:         100 * time.Millisecond,
+		},
+		{
+			name:        "test2",
+			cache_value: "test2-123",
+			ttl:         200 * time.Millisecond,
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			cache.Set(tt.name, []byte(tt.name), tt.ttl)
+			c, ok := cache.Get(tt.name)
+			suite.Equal(true, ok)
+			suite.Equal(tt.name, string(c))
+			time.Sleep(tt.ttl + 50*time.Millisecond) // Add small buffer
+			c, ok = cache.Get(tt.name)
+			suite.Equal(false, ok)
+			suite.Equal("", string(c))
+		})
+	}
+}
+
+func (suite *CacheTestSuite) Test_CacheCompression() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	suite.T().Run("should compress large data", func(t *testing.T) {
+		// Create data larger than compression threshold (1024 bytes)
+		largeData := make([]byte, 2048)
+		for i := range largeData {
+			largeData[i] = byte(i % 256)
+		}
+
+		cache.Set("large_key", largeData, 2*time.Second)
+		retrieved, ok := cache.Get("large_key")
+		suite.True(ok)
+		suite.Equal(largeData, retrieved)
+	})
+
+	suite.T().Run("should handle compression errors gracefully", func(t *testing.T) {
+		// Test with data that might cause compression issues
+		largeData := make([]byte, 1500)
+		for i := range largeData {
+			largeData[i] = byte(i % 256)
+		}
+
+		cache.Set("compression_test", largeData, 2*time.Second)
+		retrieved, ok := cache.Get("compression_test")
+		suite.True(ok)
+		suite.Equal(largeData, retrieved)
+	})
+
+	suite.T().Run("should not compress small data", func(t *testing.T) {
+		smallData := []byte("small data")
+		cache.Set("small_key", smallData, 2*time.Second)
+		retrieved, ok := cache.Get("small_key")
+		suite.True(ok)
+		suite.Equal(smallData, retrieved)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheCompressionEdgeCases() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	suite.T().Run("should handle highly compressible data", func(t *testing.T) {
+		// Create highly compressible data (repeated pattern)
+		compressibleData := make([]byte, 2048)
+		for i := range compressibleData {
+			compressibleData[i] = 'A' // All same character
+		}
+
+		cache.Set("compressible", compressibleData, 2*time.Second)
+		retrieved, ok := cache.Get("compressible")
+		suite.True(ok)
+		suite.Equal(compressibleData, retrieved)
+	})
+
+	suite.T().Run("should handle incompressible data", func(t *testing.T) {
+		// Create random-like data that doesn't compress well
+		incompressibleData := make([]byte, 1500)
+		for i := range incompressibleData {
+			incompressibleData[i] = byte((i*7 + i*i) % 256) // Pseudo-random pattern
+		}
+
+		cache.Set("incompressible", incompressibleData, 2*time.Second)
+		retrieved, ok := cache.Get("incompressible")
+		suite.True(ok)
+		suite.Equal(incompressibleData, retrieved)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheCleanup() {
+	cache := New(100 * time.Millisecond) // Short TTL for faster testing
+	defer cache.Stop()
+
+	suite.T().Run("should clean expired entries", func(t *testing.T) {
+		cache.Set("expire1", []byte("value1"), 50*time.Millisecond)
+		cache.Set("expire2", []byte("value2"), 50*time.Millisecond)
+		cache.Set("persist", []byte("persist"), 5*time.Second)
+
+		// Verify entries exist
+		_, ok := cache.Get("expire1")
+		suite.True(ok)
+		_, ok = cache.Get("expire2")
+		suite.True(ok)
+		_, ok = cache.Get("persist")
+		suite.True(ok)
+
+		// Wait for expiration
+		time.Sleep(100 * time.Millisecond)
+
+		// Trigger cleanup
+		cache.CleanExpiredEntries()
+
+		// Check expired entries are gone
+		_, ok = cache.Get("expire1")
+		suite.False(ok)
+		_, ok = cache.Get("expire2")
+		suite.False(ok)
+
+		// Check persistent entry still exists
+		_, ok = cache.Get("persist")
+		suite.True(ok)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheLazyCleanup() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	suite.T().Run("should trigger lazy cleanup on expired access", func(t *testing.T) {
+		cache.Set("lazy_expire", []byte("value"), 50*time.Millisecond)
+
+		// Verify entry exists
+		_, ok := cache.Get("lazy_expire")
+		suite.True(ok)
+
+		// Wait for expiration
+		time.Sleep(100 * time.Millisecond)
+
+		// Access expired entry should trigger lazy cleanup
+		_, ok = cache.Get("lazy_expire")
+		suite.False(ok)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheStop() {
+	suite.T().Run("should stop cache gracefully", func(t *testing.T) {
+		cache := New(5 * time.Second)
+
+		// Add some data
+		cache.Set("test", []byte("value"), 2*time.Second)
+		_, ok := cache.Get("test")
+		suite.True(ok)
+
+		// Stop cache
+		cache.Stop()
+
+		// Should be able to stop multiple times without panic
+		cache.Stop()
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheSharding() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	suite.T().Run("should distribute keys across shards", func(t *testing.T) {
+		// Test multiple keys to ensure sharding works
+		keys := []string{"key1", "key2", "key3", "key4", "key5"}
+
+		for _, key := range keys {
+			cache.Set(key, []byte("value_"+key), 2*time.Second)
+		}
+
+		for _, key := range keys {
+			value, ok := cache.Get(key)
+			suite.True(ok)
+			suite.Equal("value_"+key, string(value))
+		}
+	})
+}
+
+func (suite *CacheTestSuite) Test_CachePeriodicCleanup() {
+	suite.T().Run("should handle short TTL for periodic cleanup", func(t *testing.T) {
+		// Test with very short TTL to trigger the minimum cleanup interval logic
+		cache := New(500 * time.Millisecond)
+		defer cache.Stop()
+
+		cache.Set("short_ttl", []byte("value"), 100*time.Millisecond)
+
+		// Wait for periodic cleanup to potentially run
+		time.Sleep(200 * time.Millisecond)
+
+		_, ok := cache.Get("short_ttl")
+		suite.False(ok)
+	})
+}
+
+func (suite *CacheTestSuite) Test_CacheDecompressionErrors() {
+	cache := New(5 * time.Second)
+	defer cache.Stop()
+
+	suite.T().Run("should handle decompression pool edge cases", func(t *testing.T) {
+		// This test ensures the decompression pool handles nil readers correctly
+		largeData := make([]byte, 2048)
+		for i := range largeData {
+			largeData[i] = byte(i % 256)
+		}
+
+		// Set and get multiple times to exercise the pool
+		for i := 0; i < 5; i++ {
+			key := "pool_test_" + string(rune('0'+i))
+			cache.Set(key, largeData, 2*time.Second)
+			retrieved, ok := cache.Get(key)
+			suite.True(ok)
+			suite.Equal(largeData, retrieved)
+		}
+	})
+}

cache_compression_bench_test.go

@@ -0,0 +1,172 @@
+package gql
+
+import (
+	"testing"
+	"time"
+
+	cache "github.com/lukaszraczylo/go-simple-graphql/cache"
+)
+
+// Benchmark cache compression with different data sizes
+func BenchmarkCacheCompression(b *testing.B) {
+	c := cache.New(5 * time.Second) // Use shorter TTL for tests
+	defer c.Stop()
+
+	// Small data (under 1KB threshold)
+	smallData := make([]byte, 512)
+	for i := range smallData {
+		smallData[i] = byte(i % 256)
+	}
+
+	// Medium data (over 1KB threshold)
+	mediumData := make([]byte, 2048)
+	for i := range mediumData {
+		mediumData[i] = byte(i % 256)
+	}
+
+	// Large data (much larger than threshold)
+	largeData := make([]byte, 8192)
+	for i := range largeData {
+		largeData[i] = byte(i % 256)
+	}
+
+	// Highly compressible data
+	compressibleData := make([]byte, 4096)
+	for i := range compressibleData {
+		compressibleData[i] = 'A' // Repeating character compresses well
+	}
+
+	b.Run("SmallData_Set", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			c.Set("small", smallData, time.Minute)
+		}
+	})
+
+	b.Run("SmallData_Get", func(b *testing.B) {
+		c.Set("small", smallData, time.Minute)
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = c.Get("small")
+		}
+	})
+
+	b.Run("MediumData_Set", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			c.Set("medium", mediumData, time.Minute)
+		}
+	})
+
+	b.Run("MediumData_Get", func(b *testing.B) {
+		c.Set("medium", mediumData, time.Minute)
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = c.Get("medium")
+		}
+	})
+
+	b.Run("LargeData_Set", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			c.Set("large", largeData, time.Minute)
+		}
+	})
+
+	b.Run("LargeData_Get", func(b *testing.B) {
+		c.Set("large", largeData, time.Minute)
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = c.Get("large")
+		}
+	})
+
+	b.Run("CompressibleData_Set", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			c.Set("compressible", compressibleData, time.Minute)
+		}
+	})
+
+	b.Run("CompressibleData_Get", func(b *testing.B) {
+		c.Set("compressible", compressibleData, time.Minute)
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = c.Get("compressible")
+		}
+	})
+}
+
+// Benchmark cache memory usage with compression
+func BenchmarkCacheMemoryUsage(b *testing.B) {
+	c := cache.New(5 * time.Second) // Use shorter TTL for tests
+	defer c.Stop()
+
+	// Test data that compresses well
+	testData := make([]byte, 4096)
+	for i := range testData {
+		testData[i] = byte(i%10 + '0') // Repeating pattern
+	}
+
+	b.Run("WithCompression", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			key := "key" + string(rune(i%1000))
+			c.Set(key, testData, time.Minute)
+		}
+	})
+}
+
+// Test compression effectiveness
+func TestCompressionEffectiveness(t *testing.T) {
+	c := cache.New(5 * time.Second) // Use shorter TTL for tests
+	defer c.Stop()
+
+	// Highly compressible data
+	compressibleData := make([]byte, 4096)
+	for i := range compressibleData {
+		compressibleData[i] = 'A'
+	}
+
+	// Random data (less compressible)
+	randomData := make([]byte, 4096)
+	for i := range randomData {
+		randomData[i] = byte(i % 256)
+	}
+
+	// Small data (under threshold)
+	smallData := make([]byte, 512)
+	for i := range smallData {
+		smallData[i] = byte(i % 256)
+	}
+
+	// Test compressible data
+	c.Set("compressible", compressibleData, time.Minute)
+	retrieved, ok := c.Get("compressible")
+	if !ok {
+		t.Error("Failed to retrieve compressible data")
+	}
+	if len(retrieved) != len(compressibleData) {
+		t.Errorf("Data length mismatch: expected %d, got %d", len(compressibleData), len(retrieved))
+	}
+
+	// Test random data
+	c.Set("random", randomData, time.Minute)
+	retrieved, ok = c.Get("random")
+	if !ok {
+		t.Error("Failed to retrieve random data")
+	}
+	if len(retrieved) != len(randomData) {
+		t.Errorf("Data length mismatch: expected %d, got %d", len(randomData), len(retrieved))
+	}
+
+	// Test small data (should not be compressed)
+	c.Set("small", smallData, time.Minute)
+	retrieved, ok = c.Get("small")
+	if !ok {
+		t.Error("Failed to retrieve small data")
+	}
+	if len(retrieved) != len(smallData) {
+		t.Errorf("Data length mismatch: expected %d, got %d", len(smallData), len(retrieved))
+	}
+}

execute_query.go

@@ -0,0 +1,177 @@
+package gql
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/avast/retry-go/v4"
+	"github.com/goccy/go-json"
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
+)
+
+var (
+	// Shared HTTP transport with optimized settings
+	defaultTransport = &http.Transport{
+		MaxIdleConns:        100,
+		MaxIdleConnsPerHost: 100,
+		IdleConnTimeout:     90 * time.Second,
+		DisableCompression:  false, // Enable compression for responses
+		ForceAttemptHTTP2:   true,
+		TLSClientConfig:     &tls.Config{InsecureSkipVerify: true}, // Skip TLS verification for test environments
+	}
+
+	// Shared HTTP client with timeouts
+	defaultClient = &http.Client{
+		Transport: defaultTransport,
+		Timeout:   30 * time.Second,
+	}
+)
+
+func (qe *QueryExecutor) executeQuery() ([]byte, error) {
+	// Reuse buffer from pool to avoid allocations
+	buf := bufferPool.Get().(*bytes.Buffer)
+	defer bufferPool.Put(buf)
+	buf.Reset()
+
+	buf.Write(qe.Query)
+
+	httpRequest, err := http.NewRequest(http.MethodPost, qe.endpoint, nil)
+	if err != nil {
+		qe.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't create HTTP request",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
+		return nil, fmt.Errorf("can't create HTTP request: %w", err)
+	}
+
+	for key, value := range qe.Headers {
+		httpRequest.Header.Set(key, fmt.Sprint(value))
+	}
+	// Set Content-Type header if not already set
+	if httpRequest.Header.Get("Content-Type") == "" {
+		httpRequest.Header.Set("Content-Type", "application/json")
+	}
+
+	retriesMax := 1
+	if qe.Retries {
+		retriesMax = qe.retries_number
+	}
+
+	var queryResult queryResults
+	err = retry.Do(
+		func() error {
+			// Reset buffer before each retry
+			buf.Reset()
+			buf.Write(qe.Query)
+
+			// Set the body of the request
+			httpRequest.Body = io.NopCloser(bytes.NewReader(buf.Bytes()))
+			httpRequest.ContentLength = int64(buf.Len())
+
+			// Use default client if custom client is not set
+			client := qe.client
+			if client == nil {
+				client = defaultClient
+			}
+			httpResponse, err := client.Do(httpRequest)
+			if err != nil {
+				return err
+			}
+			defer func() {
+				io.Copy(io.Discard, httpResponse.Body)
+				httpResponse.Body.Close()
+			}()
+
+			if httpResponse.StatusCode < http.StatusOK || httpResponse.StatusCode >= http.StatusMultipleChoices {
+				return fmt.Errorf("HTTP error - status code: %s for %s", httpResponse.Status, httpRequest.URL)
+			}
+
+			var reader io.Reader
+			encoding := httpResponse.Header.Get("Content-Encoding")
+			if encoding == "gzip" {
+				gzipReader, err := gzip.NewReader(httpResponse.Body)
+				if err != nil {
+					return fmt.Errorf("error creating gzip reader: %w", err)
+				}
+				defer gzipReader.Close()
+				reader = gzipReader
+			} else {
+				reader = httpResponse.Body
+			}
+
+			// Use buffer pool for reading response
+			respBuf := bufferPool.Get().(*bytes.Buffer)
+			respBuf.Reset()
+			defer bufferPool.Put(respBuf)
+
+			_, err = io.Copy(respBuf, reader)
+			if err != nil {
+				return fmt.Errorf("error reading HTTP response: %w", err)
+			}
+
+			// Unmarshal response directly from buffer
+			err = json.Unmarshal(respBuf.Bytes(), &queryResult)
+			if err != nil {
+				return fmt.Errorf("error unmarshalling HTTP response: %w", err)
+			}
+
+			return nil
+		},
+		retry.OnRetry(func(n uint, err error) {
+			qe.Logger.Warning(&libpack_logger.LogMessage{
+				Message: "Retrying query",
+				Pairs:   map[string]interface{}{"error": err.Error(), "attempt": n + 1},
+			})
+		}),
+		retry.Attempts(uint(retriesMax)),
+		retry.DelayType(retry.BackOffDelay),
+		retry.Delay(time.Duration(qe.retries_delay)),
+		retry.MaxDelay(10*time.Second),
+		retry.LastErrorOnly(true),
+	)
+	if err != nil {
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Error executing HTTP request",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
+		return nil, err
+	}
+
+	if len(queryResult.Errors) > 0 {
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Error executing query",
+			Pairs:   map[string]interface{}{"error": queryResult.Errors},
+		})
+		return nil, fmt.Errorf("error executing query: %s", queryResult.Errors)
+	}
+
+	if queryResult.Data == nil {
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Error executing query",
+			Pairs:   map[string]interface{}{"error": "no data"},
+		})
+		return nil, errors.New("error executing query: no data")
+	}
+
+	// Marshal queryResult.Data
+	jsonData, err := json.Marshal(queryResult.Data)
+	if err != nil {
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Error marshalling query result",
+			Pairs:   map[string]interface{}{"error": err.Error(), "data": queryResult.Data},
+		})
+		return nil, fmt.Errorf("error marshalling query result: %w. Data: %s", err, queryResult.Data)
+	}
+
+	if qe.CacheKey != "no-cache" {
+		qe.cache.Set(qe.CacheKey, jsonData, qe.CacheTTL)
+	}
+
+	return jsonData, nil
+}

execute_query_test.go

@@ -0,0 +1,308 @@
+package gql
+
+import (
+	"bytes"
+	"compress/gzip"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func (suite *Tests) TestQueryExecutor_executeQuery() {
+	suite.T().Run("should execute query successfully", func(t *testing.T) {
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "test-key",
+			Retries:    false,
+		}
+		qe.endpoint = mockServer.URL
+		qe.client = mockServer.Client()
+		qe.cache = client.cache
+		qe.CacheTTL = 5 * time.Second
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+	})
+
+	suite.T().Run("should handle HTTP errors", func(t *testing.T) {
+		// Create a test server that returns an error
+		errorServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte("Internal Server Error"))
+		}))
+		defer errorServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = errorServer.URL
+		qe.client = errorServer.Client()
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "HTTP error")
+	})
+
+	suite.T().Run("should handle GraphQL errors", func(t *testing.T) {
+		// Create a test server that returns GraphQL errors
+		errorServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"errors":[{"message":"Field not found"}]}`))
+		}))
+		defer errorServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { invalidField }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = errorServer.URL
+		qe.client = errorServer.Client()
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "error executing query")
+	})
+
+	suite.T().Run("should handle no data response", func(t *testing.T) {
+		// Create a test server that returns no data
+		noDataServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"data":null}`))
+		}))
+		defer noDataServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = noDataServer.URL
+		qe.client = noDataServer.Client()
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "no data")
+	})
+
+	suite.T().Run("should handle gzip compressed responses", func(t *testing.T) {
+		// Create a test server that returns gzip compressed data
+		gzipServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.Header().Set("Content-Encoding", "gzip")
+
+			var buf bytes.Buffer
+			gzipWriter := gzip.NewWriter(&buf)
+			gzipWriter.Write([]byte(`{"data":{"viewer":{"login":"testuser"}}}`))
+			gzipWriter.Close()
+
+			w.WriteHeader(http.StatusOK)
+			w.Write(buf.Bytes())
+		}))
+		defer gzipServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "test-gzip",
+			Retries:    false,
+		}
+		qe.endpoint = gzipServer.URL
+		qe.client = gzipServer.Client()
+		qe.cache = client.cache
+		qe.CacheTTL = 5 * time.Second
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+		assert.Contains(string(result), "testuser")
+	})
+
+	suite.T().Run("should handle retries", func(t *testing.T) {
+		attempts := 0
+		retryServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			attempts++
+			if attempts < 3 {
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"data":{"viewer":{"login":"retryuser"}}}`))
+		}))
+		defer retryServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    true,
+		}
+		qe.endpoint = retryServer.URL
+		qe.client = retryServer.Client()
+		qe.cache = client.cache
+		qe.retries_number = 5
+		qe.retries_delay = 100 * time.Millisecond
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+		assert.Contains(string(result), "retryuser")
+		assert.Equal(3, attempts) // Should have retried twice before succeeding
+	})
+
+	suite.T().Run("should use default client when none provided", func(t *testing.T) {
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = mockServer.URL
+		qe.client = nil // No client provided
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+	})
+
+	suite.T().Run("should set default Content-Type header", func(t *testing.T) {
+		var receivedHeaders http.Header
+		headerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			receivedHeaders = r.Header
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"data":{"viewer":{"login":"headeruser"}}}`))
+		}))
+		defer headerServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{}, // No Content-Type header
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = headerServer.URL
+		qe.client = headerServer.Client()
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+		assert.Equal("application/json", receivedHeaders.Get("Content-Type"))
+	})
+
+	suite.T().Run("should handle invalid JSON response", func(t *testing.T) {
+		invalidJSONServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`invalid json response`))
+		}))
+		defer invalidJSONServer.Close()
+
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = invalidJSONServer.URL
+		qe.client = invalidJSONServer.Client()
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "error unmarshalling HTTP response")
+	})
+
+	suite.T().Run("should cache successful responses", func(t *testing.T) {
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "cache-test-key",
+			Retries:    false,
+		}
+		qe.endpoint = mockServer.URL
+		qe.client = mockServer.Client()
+		qe.cache = client.cache
+		qe.CacheTTL = 5 * time.Second
+
+		result, err := qe.executeQuery()
+		assert.NoError(err)
+		assert.NotNil(result)
+
+		// Check that the result was cached
+		cachedResult := client.cacheLookup("cache-test-key")
+		assert.NotNil(cachedResult)
+		assert.Equal(result, cachedResult)
+	})
+}
+
+func (suite *Tests) TestQueryExecutor_executeQuery_requestCreationError() {
+	suite.T().Run("should handle request creation errors", func(t *testing.T) {
+		client := CreateTestClient()
+
+		qe := &QueryExecutor{
+			BaseClient: client,
+			Query:      []byte(`{"query":"query { viewer { login } }"}`),
+			Headers:    map[string]interface{}{"Content-Type": "application/json"},
+			CacheKey:   "no-cache",
+			Retries:    false,
+		}
+		qe.endpoint = "://invalid-url" // Invalid URL to trigger error
+		qe.cache = client.cache
+
+		result, err := qe.executeQuery()
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "can't create HTTP request")
+	})
+}

go.mod

@@ -1,29 +1,26 @@
 module github.com/lukaszraczylo/go-simple-graphql
 
-go 1.20
+go 1.23.0
+
+toolchain go1.23.6
 
 require (
-	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/stretchr/testify v1.8.2
-	golang.org/x/net v0.9.0
+	github.com/avast/retry-go/v4 v4.6.1
+	github.com/goccy/go-json v0.10.5
+	github.com/goccy/go-reflect v1.2.0
+	github.com/gookit/goutil v0.6.18
+	github.com/stretchr/testify v1.10.0
+	golang.org/x/net v0.40.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // 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/gookit/color v1.5.4 // 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.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
+	golang.org/x/sync v0.14.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,69 +1,34 @@
-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/avast/retry-go/v4 v4.6.1 h1:VkOLRubHdisGrHnTu89g08aQEWEgRU7LVEop3GbIcMk=
+github.com/avast/retry-go/v4 v4.6.1/go.mod h1:V6oF8njAwxJ5gRo1Q7Cxab24xs5NCWZBeaHHBklR8mA=
 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.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/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/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
+github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-reflect v1.2.0 h1:O0T8rZCuNmGXewnATuKYnkL0xm6o8UNOJZd/gOkb9ms=
+github.com/goccy/go-reflect v1.2.0/go.mod h1:n0oYZn8VcV2CkWTxi8B9QjkCoq6GTtCEdfmR66YhFtE=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/gookit/goutil v0.6.18 h1:MUVj0G16flubWT8zYVicIuisUiHdgirPAkmnfD2kKgw=
+github.com/gookit/goutil v0.6.18/go.mod h1:AY/5sAwKe7Xck+mEbuxj0n/bc3qwrGNe3Oeulln7zBA=
 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.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.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/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 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.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-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.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-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.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-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.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 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-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=

hash_bench_test.go

@@ -0,0 +1,68 @@
+package gql
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Benchmark_calculateHash(b *testing.B) {
+	client := NewConnection()
+	query := &Query{
+		Query:     "query { viewer { login } }",
+		Variables: map[string]interface{}{"var1": "value1"},
+	}
+	query.JsonQuery = client.convertToJSON(query)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = calculateHash(query)
+	}
+}
+
+func Benchmark_calculateHashLargeQuery(b *testing.B) {
+	client := NewConnection()
+	// Create a larger query to test hash performance with bigger payloads
+	largeQuery := `query {
+		viewer {
+			login
+			name
+			email
+			bio
+			company
+			location
+			websiteUrl
+			twitterUsername
+			repositories(first: 100) {
+				nodes {
+					name
+					description
+					url
+					stargazerCount
+					forkCount
+					primaryLanguage {
+						name
+						color
+					}
+					createdAt
+					updatedAt
+				}
+			}
+		}
+	}`
+
+	variables := make(map[string]interface{})
+	for i := 0; i < 50; i++ {
+		variables[fmt.Sprintf("var%d", i)] = fmt.Sprintf("value%d", i)
+	}
+
+	query := &Query{
+		Query:     largeQuery,
+		Variables: variables,
+	}
+	query.JsonQuery = client.convertToJSON(query)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = calculateHash(query)
+	}
+}

hash_optimization_bench_test.go

@@ -0,0 +1,78 @@
+package gql
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"hash/fnv"
+	"testing"
+)
+
+// Benchmark comparing MD5 vs FNV hash performance
+func BenchmarkHashAlgorithms(b *testing.B) {
+	testData := []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { id name email profile { avatar bio } posts { id title content createdAt } } }","variables":{"id":"12345"}}`)
+
+	b.Run("MD5", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			hash := md5.Sum(testData)
+			_ = hex.EncodeToString(hash[:])
+		}
+	})
+
+	b.Run("FNV64a", func(b *testing.B) {
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			hash := fnv.New64a()
+			hash.Write(testData)
+			_ = hex.EncodeToString(hash.Sum(nil))
+		}
+	})
+}
+
+// Benchmark the new calculateHash function
+func BenchmarkCalculateHash(b *testing.B) {
+	query := &Query{
+		Query: "query GetUser($id: ID!) { user(id: $id) { id name email profile { avatar bio } posts { id title content createdAt } } }",
+		Variables: map[string]interface{}{
+			"id": "12345",
+		},
+		JsonQuery: []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { id name email profile { avatar bio } posts { id title content createdAt } } }","variables":{"id":"12345"}}`),
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = calculateHash(query)
+	}
+}
+
+// Benchmark hash collision rate (quality test)
+func BenchmarkHashCollisions(b *testing.B) {
+	queries := make([]*Query, 1000)
+	for i := 0; i < 1000; i++ {
+		queries[i] = &Query{
+			Query: "query GetUser($id: ID!) { user(id: $id) { id name email } }",
+			Variables: map[string]interface{}{
+				"id": i,
+			},
+			JsonQuery: []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { id name email } }","variables":{"id":` + string(rune(i)) + `}}`),
+		}
+	}
+
+	b.Run("FNV_Collision_Test", func(b *testing.B) {
+		hashes := make(map[string]bool)
+		collisions := 0
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			for _, query := range queries {
+				hash := calculateHash(query)
+				if hashes[hash] {
+					collisions++
+				} else {
+					hashes[hash] = true
+				}
+			}
+		}
+		b.ReportMetric(float64(collisions), "collisions")
+	})
+}

helpers.go

@@ -0,0 +1,54 @@
+package gql
+
+import (
+	"encoding/hex"
+	"fmt"
+	"hash/fnv"
+
+	"github.com/goccy/go-json"
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
+)
+
+func searchForKeysInMapStringInterface(msi map[string]interface{}, key string) interface{} {
+	if msi == nil {
+		return nil
+	}
+	return msi[key]
+}
+
+func calculateHash(query *Query) string {
+	hash := fnv.New64a()
+	hash.Write(query.JsonQuery)
+	return hex.EncodeToString(hash.Sum(nil))
+}
+
+func (b *BaseClient) cacheLookup(hash string) []byte {
+	obj, _ := b.cache.Get(hash)
+	return obj
+}
+
+func (b *BaseClient) decodeResponse(response []byte) (any, error) {
+	switch b.responseType {
+	case "mapstring":
+		var result map[string]interface{}
+		err := json.Unmarshal(response, &result)
+		if err != nil {
+			b.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Can't decode response into mapstring",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return nil, err
+		}
+		return result, nil
+	case "string":
+		return string(response), nil
+	case "byte":
+		return response, nil
+	default:
+		b.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't decode response",
+			Pairs:   map[string]interface{}{"error": "unknown response type"},
+		})
+		return nil, fmt.Errorf("can't decode response - unknown response type specified")
+	}
+}

helpers_test.go

@@ -0,0 +1,169 @@
+package gql
+
+import (
+	"testing"
+	"time"
+
+	"github.com/goccy/go-reflect"
+)
+
+func (suite *Tests) Test_searchForKeysInMapStringInterface() {
+	type args struct {
+		msi map[string]interface{}
+		key string
+	}
+	tests := []struct {
+		wantValue any
+		args      args
+		name      string
+	}{
+		{
+			name: "Test_searchForKeysInMapStringInterface_exists",
+			args: args{
+				msi: map[string]interface{}{
+					"gqlcache": true,
+					"test":     "test2",
+				},
+				key: "test",
+			},
+			wantValue: "test2",
+		},
+		{
+			name: "Test_searchForKeysInMapStringInterface_not_exists",
+			args: args{
+				msi: map[string]interface{}{
+					"gqlcache": true,
+					"test":     "test2",
+				},
+				key: "test-new",
+			},
+			wantValue: nil,
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			assert.Equal(tt.wantValue, searchForKeysInMapStringInterface(tt.args.msi, tt.args.key))
+		})
+	}
+}
+
+func (suite *Tests) TestBaseClient_decodeResponse() {
+	type args struct {
+		response []byte
+	}
+	tests := []struct {
+		want     any
+		name     string
+		setType  string
+		wantType string
+		args     args
+		wantErr  bool
+	}{
+		{
+			name: "TestBaseClient_decodeResponse_mapstring",
+			args: args{
+				response: []byte(`{"data":{"viewer":{"login":"lukaszraczylo"}}}`),
+			},
+			want: map[string]interface{}{
+				"data": map[string]interface{}{
+					"viewer": map[string]interface{}{
+						"login": "lukaszraczylo",
+					},
+				},
+			},
+			setType:  "mapstring",
+			wantType: "map[string]interface {}",
+		},
+		{
+			name: "TestBaseClient_decodeResponse_string",
+			args: args{
+				response: []byte(`{"data":{"viewer":{"login":"lukaszraczylo"}}}`),
+			},
+			want:     `{"data":{"viewer":{"login":"lukaszraczylo"}}}`,
+			setType:  "string",
+			wantType: "string",
+		},
+		{
+			name: "TestBaseClient_decodeResponse_byte",
+			args: args{
+				response: []byte(`{"data":{"viewer":{"login":"lukaszraczylo"}}}`),
+			},
+			want:     []byte(`{"data":{"viewer":{"login":"lukaszraczylo"}}}`),
+			setType:  "byte",
+			wantType: "[]uint8",
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			b := NewConnection()
+			b.SetOutput(tt.setType)
+			got, err := b.decodeResponse(tt.args.response)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("decodeResponse() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			assert.Equal(tt.wantType, reflect.TypeOf(got).String())
+		})
+	}
+}
+
+func (suite *Tests) Test_searchForKeysInMapStringInterface_nil() {
+	suite.T().Run("should handle nil map", func(t *testing.T) {
+		result := searchForKeysInMapStringInterface(nil, "test")
+		assert.Nil(result)
+	})
+}
+
+func (suite *Tests) Test_calculateHash() {
+	suite.T().Run("should calculate consistent hash", func(t *testing.T) {
+		query1 := &Query{JsonQuery: []byte(`{"query": "{ user { name } }"}`)}
+		query2 := &Query{JsonQuery: []byte(`{"query": "{ user { name } }"}`)}
+		query3 := &Query{JsonQuery: []byte(`{"query": "{ user { email } }"}`)}
+
+		hash1 := calculateHash(query1)
+		hash2 := calculateHash(query2)
+		hash3 := calculateHash(query3)
+
+		// Same queries should produce same hash
+		assert.Equal(hash1, hash2)
+		// Different queries should produce different hashes
+		assert.NotEqual(hash1, hash3)
+		// Hash should be non-empty
+		assert.NotEmpty(hash1)
+	})
+}
+
+func (suite *Tests) TestBaseClient_cacheLookup() {
+	suite.T().Run("should lookup cache entries", func(t *testing.T) {
+		client := CreateTestClient()
+
+		// Test cache miss
+		result := client.cacheLookup("nonexistent")
+		assert.Nil(result)
+
+		// Test cache hit
+		testData := []byte("test data")
+		client.cache.Set("test_key", testData, 5*time.Second)
+		result = client.cacheLookup("test_key")
+		assert.Equal(testData, result)
+	})
+}
+
+func (suite *Tests) TestBaseClient_decodeResponse_errors() {
+	suite.T().Run("should handle invalid JSON for mapstring", func(t *testing.T) {
+		client := NewConnection()
+		client.SetOutput("mapstring")
+
+		_, err := client.decodeResponse([]byte(`invalid json`))
+		assert.Error(err)
+	})
+
+	suite.T().Run("should handle unknown response type", func(t *testing.T) {
+		client := NewConnection()
+		client.responseType = "unknown"
+
+		_, err := client.decodeResponse([]byte(`{"test": "data"}`))
+		assert.Error(err)
+		assert.Contains(err.Error(), "unknown response type")
+	})
+}

http.go

@@ -0,0 +1,69 @@
+package gql
+
+import (
+	"crypto/tls"
+	"net/http"
+	"strings"
+	"time"
+
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
+	"golang.org/x/net/http2"
+)
+
+func (b *BaseClient) createHttpClient() (http_client *http.Client) {
+	// Optimized connection pool settings for better performance
+	httpTransport := &http.Transport{
+		MaxIdleConns:          100,              // Reduced from 512
+		MaxConnsPerHost:       50,               // Reduced from 512
+		MaxIdleConnsPerHost:   10,               // Reduced from 512
+		IdleConnTimeout:       30 * time.Second, // Increased for better reuse
+		ResponseHeaderTimeout: 10 * time.Second, // Reduced for faster timeouts
+		DisableKeepAlives:     false,
+		DisableCompression:    false,
+		WriteBufferSize:       4096, // Optimize buffer size
+		ReadBufferSize:        4096, // Optimize buffer size
+	}
+
+	if strings.HasPrefix(b.endpoint, "http://") {
+		http_client = &http.Client{
+			Timeout:   30 * time.Second, // Increased for better reliability
+			Transport: httpTransport,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		}
+		b.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Using HTTP/1.1 over http",
+			Pairs:   nil,
+		})
+	} else if strings.HasPrefix(b.endpoint, "https://") {
+		tlsClientConfig := &tls.Config{}
+		if strings.HasPrefix(b.endpoint, "https://") {
+			tlsClientConfig.InsecureSkipVerify = true
+		}
+		http2Transport := &http2.Transport{
+			AllowHTTP:        true,
+			TLSClientConfig:  tlsClientConfig,
+			ReadIdleTimeout:  30 * time.Second, // Increased for better reuse
+			PingTimeout:      10 * time.Second, // Reduced for faster detection
+			WriteByteTimeout: 10 * time.Second, // Add write timeout
+		}
+		http_client = &http.Client{
+			Timeout:   30 * time.Second, // Increased for better reliability
+			Transport: http2Transport,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		}
+		b.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Using HTTP/2 over https",
+			Pairs:   nil,
+		})
+	} else {
+		b.Logger.Critical(&libpack_logger.LogMessage{
+			Message: "Invalid endpoint - neither http or https",
+		})
+		return nil
+	}
+	return http_client
+}

http_test.go

@@ -0,0 +1,161 @@
+package gql
+
+import (
+	"net/http"
+	"testing"
+	"time"
+
+	"golang.org/x/net/http2"
+)
+
+func (suite *Tests) TestBaseClient_createHttpClient() {
+	suite.T().Run("should create HTTP/1.1 client for http endpoints", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("http://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		assert.NotNil(httpClient)
+		assert.Equal(30*time.Second, httpClient.Timeout)
+		assert.NotNil(httpClient.Transport)
+
+		// Check that it's using regular HTTP transport
+		transport, ok := httpClient.Transport.(*http.Transport)
+		assert.True(ok)
+		assert.Equal(100, transport.MaxIdleConns)
+		assert.Equal(50, transport.MaxConnsPerHost)
+		assert.Equal(10, transport.MaxIdleConnsPerHost)
+		assert.Equal(30*time.Second, transport.IdleConnTimeout)
+		assert.Equal(10*time.Second, transport.ResponseHeaderTimeout)
+		assert.False(transport.DisableKeepAlives)
+		assert.False(transport.DisableCompression)
+		assert.Equal(4096, transport.WriteBufferSize)
+		assert.Equal(4096, transport.ReadBufferSize)
+	})
+
+	suite.T().Run("should create HTTP/2 client for https endpoints", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("https://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		assert.NotNil(httpClient)
+		assert.Equal(30*time.Second, httpClient.Timeout)
+		assert.NotNil(httpClient.Transport)
+
+		// Check that it's using HTTP/2 transport
+		transport, ok := httpClient.Transport.(*http2.Transport)
+		assert.True(ok)
+		assert.True(transport.AllowHTTP)
+		assert.NotNil(transport.TLSClientConfig)
+		assert.True(transport.TLSClientConfig.InsecureSkipVerify)
+		assert.Equal(30*time.Second, transport.ReadIdleTimeout)
+		assert.Equal(10*time.Second, transport.PingTimeout)
+		assert.Equal(10*time.Second, transport.WriteByteTimeout)
+	})
+
+	suite.T().Run("should handle invalid endpoints", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("ftp://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		assert.Nil(httpClient)
+	})
+
+	suite.T().Run("should set redirect policy", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("http://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		assert.NotNil(httpClient)
+		assert.NotNil(httpClient.CheckRedirect)
+
+		// Test redirect policy
+		req, _ := http.NewRequest("GET", "http://example.com", nil)
+		err := httpClient.CheckRedirect(req, []*http.Request{})
+		assert.Equal(http.ErrUseLastResponse, err)
+	})
+
+	suite.T().Run("should handle empty endpoint", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("")
+
+		httpClient := client.createHttpClient()
+		assert.Nil(httpClient)
+	})
+
+	suite.T().Run("should handle endpoint without protocol", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		assert.Nil(httpClient)
+	})
+}
+
+func (suite *Tests) TestBaseClient_createHttpClient_transportSettings() {
+	suite.T().Run("should configure HTTP transport correctly", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("http://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		transport := httpClient.Transport.(*http.Transport)
+
+		// Verify all transport settings
+		assert.Equal(100, transport.MaxIdleConns)
+		assert.Equal(50, transport.MaxConnsPerHost)
+		assert.Equal(10, transport.MaxIdleConnsPerHost)
+		assert.Equal(30*time.Second, transport.IdleConnTimeout)
+		assert.Equal(10*time.Second, transport.ResponseHeaderTimeout)
+		assert.False(transport.DisableKeepAlives)
+		assert.False(transport.DisableCompression)
+		assert.Equal(4096, transport.WriteBufferSize)
+		assert.Equal(4096, transport.ReadBufferSize)
+	})
+
+	suite.T().Run("should configure HTTP/2 transport correctly", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("https://example.com/graphql")
+
+		httpClient := client.createHttpClient()
+		transport := httpClient.Transport.(*http2.Transport)
+
+		// Verify all HTTP/2 transport settings
+		assert.True(transport.AllowHTTP)
+		assert.NotNil(transport.TLSClientConfig)
+		assert.True(transport.TLSClientConfig.InsecureSkipVerify)
+		assert.Equal(30*time.Second, transport.ReadIdleTimeout)
+		assert.Equal(10*time.Second, transport.PingTimeout)
+		assert.Equal(10*time.Second, transport.WriteByteTimeout)
+	})
+}
+
+func (suite *Tests) TestBaseClient_createHttpClient_logging() {
+	suite.T().Run("should log HTTP/1.1 usage", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("http://example.com/graphql")
+
+		// This test verifies that the function runs without error
+		// The actual logging is tested indirectly through the logger tests
+		httpClient := client.createHttpClient()
+		assert.NotNil(httpClient)
+	})
+
+	suite.T().Run("should log HTTP/2 usage", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("https://example.com/graphql")
+
+		// This test verifies that the function runs without error
+		// The actual logging is tested indirectly through the logger tests
+		httpClient := client.createHttpClient()
+		assert.NotNil(httpClient)
+	})
+
+	suite.T().Run("should log critical error for invalid endpoint", func(t *testing.T) {
+		client := NewConnection()
+		client.SetEndpoint("invalid://example.com/graphql")
+
+		// This test verifies that the function runs without error
+		// and returns nil for invalid endpoints (Critical() won't exit in tests)
+		httpClient := client.createHttpClient()
+		assert.Nil(httpClient)
+	})
+}

logger.go

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

logging/logger.go

@@ -0,0 +1,207 @@
+package libpack_logger
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/goccy/go-json"
+)
+
+const (
+	_ = iota
+	LEVEL_DEBUG
+	LEVEL_INFO
+	LEVEL_WARN
+	LEVEL_ERROR
+	LEVEL_FATAL
+)
+
+var LevelNames = [...]string{
+	"none",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+}
+
+const (
+	defaultFormat     = time.RFC3339
+	defaultMinLevel   = LEVEL_INFO
+	defaultShowCaller = false
+)
+
+var defaultOutput = os.Stdout
+
+type Logger struct {
+	output      io.Writer
+	format      string
+	minLogLevel int
+	showCaller  bool
+}
+
+type LogMessage struct {
+	output  io.Writer
+	Pairs   map[string]any
+	Message string
+}
+
+func (m *LogMessage) String() string {
+	return m.Message
+}
+
+var fieldNames = map[string]string{
+	"timestamp": "timestamp",
+	"level":     "level",
+	"message":   "message",
+}
+
+func New() *Logger {
+	return &Logger{
+		format:      defaultFormat,
+		minLogLevel: defaultMinLevel,
+		output:      defaultOutput,
+		showCaller:  defaultShowCaller,
+	}
+}
+
+func (l *Logger) SetOutput(output io.Writer) *Logger {
+	l.output = output
+	return l
+}
+
+var bufferPool = sync.Pool{
+	New: func() any {
+		return new(bytes.Buffer)
+	},
+}
+
+var defaultPairs = make(map[string]any)
+
+func GetLogLevel(level string) int {
+	for i, name := range LevelNames {
+		if name == strings.ToLower(level) {
+			return i
+		}
+	}
+	return defaultMinLevel
+}
+
+func (l *Logger) log(level int, m *LogMessage) {
+	if m.Pairs == nil {
+		m.Pairs = defaultPairs
+	}
+
+	m.Pairs[fieldNames["timestamp"]] = time.Now().Format(l.format)
+	m.Pairs[fieldNames["level"]] = LevelNames[level]
+	m.Pairs[fieldNames["message"]] = m.Message
+
+	if l.showCaller {
+		m.Pairs["caller"] = getCaller()
+	}
+
+	buffer := bufferPool.Get().(*bytes.Buffer)
+	defer bufferPool.Put(buffer)
+	buffer.Reset()
+
+	encoder := json.NewEncoder(buffer)
+	err := encoder.Encode(m.Pairs)
+	if err != nil {
+		fmt.Println("Error marshalling log message:", err)
+		return
+	}
+
+	// if not running in test - use stderr and stdout, otherwise - use logger's output setting
+	if flag.Lookup("test.v") != nil {
+		m.output = os.Stdout
+		if level >= LEVEL_ERROR {
+			m.output = os.Stderr
+		}
+	}
+
+	// Use logger's output setting instead of os.Stdout or os.Stderr
+	l.output.Write(buffer.Bytes())
+}
+
+func (l *Logger) Debug(m *LogMessage) {
+	if l.shouldLog(LEVEL_DEBUG) {
+		l.log(LEVEL_DEBUG, m)
+	}
+}
+
+func (l *Logger) Info(m *LogMessage) {
+	if l.shouldLog(LEVEL_INFO) {
+		l.log(LEVEL_INFO, m)
+	}
+}
+
+func (l *Logger) Warn(m *LogMessage) {
+	if l.shouldLog(LEVEL_WARN) {
+		l.log(LEVEL_WARN, m)
+	}
+}
+
+func (l *Logger) Warning(m *LogMessage) {
+	l.Warn(m)
+}
+
+func (l *Logger) Error(m *LogMessage) {
+	if l.shouldLog(LEVEL_ERROR) {
+		l.log(LEVEL_ERROR, m)
+	}
+}
+
+func (l *Logger) Fatal(m *LogMessage) {
+	if l.shouldLog(LEVEL_FATAL) {
+		l.log(LEVEL_FATAL, m)
+	}
+}
+
+func (l *Logger) Critical(m *LogMessage) {
+	l.Fatal(m)
+	// Only call os.Exit(1) if not running in tests
+	if flag.Lookup("test.v") == nil {
+		os.Exit(1)
+	}
+}
+
+func (l *Logger) shouldLog(level int) bool {
+	return level >= l.minLogLevel
+}
+
+func (l *Logger) SetFormat(format string) *Logger {
+	l.format = format
+	return l
+}
+
+func (l *Logger) SetMinLogLevel(level int) *Logger {
+	l.minLogLevel = level
+	return l
+}
+
+func (l *Logger) SetFieldName(field, name string) *Logger {
+	fieldNames[field] = name
+	return l
+}
+
+func (l *Logger) SetShowCaller(show bool) *Logger {
+	l.showCaller = show
+	return l
+}
+
+func getCaller() string {
+	_, file, line, ok := runtime.Caller(3)
+	if !ok {
+		return "unknown:0"
+	}
+	file = filepath.Base(file)
+	return fmt.Sprintf("%s:%d", file, line)
+}

logging/logger_bench_test.go

@@ -0,0 +1,140 @@
+package libpack_logger
+
+import (
+	"bytes"
+	"testing"
+	"time"
+)
+
+func Benchmark_NewLogger(b *testing.B) {
+	type triggers struct {
+		ModFormat struct {
+			Format string
+		}
+		ModLevel struct {
+			Level int
+		}
+	}
+
+	tests := []struct {
+		name     string
+		triggers triggers
+	}{
+		{
+			name: "BenchmarkNew",
+		},
+		{
+			name: "BenchmarkNewChangeTimeFormat",
+			triggers: triggers{
+				ModFormat: struct{ Format string }{
+					Format: time.RFC3339Nano,
+				},
+			},
+		},
+		{
+			name: "BenchmarkNewChangeLogLevel",
+			triggers: triggers{
+				ModLevel: struct{ Level int }{
+					Level: LEVEL_DEBUG,
+				},
+			},
+		},
+		{
+			name: "BenchmarkNewChangeTimeFormatAndLogLevel",
+			triggers: triggers{
+				ModFormat: struct{ Format string }{
+					Format: time.RFC3339Nano,
+				},
+				ModLevel: struct{ Level int }{
+					Level: LEVEL_DEBUG,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		b.Run(tt.name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				got := New()
+
+				if tt.triggers.ModFormat.Format != "" {
+					got.SetFormat(tt.triggers.ModFormat.Format)
+				}
+
+				if tt.triggers.ModLevel.Level != 0 {
+					got.SetMinLogLevel(tt.triggers.ModLevel.Level)
+				}
+			}
+		})
+	}
+}
+
+func Benchmark_Log_Debug(b *testing.B) {
+	output := &bytes.Buffer{}
+	logger := New().SetMinLogLevel(LEVEL_DEBUG).SetOutput(output)
+	msg := &LogMessage{
+		Message: "debug message",
+		Pairs:   make(map[string]any),
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		logger.Debug(msg)
+	}
+}
+
+func Benchmark_Log_Info(b *testing.B) {
+	output := &bytes.Buffer{}
+	logger := New().SetMinLogLevel(LEVEL_INFO).SetOutput(output)
+	msg := &LogMessage{
+		Message: "info message",
+		Pairs:   make(map[string]any),
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		logger.Info(msg)
+	}
+}
+
+func Benchmark_Log_Warn(b *testing.B) {
+	output := &bytes.Buffer{}
+	logger := New().SetMinLogLevel(LEVEL_WARN).SetOutput(output)
+	msg := &LogMessage{
+		Message: "warn message",
+		Pairs:   make(map[string]any),
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		logger.Warn(msg)
+	}
+}
+
+func Benchmark_Log_Error(b *testing.B) {
+	output := &bytes.Buffer{}
+	logger := New().SetMinLogLevel(LEVEL_ERROR).SetOutput(output)
+	msg := &LogMessage{
+		Message: "error message",
+		Pairs:   map[string]any{"key": "value"},
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		logger.Error(msg)
+	}
+}
+
+func Benchmark_Log_Fatal(b *testing.B) {
+	output := &bytes.Buffer{}
+	logger := New().SetMinLogLevel(LEVEL_FATAL).SetOutput(output)
+	msg := &LogMessage{
+		Message: "fatal message",
+		Pairs:   make(map[string]any),
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		logger.Fatal(msg)
+	}
+}

logging/logger_suite_test.go

@@ -0,0 +1,31 @@
+package libpack_logger
+
+import (
+	"testing"
+
+	assertions "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type LoggerTestSuite struct {
+	suite.Suite
+}
+
+var (
+	assert *assertions.Assertions
+)
+
+func (suite *LoggerTestSuite) BeforeTest(suiteName, testName string) {
+}
+
+func (suite *LoggerTestSuite) SetupTest() {
+	assert = assertions.New(suite.T())
+}
+
+// TearDownTest is run after each test to clean up
+func (suite *LoggerTestSuite) TearDownTest() {
+}
+
+func TestSuite(t *testing.T) {
+	suite.Run(t, new(LoggerTestSuite))
+}

logging/logger_test.go

@@ -0,0 +1,399 @@
+package libpack_logger
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/goccy/go-json"
+	"github.com/goccy/go-reflect"
+)
+
+func (suite *LoggerTestSuite) Test_LogMessageString() {
+	msg := &LogMessage{
+		Message: "test message",
+	}
+
+	assert.Equal("test message", msg.String())
+}
+
+func callLoggerMethod(logger *Logger, methodName string, message *LogMessage) {
+	// Get the method by name using reflection
+	method := reflect.ValueOf(logger).MethodByName(methodName)
+	if method.IsValid() {
+		// Call the method with the message as an argument
+		method.Call([]reflect.Value{reflect.ValueOf(message)})
+	} else {
+		fmt.Printf("Method %s does not exist on Logger\n", methodName)
+	}
+}
+
+func (suite *LoggerTestSuite) Test_LogsLevelsPrint() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output)
+
+	tests := []struct {
+		pairs           map[string]any
+		name            string
+		method          string
+		message         string
+		loggerMinLevel  int
+		messageLogLevel int
+		wantOutput      bool
+	}{
+		{
+			name:            "Log: Debug, Level: Debug - no pairs",
+			method:          "Debug",
+			loggerMinLevel:  LEVEL_DEBUG,
+			messageLogLevel: LEVEL_DEBUG,
+			message:         "debug message",
+			wantOutput:      true,
+		},
+		{
+			name:            "Log: Info, Level: Info - one pair",
+			method:          "Info",
+			loggerMinLevel:  LEVEL_INFO,
+			messageLogLevel: LEVEL_INFO,
+			message:         "info message",
+			pairs: map[string]any{
+				"key": "value",
+			},
+			wantOutput: true,
+		},
+		{
+			name:            "Log: Info, Level: Warn - with pairs",
+			method:          "Info",
+			loggerMinLevel:  LEVEL_WARN,
+			messageLogLevel: LEVEL_INFO,
+			message:         "warn message",
+			pairs: map[string]any{
+				"key1": "value1",
+				"key2": "value2",
+			},
+			wantOutput: false,
+		},
+		{
+			name:            "Log: Warn, Level: Info - with 500 pairs",
+			method:          "Warn",
+			loggerMinLevel:  LEVEL_INFO,
+			messageLogLevel: LEVEL_WARN,
+			message:         "warn message with 500 pairs",
+			pairs: func() map[string]any {
+				pairs := make(map[string]any)
+				for i := 0; i < 500; i++ {
+					pairs[fmt.Sprintf("key%d", i)] = fmt.Sprintf("value%d", i)
+				}
+				return pairs
+			}(),
+			wantOutput: true,
+		},
+	}
+
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			msg := &LogMessage{
+				Message: tt.message,
+				Pairs:   tt.pairs,
+			}
+			output.Reset()
+
+			// Set logger's minimum log level
+			logger.SetMinLogLevel(tt.loggerMinLevel)
+			fmt.Println("Logger min log level:", LevelNames[logger.minLogLevel])
+
+			// Call the logging method
+			callLoggerMethod(logger, tt.method, msg)
+
+			logOutput := output.String()
+			fmt.Println("Output:", logOutput)
+
+			if tt.wantOutput {
+				var loggedMessage map[string]any
+				err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+				if err != nil {
+					t.Fatalf("Error unmarshalling log message: %v\nLog output: %s", err, logOutput)
+				}
+
+				if !containsLogMessage(logOutput, tt.message) {
+					t.Errorf("Expected log message %q, but got %q", tt.message, logOutput)
+				}
+				assert.Equal(LevelNames[tt.messageLogLevel], loggedMessage["level"])
+				if tt.pairs != nil {
+					for k, v := range tt.pairs {
+						assert.Equal(v, loggedMessage[k])
+					}
+				}
+			} else {
+				assert.Equal("", logOutput)
+			}
+		})
+	}
+}
+
+func containsLogMessage(logOutput, expectedMessage string) bool {
+	return bytes.Contains([]byte(logOutput), []byte(expectedMessage))
+}
+
+func (suite *LoggerTestSuite) Test_SetFormat() {
+	logger := New().SetFormat(time.RFC3339Nano)
+
+	assert.Equal(time.RFC3339Nano, logger.format)
+}
+
+func (suite *LoggerTestSuite) Test_SetMinLogLevel() {
+	logger := New().SetMinLogLevel(LEVEL_DEBUG)
+
+	assert.Equal(LEVEL_DEBUG, logger.minLogLevel)
+}
+
+func (suite *LoggerTestSuite) Test_ShouldLog() {
+	logger := New().SetMinLogLevel(LEVEL_WARN)
+
+	assert.True(logger.shouldLog(LEVEL_WARN))
+	assert.True(logger.shouldLog(LEVEL_ERROR))
+	assert.False(logger.shouldLog(LEVEL_INFO))
+	assert.False(logger.shouldLog(LEVEL_DEBUG))
+}
+
+func (suite *LoggerTestSuite) Test_GetLogLevel() {
+	tests := []struct {
+		name     string
+		level    string
+		expected int
+	}{
+		{"debug level", "debug", LEVEL_DEBUG},
+		{"info level", "info", LEVEL_INFO},
+		{"warn level", "warn", LEVEL_WARN},
+		{"error level", "error", LEVEL_ERROR},
+		{"fatal level", "fatal", LEVEL_FATAL},
+		{"uppercase debug", "DEBUG", LEVEL_DEBUG},
+		{"mixed case warn", "WaRn", LEVEL_WARN},
+		{"unknown level", "unknown", defaultMinLevel},
+		{"empty string", "", defaultMinLevel},
+	}
+
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			result := GetLogLevel(tt.level)
+			assert.Equal(tt.expected, result)
+		})
+	}
+}
+
+func (suite *LoggerTestSuite) Test_Warning() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetMinLogLevel(LEVEL_WARN)
+
+	msg := &LogMessage{
+		Message: "warning message",
+		Pairs:   map[string]any{"key": "value"},
+	}
+
+	logger.Warning(msg)
+
+	logOutput := output.String()
+	fmt.Printf("DEBUG: logOutput = %q\n", logOutput)
+	fmt.Printf("DEBUG: logOutput length = %d\n", len(logOutput))
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	fmt.Printf("DEBUG: unmarshal error = %v\n", err)
+	fmt.Printf("DEBUG: loggedMessage = %+v\n", loggedMessage)
+	assert.NoError(err)
+	assert.Equal("warn", loggedMessage["level"])
+	assert.Equal("warning message", loggedMessage["message"])
+}
+
+func (suite *LoggerTestSuite) Test_Error() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetMinLogLevel(LEVEL_ERROR)
+
+	msg := &LogMessage{
+		Message: "error message",
+		Pairs:   map[string]any{"error": "test error"},
+	}
+
+	logger.Error(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+	assert.Equal("error", loggedMessage["level"])
+	assert.Equal("error message", loggedMessage["message"])
+	assert.Equal("test error", loggedMessage["error"])
+}
+
+func (suite *LoggerTestSuite) Test_Fatal() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetMinLogLevel(LEVEL_FATAL)
+
+	msg := &LogMessage{
+		Message: "fatal message",
+		Pairs:   map[string]any{"fatal": "test fatal"},
+	}
+
+	logger.Fatal(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+	assert.Equal("fatal", loggedMessage["level"])
+	assert.Equal("fatal message", loggedMessage["message"])
+	assert.Equal("test fatal", loggedMessage["fatal"])
+}
+
+func (suite *LoggerTestSuite) Test_SetFieldName() {
+	// Save original field names
+	originalFieldNames := make(map[string]string)
+	for k, v := range fieldNames {
+		originalFieldNames[k] = v
+	}
+
+	// Restore original field names after test
+	defer func() {
+		for k, v := range originalFieldNames {
+			fieldNames[k] = v
+		}
+	}()
+
+	logger := New()
+
+	// Test setting custom field names
+	logger.SetFieldName("timestamp", "time")
+	logger.SetFieldName("level", "severity")
+	logger.SetFieldName("message", "msg")
+
+	output := &bytes.Buffer{}
+	logger.SetOutput(output)
+
+	msg := &LogMessage{
+		Message: "test message",
+	}
+
+	logger.Info(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+
+	// Check that custom field names are used
+	assert.Contains(loggedMessage, "time")
+	assert.Contains(loggedMessage, "severity")
+	assert.Contains(loggedMessage, "msg")
+	assert.Equal("info", loggedMessage["severity"])
+	assert.Equal("test message", loggedMessage["msg"])
+}
+
+func (suite *LoggerTestSuite) Test_SetShowCaller() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetShowCaller(true)
+
+	msg := &LogMessage{
+		Message: "test message with caller",
+	}
+
+	logger.Info(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+
+	// Check that caller information is included
+	assert.Contains(loggedMessage, "caller")
+	caller, ok := loggedMessage["caller"].(string)
+	assert.True(ok)
+	assert.Contains(caller, "logger_test.go:")
+}
+
+func (suite *LoggerTestSuite) Test_GetCaller() {
+	// Test getCaller function indirectly through SetShowCaller
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetShowCaller(true).SetMinLogLevel(LEVEL_DEBUG)
+
+	msg := &LogMessage{
+		Message: "caller test",
+	}
+
+	logger.Debug(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+
+	caller, exists := loggedMessage["caller"]
+	assert.True(exists)
+	assert.NotEmpty(caller)
+
+	// Caller should be in format "file:line"
+	callerStr, ok := caller.(string)
+	assert.True(ok)
+	assert.Contains(callerStr, ":")
+}
+
+func (suite *LoggerTestSuite) Test_LogWithNilPairs() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output)
+
+	msg := &LogMessage{
+		Message: "message with nil pairs",
+		Pairs:   nil,
+	}
+
+	logger.Info(msg)
+
+	logOutput := output.String()
+	assert.NotEmpty(logOutput)
+
+	var loggedMessage map[string]any
+	err := json.Unmarshal([]byte(logOutput), &loggedMessage)
+	assert.NoError(err)
+	assert.Equal("info", loggedMessage["level"])
+	assert.Equal("message with nil pairs", loggedMessage["message"])
+}
+
+func (suite *LoggerTestSuite) Test_LogLevelFiltering() {
+	output := &bytes.Buffer{}
+	logger := New().SetOutput(output).SetMinLogLevel(LEVEL_WARN)
+
+	// These should not produce output (below minimum level)
+	logger.Debug(&LogMessage{Message: "debug message"})
+	logger.Info(&LogMessage{Message: "info message"})
+
+	debugInfoOutput := output.String()
+	assert.Empty(debugInfoOutput)
+
+	// These should produce output (at or above minimum level)
+	logger.Warn(&LogMessage{Message: "warn message"})
+	warnOutput := output.String()
+	assert.NotEmpty(warnOutput)
+	assert.Contains(warnOutput, "warn message")
+
+	output.Reset()
+	logger.Error(&LogMessage{Message: "error message"})
+	errorOutput := output.String()
+	assert.NotEmpty(errorOutput)
+	assert.Contains(errorOutput, "error message")
+
+	output.Reset()
+	logger.Fatal(&LogMessage{Message: "fatal message"})
+	fatalOutput := output.String()
+	assert.NotEmpty(fatalOutput)
+	assert.Contains(fatalOutput, "fatal message")
+}

main.go

@@ -0,0 +1,45 @@
+package gql
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gookit/goutil/envutil"
+	cache "github.com/lukaszraczylo/go-simple-graphql/cache"
+	logging "github.com/lukaszraczylo/go-simple-graphql/logging"
+)
+
+func NewConnection() (b *BaseClient) {
+	b = &BaseClient{
+		endpoint:       envutil.Getenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql"),
+		responseType:   envutil.Getenv("GRAPHQL_OUTPUT", "string"),
+		Logger:         logging.New(),
+		cache:          cache.New(time.Duration(envutil.GetInt("GRAPHQL_CACHE_TTL", 5)) * time.Second),
+		cache_global:   envutil.GetBool("GRAPHQL_CACHE_ENABLED", false),
+		retries_enable: envutil.GetBool("GRAPHQL_RETRIES_ENABLE", false),
+		retries_delay:  time.Duration(envutil.GetInt("GRAPHQL_RETRIES_DELAY", 250) * int(time.Millisecond)),
+		retries_number: envutil.GetInt("GRAPHQL_RETRIES_NUMBER", 3),
+	}
+	b.client = b.createHttpClient()
+	b.Logger.Debug(&logging.LogMessage{
+		Message: "Created new GraphQL client connection",
+		Pairs: map[string]interface{}{
+			"values": b,
+		}})
+	return b
+}
+
+func (b *BaseClient) SetEndpoint(endpoint string) {
+	b.endpoint = endpoint
+}
+
+func (b *BaseClient) SetOutput(responseType string) {
+	// allowed are byte, string, mapstring
+	// check if responseType is allowed
+	// TODO: implement
+	b.responseType = responseType
+}
+
+func (b *BaseClient) SetHTTPClient(client *http.Client) {
+	b.client = client
+}

main_bench_test.go

@@ -0,0 +1,9 @@
+package gql
+
+import "testing"
+
+func Benchmark_newConnection(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		NewConnection()
+	}
+}

main_test.go

@@ -0,0 +1,21 @@
+package gql
+
+import (
+	"testing"
+)
+
+func (suite *Tests) TestNewConnection() {
+	tests := []struct {
+		name string
+	}{
+		{
+			name: "TestNewConnection",
+		},
+	}
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			got := NewConnection()
+			assert.NotNil(suite.T(), got)
+		})
+	}
+}

mock_server.go

@@ -0,0 +1,67 @@
+// mock_server.go
+package gql
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+
+	"golang.org/x/net/http2"
+)
+
+func StartMockServer() *httptest.Server {
+	// Create your handler
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Your existing handler code
+		bodyBytes, err := io.ReadAll(r.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		var req struct {
+			Variables map[string]interface{} `json:"variables"`
+			Query     string                 `json:"query"`
+		}
+		err = json.Unmarshal(bodyBytes, &req)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+
+		// Simple validation to check for unbalanced braces as a syntax error
+		if !strings.HasPrefix(strings.TrimSpace(req.Query), "query") || !strings.HasSuffix(strings.TrimSpace(req.Query), "}") {
+			resp := []byte(`{"errors":[{"message":"Syntax Error: Invalid query"}]}`)
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write(resp)
+			return
+		}
+
+		var resp []byte
+		if strings.Contains(req.Query, "viewer") {
+			resp = []byte(`{"data":{"viewer":{"login":"mockuser"}}}`)
+		} else if strings.Contains(req.Query, "dragons") {
+			resp = []byte(`{"data":{"dragons":[{"name":"Mock Dragon 1"},{"name":"Mock Dragon 2"}]}}`)
+		} else {
+			resp = []byte(`{"errors":[{"message":"Unknown query"}]}`)
+			w.WriteHeader(http.StatusBadRequest)
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(resp)
+	})
+
+	// Create an unstarted server
+	server := httptest.NewUnstartedServer(handler)
+
+	// Configure the server to support HTTP/2
+	http2.ConfigureServer(server.Config, &http2.Server{})
+	server.TLS = server.Config.TLSConfig
+
+	// Start the server with TLS
+	server.StartTLS()
+	return server
+}

performance_regression_test.go

@@ -0,0 +1,158 @@
+package gql
+
+import (
+	"testing"
+	"time"
+
+	cache "github.com/lukaszraczylo/go-simple-graphql/cache"
+)
+
+// Performance regression tests to ensure optimizations maintain their benefits
+func TestPerformanceRegression(t *testing.T) {
+	// Test hash performance
+	t.Run("HashPerformance", func(t *testing.T) {
+		query := &Query{
+			Query: "query GetUser($id: ID!) { user(id: $id) { id name email } }",
+			Variables: map[string]interface{}{
+				"id": "12345",
+			},
+			JsonQuery: []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { id name email } }","variables":{"id":"12345"}}`),
+		}
+
+		start := time.Now()
+		for i := 0; i < 10000; i++ {
+			_ = calculateHash(query)
+		}
+		duration := time.Since(start)
+
+		// Should complete 10k hashes in under 25ms (accounts for race detection + coverage overhead)
+		if duration > 25*time.Millisecond {
+			t.Errorf("Hash performance regression: 10k hashes took %v, expected < 25ms", duration)
+		}
+	})
+
+	// Test buffer pool performance
+	t.Run("BufferPoolPerformance", func(t *testing.T) {
+		start := time.Now()
+		for i := 0; i < 10000; i++ {
+			buf := getBuffer(1024)
+			buf.WriteString("test data")
+			putBuffer(buf)
+		}
+		duration := time.Since(start)
+
+		// Should complete 10k buffer operations in under 25ms (accounts for race detection + coverage overhead)
+		if duration > 25*time.Millisecond {
+			t.Errorf("Buffer pool performance regression: 10k operations took %v, expected < 25ms", duration)
+		}
+	})
+
+	// Test cache performance
+	t.Run("CachePerformance", func(t *testing.T) {
+		c := cache.New(5 * time.Second) // Use shorter TTL for tests
+		defer c.Stop()
+
+		testData := make([]byte, 512) // Small data that won't be compressed
+		for i := range testData {
+			testData[i] = byte(i % 256)
+		}
+
+		start := time.Now()
+		for i := 0; i < 10000; i++ {
+			key := "key" + string(rune(i%100))
+			c.Set(key, testData, time.Minute)
+			_, _ = c.Get(key)
+		}
+		duration := time.Since(start)
+
+		// Should complete 10k cache operations in under 50ms
+		if duration > 50*time.Millisecond {
+			t.Errorf("Cache performance regression: 10k operations took %v, expected < 50ms", duration)
+		}
+	})
+
+	// Test processFlags performance
+	t.Run("ProcessFlagsPerformance", func(t *testing.T) {
+		variables := map[string]interface{}{
+			"id":         "123",
+			"gqlcache":   true,
+			"gqlretries": true,
+		}
+		headers := map[string]interface{}{}
+
+		start := time.Now()
+		for i := 0; i < 10000; i++ {
+			_, _, _ = processFlags(variables, headers)
+		}
+		duration := time.Since(start)
+
+		// Should complete 10k flag processing operations in under 30ms (accounts for race detection + coverage overhead)
+		if duration > 30*time.Millisecond {
+			t.Errorf("ProcessFlags performance regression: 10k operations took %v, expected < 30ms", duration)
+		}
+	})
+
+	// Test query compilation performance
+	t.Run("QueryCompilationPerformance", func(t *testing.T) {
+		client := CreateTestClient()
+
+		query := "query GetUser($id: ID!) { user(id: $id) { id name email } }"
+		variables := map[string]interface{}{"id": "123"}
+
+		start := time.Now()
+		for i := 0; i < 1000; i++ {
+			_ = client.compileQuery(query, variables)
+		}
+		duration := time.Since(start)
+
+		// Should complete 1k query compilations in under 50ms
+		if duration > 50*time.Millisecond {
+			t.Errorf("Query compilation performance regression: 1k operations took %v, expected < 50ms", duration)
+		}
+	})
+}
+
+// Benchmark comprehensive workflow to ensure no regression
+func BenchmarkComprehensiveWorkflow(b *testing.B) {
+	client := CreateTestClient()
+
+	query := "query GetUser($id: ID!) { user(id: $id) { id name email profile { avatar bio } } }"
+	variables := map[string]interface{}{
+		"id":         "123",
+		"gqlcache":   true,
+		"gqlretries": true,
+	}
+	headers := map[string]interface{}{}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// Process flags
+		enableCache, enableRetries, cleanedVariables := processFlags(variables, headers)
+
+		// Compile query
+		compiledQuery := client.compileQuery(query, cleanedVariables)
+
+		// Calculate hash
+		if enableCache {
+			_ = calculateHash(compiledQuery)
+		}
+
+		// Use variables to avoid optimization
+		_ = enableRetries
+	}
+}
+
+// Memory allocation benchmark
+func BenchmarkMemoryAllocations(b *testing.B) {
+	client := CreateTestClient()
+
+	query := "query GetUser($id: ID!) { user(id: $id) { id name } }"
+	variables := map[string]interface{}{"id": "123"}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		compiledQuery := client.compileQuery(query, variables)
+		_ = calculateHash(compiledQuery)
+	}
+}

pools.go

@@ -0,0 +1,74 @@
+package gql
+
+import (
+	"bytes"
+	"sync"
+)
+
+var (
+	// Tiered buffer pools for different size requirements
+	smallBufferPool = sync.Pool{
+		New: func() interface{} {
+			// Small buffers for typical GraphQL queries (1KB)
+			b := bytes.NewBuffer(make([]byte, 0, 1024))
+			return b
+		},
+	}
+
+	mediumBufferPool = sync.Pool{
+		New: func() interface{} {
+			// Medium buffers for larger queries (4KB)
+			b := bytes.NewBuffer(make([]byte, 0, 4096))
+			return b
+		},
+	}
+
+	largeBufferPool = sync.Pool{
+		New: func() interface{} {
+			// Large buffers for very large queries (16KB)
+			b := bytes.NewBuffer(make([]byte, 0, 16384))
+			return b
+		},
+	}
+
+	// Backward compatibility - use medium pool as default
+	bufferPool *sync.Pool
+
+	// Pre-allocate error maps to reduce allocations
+	errPairsPool = sync.Pool{
+		New: func() interface{} {
+			return make(map[string]interface{}, 1)
+		},
+	}
+)
+
+func init() {
+	bufferPool = &mediumBufferPool
+}
+
+// getBuffer returns an appropriately sized buffer based on estimated size
+func getBuffer(estimatedSize int) *bytes.Buffer {
+	switch {
+	case estimatedSize <= 1024:
+		return smallBufferPool.Get().(*bytes.Buffer)
+	case estimatedSize <= 4096:
+		return mediumBufferPool.Get().(*bytes.Buffer)
+	default:
+		return largeBufferPool.Get().(*bytes.Buffer)
+	}
+}
+
+// putBuffer returns a buffer to the appropriate pool based on its capacity
+func putBuffer(buf *bytes.Buffer) {
+	buf.Reset()
+	capacity := buf.Cap()
+
+	switch {
+	case capacity <= 1024:
+		smallBufferPool.Put(buf)
+	case capacity <= 4096:
+		mediumBufferPool.Put(buf)
+	default:
+		largeBufferPool.Put(buf)
+	}
+}

query.go

@@ -1,117 +1,184 @@
 package gql
 
 import (
-	"context"
-
-	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
+	"fmt"
 
+	"github.com/goccy/go-json"
+	"github.com/gookit/goutil"
 	"github.com/gookit/goutil/strutil"
-
-	jsoniter "github.com/json-iterator/go"
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
 )
 
-var json = jsoniter.ConfigCompatibleWithStandardLibrary
+func (b *BaseClient) convertToJSON(v any) []byte {
+	// Estimate size based on query structure for better buffer selection
+	estimatedSize := 512 // Base size
+	if query, ok := v.(*Query); ok {
+		estimatedSize += len(query.Query)
+		if query.Variables != nil {
+			estimatedSize += len(query.Variables) * 50 // Rough estimate per variable
+		}
+	}
 
-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())
+	buf := getBuffer(estimatedSize)
+	defer putBuffer(buf)
+
+	// Use json.NewEncoder for better performance with buffers
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(false) // Reduce unnecessary escaping
+
+	if err := enc.Encode(v); err != nil {
+		errPairs := errPairsPool.Get().(map[string]interface{})
+		errPairs["error"] = err.Error()
+		b.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't convert to JSON",
+			Pairs:   errPairs,
+		})
+		errPairsPool.Put(errPairs)
 		return nil
 	}
-	return json
+
+	// Get the buffer bytes directly, trimming the trailing newline
+	bytes := buf.Bytes()
+	if len(bytes) > 0 && bytes[len(bytes)-1] == '\n' {
+		bytes = bytes[:len(bytes)-1]
+	}
+
+	// Make a copy of the bytes since the buffer will be reused
+	result := make([]byte, len(bytes))
+	copy(result, bytes)
+	return result
 }
 
-func (c *BaseClient) NewQuery(q ...any) *Query {
-	query := &Query{}
+func processFlags(variables map[string]interface{}, headers map[string]interface{}) (enableCache, enableRetries bool, cleanedVariables map[string]interface{}) {
+	// Start with original variables
+	cleanedVariables = variables
 
-	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
+	// Check headers first
+	enableCache, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlcache"))
+	enableRetries, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlretries"))
+
+	// Check variables and clean them if needed
+	if variables != nil {
+		varEnableCache, _ := goutil.ToBool(searchForKeysInMapStringInterface(variables, "gqlcache"))
+		varEnableRetries, _ := goutil.ToBool(searchForKeysInMapStringInterface(variables, "gqlretries"))
+
+		enableCache = enableCache || varEnableCache
+		enableRetries = enableRetries || varEnableRetries
+
+		// Clean variables if flags are present (regardless of their value)
+		_, hasCacheFlag := variables["gqlcache"]
+		_, hasRetriesFlag := variables["gqlretries"]
+
+		if hasCacheFlag || hasRetriesFlag {
+			cleanedVariables = make(map[string]interface{})
+			for k, v := range variables {
+				if k != "gqlcache" && k != "gqlretries" {
+					cleanedVariables[k] = v
+				}
 			}
 		}
 	}
 
-	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
+	return enableCache, enableRetries, cleanedVariables
 }
 
-// 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 (b *BaseClient) compileQuery(queryPartials ...any) *Query {
+	var query string
+	var variables map[string]interface{}
 
-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
-
-	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")
+	// Pre-allocate the query with an estimated size
+	if len(queryPartials) > 0 {
+		if str, ok := queryPartials[0].(string); ok {
+			query = str
 		}
 	}
 
-	response, err := c.executeQuery(query.compiledQuery, queryHeaders)
-	if err != nil {
-		c.Logger.Error(c, "Error while executing query;", "error", err.Error())
-		return nil, err
+	// Only allocate variables map if we have more than one partial
+	if len(queryPartials) > 1 {
+		if vars, ok := queryPartials[1].(map[string]interface{}); ok {
+			variables = vars
+		}
 	}
 
-	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)
-	}
-
-	return c.decodeResponse(jsonData), err
-}
-
-func (c *BaseClient) decodeResponse(jsonData []byte) any {
-	switch c.responseType {
-	case "string":
-		return helpers.BytesToString(jsonData)
-	case "byte":
-		return jsonData
-	default:
-		c.Logger.Error(c, "Unknown response type", "response", c.responseType)
+	if query == "" {
+		errPairs := errPairsPool.Get().(map[string]interface{})
+		errPairs["error"] = "query is empty"
+		b.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't compile query",
+			Pairs:   errPairs,
+		})
+		errPairsPool.Put(errPairs)
 		return nil
 	}
+
+	// Construct query object once
+	q := &Query{
+		Query:     query,
+		Variables: variables,
+	}
+	q.JsonQuery = b.convertToJSON(q)
+	return q
+}
+
+func (b *BaseClient) Query(query string, variables map[string]interface{}, headers map[string]interface{}) (any, error) {
+	// Process flags before compilation to avoid recompilation
+	enableCache, enableRetries, cleanedVariables := processFlags(variables, headers)
+
+	// Compile query once with cleaned variables
+	compiledQuery := b.compileQuery(query, cleanedVariables)
+	if compiledQuery == nil || compiledQuery.JsonQuery == nil {
+		b.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't compile query",
+			Pairs:   map[string]interface{}{"error": "query is empty"},
+		})
+		return nil, fmt.Errorf("can't compile query")
+	}
+	b.Logger.Debug(&libpack_logger.LogMessage{
+		Message: "Compiled query",
+		Pairs:   map[string]interface{}{"query": compiledQuery},
+	})
+
+	var queryHash string
+	if (enableCache || b.cache_global) && strutil.HasPrefix(compiledQuery.Query, "query") {
+		b.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache enabled",
+			Pairs:   nil,
+		})
+		queryHash = calculateHash(compiledQuery)
+		if cachedValue := b.cacheLookup(queryHash); cachedValue != nil {
+			b.Logger.Debug(&libpack_logger.LogMessage{
+				Message: "Cache hit",
+				Pairs:   map[string]interface{}{"query": compiledQuery},
+			})
+			return b.decodeResponse(cachedValue)
+		}
+		b.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache miss",
+			Pairs:   map[string]interface{}{"query": compiledQuery},
+		})
+	}
+
+	q := &QueryExecutor{
+		BaseClient: b,
+		Query:      compiledQuery.JsonQuery,
+		Headers:    headers,
+		CacheKey: func() string {
+			if queryHash != "" {
+				return queryHash
+			}
+			return "no-cache"
+		}(),
+		Retries: enableRetries || b.retries_enable,
+	}
+
+	rv, err := q.executeQuery()
+	if err != nil {
+		b.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Error executing query",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
+		return nil, err
+	}
+
+	return b.decodeResponse(rv)
 }

query_bench_test.go

@@ -0,0 +1,99 @@
+package gql
+
+import (
+	"testing"
+)
+
+func Benchmark_compileQuery(bn *testing.B) {
+	b := NewConnection()
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		b.compileQuery(
+			`query { viewer { login } }`,
+		)
+	}
+}
+
+func Benchmark_compileQueryWithVariables(bn *testing.B) {
+	b := NewConnection()
+	variables := map[string]interface{}{
+		"var1": "value1",
+	}
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		b.compileQuery(
+			`query { viewer { login } }`,
+			variables,
+		)
+	}
+}
+
+func Benchmark_convertToJson(bn *testing.B) {
+	b := NewConnection()
+	query := `query { viewer { login } }`
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		b.convertToJSON(query)
+	}
+}
+func Benchmark_Query(bn *testing.B) {
+	mockServer := StartMockServer()
+	bn.Cleanup(func() {
+		mockServer.Close()
+	})
+
+	b := NewConnection()
+	b.SetEndpoint(mockServer.URL)
+	query := "query { viewer { login } }"
+	variables := map[string]interface{}{
+		"var1": "value1",
+	}
+	headers := map[string]interface{}{
+		"Authorization": "Bearer token",
+		"gqlcache":      "true",
+	}
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		_, _ = b.Query(query, variables, headers)
+	}
+}
+
+func Benchmark_QueryNoCacheNoRetry(bn *testing.B) {
+	mockServer := StartMockServer()
+	bn.Cleanup(func() {
+		mockServer.Close()
+	})
+
+	b := NewConnection()
+	b.SetEndpoint(mockServer.URL)
+	query := `query { viewer { login } }`
+	variables := map[string]interface{}{
+		"var1": "value1",
+	}
+	headers := map[string]interface{}{
+		"Authorization": "Bearer token",
+	}
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		_, _ = b.Query(query, variables, headers)
+	}
+}
+
+func Benchmark_QueryWithEmptyVariables(bn *testing.B) {
+	mockServer := StartMockServer()
+	bn.Cleanup(func() {
+		mockServer.Close()
+	})
+
+	b := NewConnection()
+	b.SetEndpoint(mockServer.URL)
+	query := `query { viewer { login } }`
+	headers := map[string]interface{}{
+		"Authorization": "Bearer token",
+		"gqlcache":      "true",
+	}
+	bn.ResetTimer()
+	for i := 0; i < bn.N; i++ {
+		_, _ = b.Query(query, nil, headers)
+	}
+}

query_optimization_test.go

@@ -0,0 +1,196 @@
+package gql
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type QueryOptimizationTestSuite struct {
+	suite.Suite
+	client *BaseClient
+}
+
+func (suite *QueryOptimizationTestSuite) SetupTest() {
+	suite.client = CreateTestClient()
+}
+
+func (suite *QueryOptimizationTestSuite) TearDownTest() {
+	// No need to stop shared cache - it will be cleaned up globally
+}
+
+func (suite *QueryOptimizationTestSuite) TestProcessFlags() {
+	tests := []struct {
+		name             string
+		variables        map[string]interface{}
+		headers          map[string]interface{}
+		expectedCache    bool
+		expectedRetries  bool
+		expectedVarCount int
+	}{
+		{
+			name:             "No flags",
+			variables:        map[string]interface{}{"id": "123"},
+			headers:          map[string]interface{}{},
+			expectedCache:    false,
+			expectedRetries:  false,
+			expectedVarCount: 1,
+		},
+		{
+			name:             "Cache flag in headers",
+			variables:        map[string]interface{}{"id": "123"},
+			headers:          map[string]interface{}{"gqlcache": true},
+			expectedCache:    true,
+			expectedRetries:  false,
+			expectedVarCount: 1,
+		},
+		{
+			name:             "Retries flag in headers",
+			variables:        map[string]interface{}{"id": "123"},
+			headers:          map[string]interface{}{"gqlretries": true},
+			expectedCache:    false,
+			expectedRetries:  true,
+			expectedVarCount: 1,
+		},
+		{
+			name:             "Cache flag in variables",
+			variables:        map[string]interface{}{"id": "123", "gqlcache": true},
+			headers:          map[string]interface{}{},
+			expectedCache:    true,
+			expectedRetries:  false,
+			expectedVarCount: 1, // gqlcache should be removed
+		},
+		{
+			name:             "Retries flag in variables",
+			variables:        map[string]interface{}{"id": "123", "gqlretries": true},
+			headers:          map[string]interface{}{},
+			expectedCache:    false,
+			expectedRetries:  true,
+			expectedVarCount: 1, // gqlretries should be removed
+		},
+		{
+			name:             "Both flags in variables",
+			variables:        map[string]interface{}{"id": "123", "gqlcache": true, "gqlretries": true},
+			headers:          map[string]interface{}{},
+			expectedCache:    true,
+			expectedRetries:  true,
+			expectedVarCount: 1, // both flags should be removed
+		},
+		{
+			name:             "Flags in both headers and variables",
+			variables:        map[string]interface{}{"id": "123", "gqlcache": false},
+			headers:          map[string]interface{}{"gqlcache": true, "gqlretries": true},
+			expectedCache:    true, // header value OR variable value
+			expectedRetries:  true,
+			expectedVarCount: 1, // gqlcache should be removed from variables
+		},
+		{
+			name:             "Nil variables",
+			variables:        nil,
+			headers:          map[string]interface{}{"gqlcache": true},
+			expectedCache:    true,
+			expectedRetries:  false,
+			expectedVarCount: 0,
+		},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			enableCache, enableRetries, cleanedVariables := processFlags(tt.variables, tt.headers)
+
+			suite.Equal(tt.expectedCache, enableCache, "Cache flag mismatch")
+			suite.Equal(tt.expectedRetries, enableRetries, "Retries flag mismatch")
+
+			if tt.expectedVarCount == 0 {
+				suite.Nil(cleanedVariables, "Variables should be nil")
+			} else {
+				suite.Len(cleanedVariables, tt.expectedVarCount, "Variable count mismatch")
+				suite.NotContains(cleanedVariables, "gqlcache", "gqlcache should be removed")
+				suite.NotContains(cleanedVariables, "gqlretries", "gqlretries should be removed")
+			}
+		})
+	}
+}
+
+func (suite *QueryOptimizationTestSuite) TestDoubleCompilationFix() {
+	// Test that query is only compiled once even with flags in variables
+	query := "query GetUser($id: ID!) { user(id: $id) { id name } }"
+	variables := map[string]interface{}{
+		"id":         "123",
+		"gqlcache":   true,
+		"gqlretries": true,
+	}
+
+	// This should not cause double compilation
+	compiledQuery := suite.client.compileQuery(query, variables)
+	suite.NotNil(compiledQuery)
+	suite.Equal(query, compiledQuery.Query)
+
+	// Variables should still contain the flags at this point (they're cleaned in Query method)
+	suite.Contains(compiledQuery.Variables, "gqlcache")
+	suite.Contains(compiledQuery.Variables, "gqlretries")
+}
+
+func (suite *QueryOptimizationTestSuite) TestQueryMethodOptimization() {
+	// Test that processFlags works correctly without making HTTP requests
+	variables := map[string]interface{}{
+		"id":         "123",
+		"gqlcache":   true,
+		"gqlretries": true,
+	}
+	headers := map[string]interface{}{}
+
+	// Test processFlags directly
+	enableCache, enableRetries, cleanedVariables := processFlags(variables, headers)
+
+	suite.True(enableCache, "Cache should be enabled")
+	suite.True(enableRetries, "Retries should be enabled")
+	suite.Len(cleanedVariables, 1, "Should have only id variable")
+	suite.Equal("123", cleanedVariables["id"], "ID should be preserved")
+	suite.NotContains(cleanedVariables, "gqlcache", "gqlcache should be removed")
+	suite.NotContains(cleanedVariables, "gqlretries", "gqlretries should be removed")
+}
+
+// Benchmark the optimization impact
+func BenchmarkQueryCompilation(b *testing.B) {
+	client := CreateTestClient()
+
+	query := "query GetUser($id: ID!) { user(id: $id) { id name email profile { avatar bio } } }"
+
+	b.Run("WithoutFlags", func(b *testing.B) {
+		variables := map[string]interface{}{"id": "123"}
+		headers := map[string]interface{}{}
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			processFlags(variables, headers)
+		}
+	})
+
+	b.Run("WithFlags", func(b *testing.B) {
+		variables := map[string]interface{}{
+			"id":         "123",
+			"gqlcache":   true,
+			"gqlretries": true,
+		}
+		headers := map[string]interface{}{}
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			processFlags(variables, headers)
+		}
+	})
+
+	b.Run("CompileQuery", func(b *testing.B) {
+		variables := map[string]interface{}{"id": "123"}
+
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			client.compileQuery(query, variables)
+		}
+	})
+}
+
+func TestQueryOptimizationSuite(t *testing.T) {
+	suite.Run(t, new(QueryOptimizationTestSuite))
+}

query_test.go

@@ -1,291 +1,429 @@
 package gql
 
 import (
-	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/goccy/go-reflect"
 )
 
-func TestBaseClient_convertToJson(t *testing.T) {
-	type fields struct {
-	}
+func (suite *Tests) TestBaseClient_convertToJSON() {
 	type args struct {
 		v any
 	}
 	tests := []struct {
-		name   string
-		fields fields
-		args   args
-		want   []byte
+		name string
+		args args
+		want []byte
 	}{
 		{
-			name:   "Test convertToJson",
-			fields: fields{},
+			name: "TestBaseClient_convertToJSON_query",
 			args: args{
-				v: map[string]interface{}{
-					"query": "query { hello }",
-				},
+				v: `query { viewer { login } }`,
 			},
-			want: []byte(`{"query":"query { hello }"}`),
+			want: []byte(`"query { viewer { login } }"`),
 		},
 		{
-			name:   "Test convertToJson with variables",
-			fields: fields{},
+			name: "TestBaseClient_convertToJSON_variables",
 			args: args{
 				v: map[string]interface{}{
-					"query":     "query { hello }",
-					"variables": map[string]interface{}{"name": "John"},
+					"login": "lukaszraczylo",
+					"first": 10,
 				},
 			},
-			want: []byte(`{"query":"query { hello }","variables":{"name":"John"}}`),
+			want: []byte(`{"first":10,"login":"lukaszraczylo"}`),
 		},
 	}
 	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)
+		suite.T().Run(tt.name, func(t *testing.T) {
+			b := NewConnection()
+			if got := b.convertToJSON(tt.args.v); !reflect.DeepEqual(got, tt.want) {
+				assert.Equal(tt.want, got)
 			}
 		})
 	}
 }
 
-func TestBaseClient_NewQuery(t *testing.T) {
-	type fields struct {
-	}
+func (suite *Tests) TestBaseClient_compileQuery() {
 	type args struct {
-		q []any
+		query_partials []any
 	}
 	tests := []struct {
-		fields fields
-		want   *Query
-		name   string
-		args   args
+		wantQ *Query
+		name  string
+		args  args
 	}{
 		{
-			name:   "Test NewQuery",
-			fields: fields{},
+			name: "TestBaseClient_compileQuery_query",
 			args: args{
-				q: []any{
-					"query { hello }",
+				query_partials: []any{
+					`query { viewer { login } }`,
 				},
 			},
-			want: &Query{
-				compiledQuery: []byte(`{"variables":null,"query":"query { hello }"}`),
+			wantQ: &Query{
+				Query:     `query { viewer { login } }`,
+				JsonQuery: []byte(`{"query":"query { viewer { login } }"}`),
 			},
 		},
 		{
-			name:   "Test NewQuery with variables",
-			fields: fields{},
+			name: "TestBaseClient_compileQuery_with_variables",
 			args: args{
-				q: []any{
-					"query { hello }",
-					map[string]interface{}{"name": "John"},
+				query_partials: []any{
+					`query { viewer { login } }`,
+					map[string]interface{}{
+						"login": "lukaszraczylo",
+						"first": 10,
+					},
 				},
 			},
-			want: &Query{
-				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query { hello }"}`),
+			wantQ: &Query{
+				Query: `query { viewer { login } }`,
+				Variables: map[string]interface{}{
+					"login": "lukaszraczylo",
+					"first": 10,
+				},
+				JsonQuery: []byte(`{"variables":{"first":10,"login":"lukaszraczylo"},"query":"query { viewer { login } }"}`),
 			},
 		},
+		{
+			name: "TestBaseClient_compileQuery_variables_without_query",
+			args: args{
+				query_partials: []any{
+					map[string]interface{}{
+						"login": "lukaszraczylo",
+						"first": 10,
+					},
+				},
+			},
+			wantQ: nil,
+		},
 	}
 	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)
+		suite.T().Run(tt.name, func(t *testing.T) {
+			b := NewConnection()
+			got := b.compileQuery(tt.args.query_partials...)
+			assert.Equal(tt.wantQ, got)
 		})
 	}
 }
 
-func TestBaseClient_decodeResponse(t *testing.T) {
-	type fields struct {
-		responseType string
-	}
+func (suite *Tests) TestBaseClient_Query() {
 	type args struct {
-		jsonData []byte
+		variables map[string]interface{}
+		headers   map[string]interface{}
+		query     string
 	}
 	tests := []struct {
-		fields fields
-		want   any
-		name   string
-		args   args
+		args               args
+		wantReturned_value any
+		name               string
+		wantType           string
+		wantErr            bool
 	}{
 		{
-			name: "Test decodeResponse - string",
-			fields: fields{
-				responseType: "string",
-			},
+			name: "TestBaseClient_Query_viewer",
 			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
-		name    string
-		fields  fields
-		wantErr bool
-	}{
-		{
-			name: "Test Query - failing",
-			fields: fields{
-				graphql_endpoint: "https://spacex-production.up.railway.app/",
-			},
-			args: args{
-				queryContent: "query { hello }",
-			},
-			want:    ``,
-			wantErr: true,
-		},
-		{
-			name: "Test Query - success",
-			fields: fields{
-				graphql_endpoint: "https://spacex-production.up.railway.app/",
-			},
-			args: args{
-				queryContent: `query Dragons {
-					dragons {
-						name
-					}
-				}`,
-				queryHeaders: map[string]interface{}{
-					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+				query:     "query { viewer { login } }",
+				variables: nil,
+				headers: map[string]interface{}{
+					"x-apollo-operation-name": "ViewerQuery",
 					"content-type":            "application/json",
 				},
 			},
-			wantErr: false,
-			want:    `{"dragons":[{"name":"Dragon 1"},{"name":"Dragon 2"}]}`,
+			wantReturned_value: `{"viewer":{"login":"mockuser"}}`, // Adjusted expected value
+			wantErr:            false,
 		},
 		{
-			name: "Test Query - success",
-			fields: fields{
-				repeat:           2,
-				graphql_endpoint: "https://spacex-production.up.railway.app/",
-			},
+			name: "TestBaseClient_Query_dragons",
 			args: args{
-				queryContent: `query Dragons {
-					dragons {
-						name
-						first_flight
-					}
-				}`,
-				queryHeaders: map[string]interface{}{
-					"x-apollo-operation-name": "Missions-Potato-Test-Golang-Cached",
+				query: `query Dragons {
+													dragons {
+																	name
+													}
+									}`,
+				variables: nil,
+				headers: map[string]interface{}{
+					"x-apollo-operation-name": "DragonsQuery",
 					"content-type":            "application/json",
 				},
 			},
-			wantErr: false,
-			want:    `{"dragons":[{"first_flight":"2010-12-08","name":"Dragon 1"},{"first_flight":"2019-03-02","name":"Dragon 2"}]}`,
+			wantReturned_value: `{"dragons":[{"name":"Mock Dragon 1"},{"name":"Mock Dragon 2"}]}`, // Adjusted expected value
+			wantErr:            false,
+		},
+
+		{
+			name: "TestBaseClient_Query_invalid_query",
+			args: args{
+				query:     "query { potato { login } ",
+				variables: nil,
+				headers: map[string]interface{}{
+					"x-apollo-operation-name": "InvalidQuery",
+					"content-type":            "application/json",
+				},
+			},
+			wantReturned_value: nil,
+			wantErr:            true,
 		},
 	}
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			c := NewConnection()
-
-			if tt.fields.graphql_endpoint != "" {
-				c.endpoint = tt.fields.graphql_endpoint
+		suite.T().Run(tt.name, func(t *testing.T) {
+			b := NewConnection()
+			b.SetEndpoint(mockServer.URL)
+			b.SetHTTPClient(mockServer.Client())
+			if tt.wantType != "" {
+				b.SetOutput(tt.wantType)
 			}
-
-			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)
-				}
+			gotReturned_value, err := b.Query(tt.args.query, tt.args.variables, tt.args.headers)
+			if tt.wantErr {
+				assert.Error(err)
+			} else {
+				assert.NoError(err)
 			}
+			assert.Equal(tt.wantReturned_value, gotReturned_value)
 		})
 	}
 }
 
-/// benchmarks
+func (suite *Tests) TestBaseClient_convertToJSON_errors() {
+	suite.T().Run("should handle JSON encoding errors", func(t *testing.T) {
+		b := NewConnection()
 
-func BenchmarkBaseClient_convertToJson(b *testing.B) {
-	c := NewConnection()
-	query := c.NewQuery("query { hello }")
-	for i := 0; i < b.N; i++ {
-		_ = c.convertToJson(query)
+		// Test with a value that can't be JSON encoded (function)
+		result := b.convertToJSON(func() {})
+		assert.Nil(result)
+	})
+
+	suite.T().Run("should handle Query type with variables", func(t *testing.T) {
+		b := NewConnection()
+
+		query := &Query{
+			Query: "query { test }",
+			Variables: map[string]interface{}{
+				"var1": "value1",
+				"var2": 123,
+			},
+		}
+
+		result := b.convertToJSON(query)
+		assert.NotNil(result)
+		assert.Contains(string(result), "query { test }")
+		assert.Contains(string(result), "var1")
+		assert.Contains(string(result), "value1")
+	})
+}
+
+func (suite *Tests) TestBaseClient_compileQuery_errors() {
+	suite.T().Run("should handle empty query", func(t *testing.T) {
+		b := NewConnection()
+
+		result := b.compileQuery("")
+		assert.Nil(result)
+	})
+
+	suite.T().Run("should handle no arguments", func(t *testing.T) {
+		b := NewConnection()
+
+		result := b.compileQuery()
+		assert.Nil(result)
+	})
+
+	suite.T().Run("should handle invalid variable type", func(t *testing.T) {
+		b := NewConnection()
+
+		result := b.compileQuery("query { test }", "invalid_variables")
+		assert.NotNil(result)
+		assert.Equal("query { test }", result.Query)
+		assert.Nil(result.Variables)
+	})
+}
+
+func (suite *Tests) Test_processFlags() {
+	tests := []struct {
+		name            string
+		variables       map[string]interface{}
+		headers         map[string]interface{}
+		wantCache       bool
+		wantRetries     bool
+		wantCleanedVars map[string]interface{}
+	}{
+		{
+			name:      "cache enabled in headers",
+			variables: nil,
+			headers: map[string]interface{}{
+				"gqlcache": true,
+			},
+			wantCache:       true,
+			wantRetries:     false,
+			wantCleanedVars: nil,
+		},
+		{
+			name:      "retries enabled in headers",
+			variables: nil,
+			headers: map[string]interface{}{
+				"gqlretries": true,
+			},
+			wantCache:       false,
+			wantRetries:     true,
+			wantCleanedVars: nil,
+		},
+		{
+			name: "cache enabled in variables",
+			variables: map[string]interface{}{
+				"gqlcache": true,
+				"test":     "value",
+			},
+			headers:     nil,
+			wantCache:   true,
+			wantRetries: false,
+			wantCleanedVars: map[string]interface{}{
+				"test": "value",
+			},
+		},
+		{
+			name: "retries enabled in variables",
+			variables: map[string]interface{}{
+				"gqlretries": true,
+				"test":       "value",
+			},
+			headers:     nil,
+			wantCache:   false,
+			wantRetries: true,
+			wantCleanedVars: map[string]interface{}{
+				"test": "value",
+			},
+		},
+		{
+			name: "both flags in variables",
+			variables: map[string]interface{}{
+				"gqlcache":   true,
+				"gqlretries": false,
+				"test":       "value",
+			},
+			headers:     nil,
+			wantCache:   true,
+			wantRetries: false,
+			wantCleanedVars: map[string]interface{}{
+				"test": "value",
+			},
+		},
+		{
+			name: "flags in both headers and variables",
+			variables: map[string]interface{}{
+				"gqlcache": false,
+				"test":     "value",
+			},
+			headers: map[string]interface{}{
+				"gqlretries": true,
+			},
+			wantCache:   false,
+			wantRetries: true,
+			wantCleanedVars: map[string]interface{}{
+				"test": "value",
+			},
+		},
+		{
+			name:            "no flags",
+			variables:       map[string]interface{}{"test": "value"},
+			headers:         nil,
+			wantCache:       false,
+			wantRetries:     false,
+			wantCleanedVars: map[string]interface{}{"test": "value"},
+		},
+	}
+
+	for _, tt := range tests {
+		suite.T().Run(tt.name, func(t *testing.T) {
+			gotCache, gotRetries, gotCleanedVars := processFlags(tt.variables, tt.headers)
+			assert.Equal(tt.wantCache, gotCache)
+			assert.Equal(tt.wantRetries, gotRetries)
+			assert.Equal(tt.wantCleanedVars, gotCleanedVars)
+		})
 	}
 }
 
-func BenchmarkNewQuery(b *testing.B) {
-	c := NewConnection()
-	for i := 0; i < b.N; i++ {
-		_ = c.NewQuery("query { hello }")
-	}
+func (suite *Tests) TestBaseClient_Query_caching() {
+	suite.T().Run("should use cache for query operations", func(t *testing.T) {
+		b := NewConnection()
+		b.SetEndpoint(mockServer.URL)
+		b.SetHTTPClient(mockServer.Client())
+
+		query := "query { viewer { login } }"
+		variables := map[string]interface{}{
+			"gqlcache": true,
+		}
+
+		// First call should hit the server
+		result1, err := b.Query(query, variables, nil)
+		assert.NoError(err)
+		assert.NotNil(result1)
+
+		// Second call should use cache
+		result2, err := b.Query(query, variables, nil)
+		assert.NoError(err)
+		assert.Equal(result1, result2)
+	})
+
+	suite.T().Run("should not cache mutations", func(t *testing.T) {
+		b := NewConnection()
+		b.SetEndpoint(mockServer.URL)
+		b.SetHTTPClient(mockServer.Client())
+
+		mutation := "mutation { updateUser { id } }"
+		variables := map[string]interface{}{
+			"gqlcache": true,
+		}
+
+		// Mutations should not be cached even with cache flag
+		_, err := b.Query(mutation, variables, nil)
+		assert.Error(err) // Mock server doesn't handle mutations
+	})
 }
 
-func BenchmarkDecodeResponse(b *testing.B) {
-	c := NewConnection()
-	for i := 0; i < b.N; i++ {
-		_ = c.decodeResponse([]byte(`{"data":{"hello":"world"}}`))
-	}
+func (suite *Tests) TestBaseClient_Query_retries() {
+	suite.T().Run("should handle retries flag", func(t *testing.T) {
+		b := NewConnection()
+		b.SetEndpoint(mockServer.URL)
+		b.SetHTTPClient(mockServer.Client())
+
+		query := "query { viewer { login } }"
+		variables := map[string]interface{}{
+			"gqlretries": true,
+		}
+
+		result, err := b.Query(query, variables, nil)
+		assert.NoError(err)
+		assert.NotNil(result)
+	})
 }
 
-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 (suite *Tests) TestBaseClient_Query_globalCache() {
+	suite.T().Run("should respect global cache setting", func(t *testing.T) {
+		b := NewConnection()
+		b.SetEndpoint(mockServer.URL)
+		b.SetHTTPClient(mockServer.Client())
+		b.cache_global = true
+
+		query := "query { viewer { login } }"
+
+		// Should use cache even without explicit flag
+		result1, err := b.Query(query, nil, nil)
+		assert.NoError(err)
+		assert.NotNil(result1)
+
+		result2, err := b.Query(query, nil, nil)
+		assert.NoError(err)
+		assert.Equal(result1, result2)
+	})
 }
 
-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 (suite *Tests) TestBaseClient_Query_emptyQuery() {
+	suite.T().Run("should handle empty query", func(t *testing.T) {
+		b := NewConnection()
+		b.SetEndpoint(mockServer.URL)
+		b.SetHTTPClient(mockServer.Client())
+
+		result, err := b.Query("", nil, nil)
+		assert.Error(err)
+		assert.Nil(result)
+		assert.Contains(err.Error(), "can't compile query")
+	})
 }

request.go

@@ -1,59 +0,0 @@
-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, value.(string))
-	}
-
-	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_test.go

@@ -0,0 +1,24 @@
+package main
+
+import "testing"
+
+func Test_main(t *testing.T) {
+	// Test that main function doesn't panic during setup
+	// The actual GraphQL calls will fail, but we want to test the setup code
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("main() panicked: %v", r)
+		}
+	}()
+
+	// Call main() to get coverage - it will fail on network calls but that's expected
+	// This tests the NewConnection() call and query compilation
+	main()
+}
+
+func Test_samplePackageExists(t *testing.T) {
+	// This test ensures the sample package is properly structured
+	// and can be imported/compiled
+
+	// Test passes if we reach this point without compilation errors
+}

semver.yaml

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

structs.go

@@ -1,52 +1,41 @@
 package gql
 
 import (
-	"context"
 	"net/http"
+	"time"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
-
-	"github.com/allegro/bigcache"
+	cache "github.com/lukaszraczylo/go-simple-graphql/cache"
+	logging "github.com/lukaszraczylo/go-simple-graphql/logging"
 )
 
-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
+	cache          *cache.Cache
+	Logger         *logging.Logger
+	client         *http.Client
+	endpoint       string
+	responseType   string
+	retries_delay  time.Duration
+	retries_number int
+	MaxGoRoutines  int
+	cache_global   bool
+	retries_enable bool
 }
 
 type Query struct {
-	context       context.Context
-	variables     map[string]any `json:"variables"`
-	query         string         `json:"query"`
-	compiledQuery []byte         `json:"compiledQuery"`
+	Variables map[string]interface{} `json:"variables,omitempty"`
+	Query     string                 `json:"query,omitempty"`
+	JsonQuery []byte                 `json:"jsonQuery,omitempty"`
 }
 
-type request struct {
-	Variables any    `json:"variables"`
-	Query     string `json:"query"`
+type QueryExecutor struct {
+	Result any
+	Error  error
+	*BaseClient
+	Headers  map[string]interface{}
+	CacheKey string
+	Query    []byte
+	CacheTTL time.Duration
+	Retries  bool
 }
 
 type queryResults struct {

suite_test.go

@@ -0,0 +1,44 @@
+package gql
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	assertions "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+type Tests struct {
+	suite.Suite
+}
+
+var (
+	assert     *assertions.Assertions
+	mockServer *httptest.Server
+)
+
+func (suite *Tests) SetupSuite() {
+	// Start mock GraphQL server
+	mockServer = StartMockServer()
+}
+
+func (suite *Tests) TearDownSuite() {
+	// Close the mock server
+	if mockServer != nil {
+		mockServer.Close()
+	}
+
+	// Cleanup shared test cache
+	CleanupTestCache()
+}
+
+func (suite *Tests) SetupTest() {
+	assert = assertions.New(suite.T())
+}
+
+func (suite *Tests) BeforeTest(suiteName, testName string) {
+}
+
+func TestSuite(t *testing.T) {
+	suite.Run(t, new(Tests))
+}

test_helpers.go

@@ -0,0 +1,49 @@
+package gql
+
+import (
+	"sync"
+	"time"
+
+	cache "github.com/lukaszraczylo/go-simple-graphql/cache"
+	logging "github.com/lukaszraczylo/go-simple-graphql/logging"
+)
+
+var (
+	testCacheOnce sync.Once
+	testCache     *cache.Cache
+	testLogger    *logging.Logger
+)
+
+// GetTestCache returns a shared cache instance for tests to reduce resource contention
+func GetTestCache() *cache.Cache {
+	testCacheOnce.Do(func() {
+		testCache = cache.New(5 * time.Second) // Short TTL for tests
+	})
+	return testCache
+}
+
+// GetTestLogger returns a shared logger instance for tests
+func GetTestLogger() *logging.Logger {
+	if testLogger == nil {
+		testLogger = logging.New()
+		testLogger.SetMinLogLevel(logging.LEVEL_ERROR)
+	}
+	return testLogger
+}
+
+// CleanupTestCache stops the shared test cache - call this in TestMain if needed
+func CleanupTestCache() {
+	if testCache != nil {
+		testCache.Stop()
+	}
+}
+
+// CreateTestClient creates a test client with shared resources
+func CreateTestClient() *BaseClient {
+	return &BaseClient{
+		Logger:       GetTestLogger(),
+		cache:        GetTestCache(),
+		endpoint:     "https://example.com/graphql",
+		responseType: "mapstring",
+	}
+}

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/helpers/helpers.go

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

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

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

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

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

@@ -1,164 +0,0 @@
-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"
-	}
-}