New minor release after complete rewrite.

Brings neat and testable codebase with minimum allocations in mind.

utils/concurrency/concurrency.go

@@ -0,0 +1,30 @@
+package concurrency
+
+type Pool struct {
+	queue chan struct{}
+	jobs  int
+}
+
+func NewPool(size int) *Pool {
+	if size < 0 {
+		size = 0
+	}
+	return &Pool{
+		jobs:  size,
+		queue: make(chan struct{}, size),
+	}
+}
+
+func (p *Pool) Enqueue(job func(params ...any), params ...any) {
+	if p.jobs == 0 {
+		go job(params...)
+		return
+	}
+	p.queue <- struct{}{}
+	go func() {
+		defer func() {
+			<-p.queue
+		}()
+		job(params...)
+	}()
+}

utils/concurrency/concurrency_test.go

@@ -0,0 +1,74 @@
+package concurrency
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewPool(t *testing.T) {
+	type args struct {
+		size int
+	}
+	tests := []struct {
+		want *Pool
+		name string
+		args args
+	}{
+		{
+			name: "TestNewPool",
+			args: args{
+				size: 0,
+			},
+			want: &Pool{
+				jobs:  0,
+				queue: make(chan struct{}, 0),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NewPool(tt.args.size)
+			assert.Equal(t, got.jobs, tt.want.jobs)
+			assert.Equal(t, cap(got.queue), cap(tt.want.queue))
+		})
+	}
+}
+
+func TestPool_Enqueue(t *testing.T) {
+	type fields struct {
+		queue chan struct{}
+		jobs  int
+	}
+	type args struct {
+		job    func(params ...any)
+		params []any
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		{
+			name: "TestPool_Enqueue",
+			fields: fields{
+				queue: make(chan struct{}, 0),
+				jobs:  0,
+			},
+			args: args{
+				job: func(params ...any) {
+					return
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &Pool{
+				queue: tt.fields.queue,
+				jobs:  tt.fields.jobs,
+			}
+			p.Enqueue(tt.args.job, tt.args.params...)
+		})
+	}
+}

utils/helpers/helpers.go

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

utils/helpers/helpers_test.go

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

utils/logger/logger.go

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

utils/logger/logger_test.go

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

utils/ordered_map/ordered_map.go

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

utils/ordered_map/ordered_map_test.go

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