v0.0.480

ginext/engine.go

@@ -218,3 +218,7 @@ func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
 func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
 	w.engine.ServeHTTP(writer, req)
 }
+
+func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
+	return w.engine.Routes()
+}

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.5.0
 	github.com/rs/zerolog v1.33.0
-	go.mongodb.org/mongo-driver v1.15.1
+	go.mongodb.org/mongo-driver v1.16.0
 	golang.org/x/crypto v0.24.0
 	golang.org/x/sys v0.21.0
 	golang.org/x/term v0.21.0
@@ -21,7 +21,7 @@ require (
 )
 
 require (
-	github.com/bytedance/sonic v1.11.8 // indirect
+	github.com/bytedance/sonic v1.11.9 // indirect
 	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.1 // indirect
@@ -54,7 +54,7 @@ require (
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 // indirect
 	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/image v0.17.0 // indirect
+	golang.org/x/image v0.18.0 // indirect
 	golang.org/x/net v0.26.0 // indirect
 	golang.org/x/text v0.16.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect

go.sum

@@ -22,6 +22,8 @@ github.com/bytedance/sonic v1.11.7 h1:k/l9p1hZpNIMJSk37wL9ltkcpqLfIho1vYthi4xT2t
 github.com/bytedance/sonic v1.11.7/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LRA=
 github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic v1.11.9 h1:LFHENlIY/SLzDWverzdOvgMztTxcfcF+cqNsz9pK5zg=
+github.com/bytedance/sonic v1.11.9/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic/loader v0.1.0/go.mod h1:UmRT+IRTGKz/DAkzcEGzyVqQFJ7H9BqwBO3pm9H/+HY=
 github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
@@ -220,6 +222,8 @@ go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUS
 go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
 go.mongodb.org/mongo-driver v1.15.1 h1:l+RvoUOoMXFmADTLfYDm7On9dRm7p4T80/lEQM+r7HU=
 go.mongodb.org/mongo-driver v1.15.1/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
+go.mongodb.org/mongo-driver v1.16.0 h1:tpRsfBJMROVHKpdGyc1BBEzzjDUWjItxbVSZ8Ls4BQ4=
+go.mongodb.org/mongo-driver v1.16.0/go.mod h1:oB6AhJQvFQL4LEHyXi6aJzQJtBiTQHiAd83l0GdFaiw=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.7.0 h1:pskyeJh/3AmoQ8CPE95vxHLqp1G1GfGNXTmcl9NEKTc=
 golang.org/x/arch v0.7.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
@@ -252,6 +256,8 @@ golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
 golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
+golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.475"
+const GoextVersion = "0.0.480"
 
-const GoextVersionTimestamp = "2024-06-16T17:14:21+0200"
+const GoextVersionTimestamp = "2024-07-02T11:32:22+0200"

langext/string.go

@@ -88,12 +88,15 @@ func StrRunePadRight(str string, pad string, padlen int) string {
 
 func Indent(str string, pad string) string {
 	eonl := strings.HasSuffix(str, "\n")
+	if eonl {
+		str = str[0 : len(str)-1]
+	}
 	r := ""
 	for _, v := range strings.Split(str, "\n") {
 		r += pad + v + "\n"
 	}
 
-	if eonl {
+	if !eonl {
 		r = r[0 : len(r)-1]
 	}
 
@@ -115,3 +118,21 @@ func StrRepeat(val string, count int) string {
 	}
 	return r
 }
+
+func StrWrap(val string, linelen int, seperator string) string {
+	res := ""
+
+	for iPos := 0; ; {
+		next := min(iPos+linelen, len(val))
+		res += val[iPos:next]
+
+		iPos = next
+		if iPos >= len(val) {
+			break
+		}
+
+		res += seperator
+	}
+
+	return res
+}

langext/string_test.go

@@ -0,0 +1,152 @@
+package langext
+
+import "testing"
+
+func TestStrLimitBehaviour(t *testing.T) {
+	val := "Hello, World!"
+	maxlen := 5
+	suffix := "..."
+	expected := "He..."
+	result := StrLimit(val, maxlen, suffix)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrSplitBehaviour1(t *testing.T) {
+	val := "Hello,World,,"
+	sep := ","
+	expected := []string{"Hello", "World"}
+	result := StrSplit(val, sep, false)
+	if len(result) != len(expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrSplitBehaviour2(t *testing.T) {
+	val := "Hello,World,,"
+	sep := ","
+	expected := []string{"Hello", "World", "", ""}
+	result := StrSplit(val, sep, true)
+	if len(result) != len(expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrPadRightBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "Hello*****"
+	result := StrPadRight(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrPadLeftBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "*****Hello"
+	result := StrPadLeft(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRunePadLeftBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "*****Hello"
+	result := StrRunePadLeft(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRunePadRightBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "Hello*****"
+	result := StrRunePadRight(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestIndentBehaviour1(t *testing.T) {
+	str := "Hello\nWorld"
+	pad := ".."
+	expected := "..Hello\n..World"
+	result := Indent(str, pad)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestIndentBehaviour2(t *testing.T) {
+	str := "Hello\nWorld\n"
+	pad := ".."
+	expected := "..Hello\n..World\n"
+	result := Indent(str, pad)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRepeatBehaviour(t *testing.T) {
+	val := "Hello"
+	count := 3
+	expected := "HelloHelloHello"
+	result := StrRepeat(val, count)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour1(t *testing.T) {
+	val := "123456789"
+	linelen := 5
+	seperator := "\n"
+	expected := "12345\n6789"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour2(t *testing.T) {
+	val := "1234567890"
+	linelen := 5
+	seperator := "\n"
+	expected := "12345\n67890"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour3(t *testing.T) {
+	val := "****************"
+	linelen := 4
+	seperator := "\n"
+	expected := "****\n****\n****\n****"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour4(t *testing.T) {
+	val := "*****************"
+	linelen := 4
+	seperator := "\n"
+	expected := "****\n****\n****\n****\n*"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}

reflectext/structAccess.go

@@ -0,0 +1,185 @@
+package reflectext
+
+import (
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+var ErrAccessStructInvalidFieldType = errors.New("invalid field type")
+var ErrAccessStructFieldInPathWasNil = errors.New("a field in the path was nil")
+var ErrAccessStructInvalidArrayIndex = errors.New("invalid array index")
+var ErrAccessStructInvalidMapKey = errors.New("invalid map key")
+var ErrAccessStructArrayAccess = errors.New("trying to access array")
+var ErrAccessStructMapAccess = errors.New("trying to access map")
+var ErrAccessStructMissingField = errors.New("missing field")
+
+type AccessStructOpt struct {
+	ReturnNilOnMissingFields          bool    // return nil (instead of error) when a field in the path is missing (aka the supplied path is wrong)
+	ReturnNilOnNilPtrFields           bool    // return nil (instead of error) when a field in the path is nil
+	ReturnNilOnWrongFinalFieldType    bool    // return nil (instead of error) when the (final) field is not of the requested generic type
+	ReturnNilOnWrongIntermedFieldType bool    // return nil (instead of error) when the intermediate field has an invalid type
+	ReturnNilOnInvalidArrayIndizes    bool    // return nil (instead of error) when trying to acces an array with an invalid index (not a number or out of range)
+	ReturnNilOnMissingMapKeys         bool    // return nil (instead of error) when trying to access a map with a missing key
+	UsedTagForKeys                    *string // Use this tag for key names in the struct (instead of the StructField.Name)
+	PreventArrayAccess                bool    // do not access array indizes - throw an error instead
+	PreventMapAccess                  bool    // do not access maps - throw an error instead
+}
+
+func AccessJSONStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: langext.Ptr("json")})
+}
+
+func AccessStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{})
+}
+
+func AccessStructByArrayPath[TResult any](v any, path []string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), path, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func AccessStructByStringPath[TResult any](v any, path string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+	arrpath := strings.Split(path, ".")
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), arrpath, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func accessStructByPath(val reflect.Value, path []string, opt AccessStructOpt) (any, error) {
+	if len(path) == 0 {
+		return val.Interface(), nil
+	}
+
+	currPath := path[0]
+
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+		return accessStructByPath(val.Elem(), path, opt)
+	}
+
+	if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
+		if opt.PreventArrayAccess {
+			return nil, ErrAccessStructArrayAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		arrIdx, err := strconv.ParseInt(currPath, 10, 64)
+		if err != nil {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		if arrIdx < 0 || int(arrIdx) >= val.Len() {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		return accessStructByPath(val.Index(int(arrIdx)), path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Map {
+		if opt.PreventMapAccess {
+			return nil, ErrAccessStructMapAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		mapval := val.MapIndex(reflect.ValueOf(currPath))
+		if !mapval.IsValid() || mapval.IsZero() {
+			if opt.ReturnNilOnMissingMapKeys {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidMapKey
+			}
+		}
+
+		return accessStructByPath(mapval, path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Struct {
+		if opt.UsedTagForKeys != nil {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Tag.Get(*opt.UsedTagForKeys) == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		} else {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Name == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		}
+	}
+
+	if opt.ReturnNilOnWrongIntermedFieldType {
+		return nil, nil
+	} else {
+		return nil, ErrAccessStructMissingField
+	}
+}

reflectext/structAccess_test.go

@@ -0,0 +1,259 @@
+package reflectext
+
+import "testing"
+
+type TestStruct struct {
+	Name string `json:"name"`
+	Age  int    `json:"age"`
+}
+
+func TestAccessStructByArrayPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByStringPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByStringPath[string](testStruct, "Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByStringPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByStringPath[string](testStruct, "Invalid")
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type RecursiveStruct struct {
+	Name     string
+	Sub      *RecursiveStruct
+	SubSlice []RecursiveStruct
+}
+
+func TestAccessStructByArrayPath_RecursiveStruct(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", Sub: &RecursiveStruct{Name: "Jane"}}
+	result, err := AccessStructByArrayPath[string](*testStruct.Sub, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_RecursiveStructSlice(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", SubSlice: []RecursiveStruct{{Name: "Jane"}}}
+	result, err := AccessStructByArrayPath[string](testStruct.SubSlice[0], []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_WrongType(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[int](testStruct, []string{"Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Name", "Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStruct struct {
+	Name string
+	Sub  *TestStruct
+}
+
+func TestAccessStructByStringPath_NestedStruct(t *testing.T) {
+	testStruct := NestedStruct{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+type DeepNestedStruct struct {
+	Name string
+	Sub  *NestedStruct
+}
+
+func TestAccessStructByStringPath_DeepNestedStruct(t *testing.T) {
+	testStruct := DeepNestedStruct{Name: "John", Sub: &NestedStruct{Name: "Jane", Sub: &TestStruct{Name: "Doe", Age: 30}}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Doe" {
+		t.Errorf("Expected 'Doe', got '%s'", result)
+	}
+}
+
+type MapStruct struct {
+	Name string
+	Age  int
+}
+
+type TestStructWithMap struct {
+	MapField map[string]MapStruct
+}
+
+func TestAccessStructByArrayPath_MapField(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "key", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidMapKey(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "invalid", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type ArrayStruct struct {
+	Name string
+	Arr  []TestStruct
+}
+
+func TestAccessStructByArrayPath_ArrayField(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "0", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidArrayIndex(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "1", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type FunctionStruct struct {
+	Name string
+	Func func() string
+}
+
+func TestAccessStructByArrayPath_FunctionField(t *testing.T) {
+	testStruct := FunctionStruct{Name: "John", Func: func() string { return "Hello" }}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Func"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_NonExistentPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"NonExistent"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStructWithTag struct {
+	Name string      `json:"name"`
+	Sub  *TestStruct `json:"sub"`
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeys(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "name"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeysInvalid(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "invalid"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type DifferentTypeStruct struct {
+	Name string
+	Age  int
+}
+
+func TestAccessStructByArrayPath_DifferentType(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[any](testStruct, []string{"Age"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != 30 {
+		t.Errorf("Expected '30', got '%v'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_DifferentTypeInvalid(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[any](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}

wmo/queryAggregate.go

@@ -19,6 +19,8 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	res, err := c.decodeAll(ctx, cursor)
 	if err != nil {
 		return nil, exerr.Wrap(err, "failed to decode values").Build()
@@ -38,6 +40,8 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v, err := c.decodeSingle(ctx, cursor)
 		if err != nil {
@@ -60,6 +64,8 @@ func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline,
 		return *new(TData), exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v, err := c.decodeSingle(ctx, cursor)
 		if err != nil {

wmo/queryFind.go

@@ -64,6 +64,8 @@ func (c *Coll[TData]) Find(ctx context.Context, filter bson.M, opts ...*options.
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	res, err := c.decodeAll(ctx, cursor)
 	if err != nil {
 		return nil, exerr.Wrap(err, "failed to decode values").Build()

wmo/queryFindOne.go

@@ -80,6 +80,8 @@ func (c *Coll[TData]) findOneInternal(ctx context.Context, filter bson.M, allowN
 			return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
 		}
 
+		defer func() { _ = cursor.Close(ctx) }()
+
 		if cursor.Next(ctx) {
 			v, err := c.decodeSingle(ctx, cursor)
 			if err != nil {

wmo/queryList.go

@@ -69,6 +69,8 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int,
 		return nil, ct.CursorToken{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	// fast branch
 	if pageSize == nil {
 		entries, err := c.decodeAll(ctx, cursor)
@@ -118,6 +120,8 @@ func (c *Coll[TData]) Count(ctx context.Context, filter ct.RawFilter) (int64, er
 		return 0, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v := countRes{}
 		err = cursor.Decode(&v)