New minor release after complete rewrite.

Brings neat and testable codebase with minimum allocations in mind.

utils/logger/logger.go

@@ -0,0 +1,72 @@
+package logger
+
+import (
+	"reflect"
+
+	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/ordered_map"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+var json = jsoniter.ConfigCompatibleWithStandardLibrary
+
+const (
+	reset      = "\033[0m"
+	redBold    = "\033[1;31m"
+	greenBold  = "\033[1;32m"
+	yellowBold = "\033[1;33m"
+	blueBold   = "\033[1;34m"
+)
+
+type LogLevel int
+
+const (
+	Silent LogLevel = iota
+	Error
+	Warn
+	Info
+	Debug
+)
+
+type Config struct {
+	Colorful bool
+	LogLevel LogLevel
+}
+
+func Serialize(v any) (string, error) {
+	marshal, err := json.Marshal(internalSerialize(v))
+	if err != nil {
+		return "", err
+	}
+	return helpers.BytesToString(marshal), nil
+}
+
+func internalSerialize(v any) any {
+	if v != nil {
+		switch reflect.TypeOf(v).Kind() {
+		case reflect.Struct:
+			r := ordered_map.New()
+			name := reflect.TypeOf(v).Name()
+			if name != "" {
+				r.Set("_", reflect.TypeOf(v).String())
+			}
+			for i := 0; i < reflect.ValueOf(v).NumField(); i++ {
+				r.Set(reflect.TypeOf(v).Field(i).Name, internalSerialize(reflect.ValueOf(v).Field(i).Interface()))
+			}
+			return r
+		case reflect.Ptr:
+			if !reflect.ValueOf(v).IsNil() {
+				return internalSerialize(reflect.ValueOf(v).Elem().Interface())
+			}
+		case reflect.Slice:
+			var r []any
+			tmpSlice := reflect.ValueOf(v)
+			for i := 0; i < tmpSlice.Len(); i++ {
+				r = append(r, internalSerialize(tmpSlice.Index(i).Interface()))
+			}
+			return r
+		}
+	}
+	return v
+}

utils/logger/logger_test.go

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