Replace allegro/bigcache with something lighter.

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

utils/logger/logger.go

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

utils/ordered_map/ordered_map.go

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