general improvements

.github/workflows/autoupdate.yaml

@@ -0,0 +1,72 @@
+name: Autoupdate go.mod and go.sum
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "30 2 * * *"
+
+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
+      - 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"

execute_query.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/avast/retry-go/v4"
 	"github.com/goccy/go-json"
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
 )
 
 var bufferPool = sync.Pool{
@@ -28,13 +29,19 @@ func (qe *QueryExecutor) executeQuery() ([]byte, error) {
 
 	_, err := buf.Write(qe.Query)
 	if err != nil {
-		qe.Logger.Error("Can't write to buffer", map[string]interface{}{"error": err})
+		qe.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't write to buffer",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
 		return nil, err
 	}
 
 	httpRequest, err := http.NewRequest(http.MethodPost, qe.endpoint, buf)
 	if err != nil {
-		qe.Logger.Error("Can't create HTTP request", map[string]interface{}{"error": err})
+		qe.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't create HTTP request",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
 		return nil, err
 	}
 
@@ -44,24 +51,36 @@ func (qe *QueryExecutor) executeQuery() ([]byte, error) {
 
 	retriesMax := 1
 	if qe.Retries {
-		qe.Logger.Debug("Retries enabled", map[string]interface{}{"retries": qe.retries_number})
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Retries enabled",
+			Pairs:   map[string]interface{}{"retries": qe.retries_number},
+		})
 		retriesMax = qe.retries_number
 	} else {
-		qe.Logger.Debug("Retries disabled", map[string]interface{}{"retries": 1})
+		qe.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Retries disabled",
+			Pairs:   map[string]interface{}{"retries": 1},
+		})
 	}
 
 	var queryResult queryResults
 	err = retry.Do(
 		func() error {
 			httpResponse, err := qe.client.Do(httpRequest)
 			if err != nil {
-				qe.Logger.Debug("Error executing HTTP request", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug(&libpack_logger.LogMessage{
+					Message: "Error executing HTTP request",
+					Pairs:   map[string]interface{}{"error": err.Error()},
+				})
 				return err
 			}
 			defer func() {
 				_, err := io.Copy(io.Discard, httpResponse.Body)
 				if err != nil {
-					qe.Logger.Debug("Error discarding HTTP response body", map[string]interface{}{"error": err.Error()})
+					qe.Logger.Debug(&libpack_logger.LogMessage{
+						Message: "Error discarding HTTP response body",
+						Pairs:   map[string]interface{}{"error": err.Error()},
+					})
 				}
 				httpResponse.Body.Close()
 			}()
@@ -75,7 +94,10 @@ func (qe *QueryExecutor) executeQuery() ([]byte, error) {
 			if encoding == "gzip" {
 				reader, err = gzip.NewReader(httpResponse.Body)
 				if err != nil {
-					qe.Logger.Debug("Error creating gzip reader", map[string]interface{}{"error": err.Error()})
+					qe.Logger.Debug(&libpack_logger.LogMessage{
+						Message: "Error creating gzip reader",
+						Pairs:   map[string]interface{}{"error": err.Error()},
+					})
 					return fmt.Errorf("error creating gzip reader: %w", err)
 				}
 				defer reader.Close()
@@ -85,44 +107,65 @@ func (qe *QueryExecutor) executeQuery() ([]byte, error) {
 
 			body, err := io.ReadAll(reader)
 			if err != nil {
-				qe.Logger.Debug("Error reading HTTP response", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug(&libpack_logger.LogMessage{
+					Message: "Error reading HTTP response",
+					Pairs:   map[string]interface{}{"error": err.Error()},
+				})
 				return fmt.Errorf("error reading HTTP response: %w", err)
 			}
 
 			err = json.Unmarshal(body, &queryResult)
 			if err != nil {
-				qe.Logger.Debug("Error unmarshalling HTTP response", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug(&libpack_logger.LogMessage{
+					Message: "Error unmarshalling HTTP response",
+					Pairs:   map[string]interface{}{"error": err.Error()},
+				})
 				return fmt.Errorf("error unmarshalling HTTP response: %w", err)
 			}
 
 			return nil
 		},
 		retry.OnRetry(func(n uint, err error) {
-			qe.Logger.Warning("Retrying query", map[string]interface{}{"error": err.Error(), "attempt": n + 1})
+			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.LastErrorOnly(true),
 	)
 	if err != nil {
-		qe.Logger.Debug("Error executing HTTP request", map[string]interface{}{"error": err.Error()})
+		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("Error executing query", map[string]interface{}{"error": queryResult.Errors})
+		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("Error executing query", map[string]interface{}{"error": "no data"})
+		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")
 	}
 
 	jsonData, err := json.Marshal(queryResult.Data)
 	if err != nil {
-		qe.Logger.Debug("Error marshalling query result", map[string]interface{}{"error": err.Error(), "data": queryResult.Data})
+		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)
 	}
 

helpers.go

@@ -1,10 +1,12 @@
 package gql
 
 import (
+	"crypto/md5"
+	"encoding/hex"
 	"fmt"
 
 	"github.com/goccy/go-json"
-	"github.com/gookit/goutil/strutil"
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
 )
 
 func searchForKeysInMapStringInterface(msi map[string]interface{}, key string) (value any) {
@@ -15,7 +17,8 @@ func searchForKeysInMapStringInterface(msi map[string]interface{}, key string) (
 }
 
 func calculateHash(query *Query) string {
-	return strutil.Md5(query.JsonQuery)
+	hash := md5.Sum([]byte(query.JsonQuery))
+	return hex.EncodeToString(hash[:])
 }
 
 func (b *BaseClient) cacheLookup(hash string) []byte {
@@ -29,7 +32,10 @@ func (b *BaseClient) decodeResponse(response []byte) (any, error) {
 		var result map[string]interface{}
 		err := json.Unmarshal(response, &result)
 		if err != nil {
-			b.Logger.Error("Can't decode response into mapstring", map[string]interface{}{"error": err.Error()})
+			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
@@ -38,7 +44,10 @@ func (b *BaseClient) decodeResponse(response []byte) (any, error) {
 	case "byte":
 		return response, nil
 	default:
-		b.Logger.Error("Can't decode response;", map[string]interface{}{"error": "unknown response type"})
+		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")
 	}
 }

http.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	libpack_logger "github.com/lukaszraczylo/go-simple-graphql/logging"
 	"golang.org/x/net/http2"
 )
 
@@ -28,7 +29,10 @@ func (b *BaseClient) createHttpClient() (http_client *http.Client) {
 				return http.ErrUseLastResponse
 			},
 		}
-		b.Logger.Debug("Using HTTP/1.1 over http", nil)
+		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://") {
@@ -46,9 +50,14 @@ func (b *BaseClient) createHttpClient() (http_client *http.Client) {
 				return http.ErrUseLastResponse
 			},
 		}
-		b.Logger.Debug("Using HTTP/2 over https", nil)
+		b.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Using HTTP/2 over https",
+			Pairs:   nil,
+		})
 	} else {
-		b.Logger.Critical("Invalid endpoint - neither http or https", nil)
+		b.Logger.Critical(&libpack_logger.LogMessage{
+			Message: "Invalid endpoint - neither http or https",
+		})
 	}
 	return http_client
 }