go mod tidy

bfcodegen/csid-generate.go

@@ -5,11 +5,11 @@ import (
 	_ "embed"
 	"errors"
 	"fmt"
+	"go/format"
 	"git.blackforestbytes.com/BlackForestBytes/goext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
-	"go/format"
 	"io"
 	"os"
 	"path"
@@ -64,17 +64,16 @@ func GenerateCharsetIDSpecs(sourceDir string, destFile string, opt CSIDGenOption
 	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
 	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
 
-	var newChecksumStr strings.Builder
+	newChecksumStr := goext.GoextVersion
-	newChecksumStr.WriteString(goext.GoextVersion)
 	for _, f := range files {
 		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
 		if err != nil {
 			return err
 		}
-		newChecksumStr.WriteString("\n" + f.Name() + "\t" + cryptext.BytesSha256(content))
+		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
 	}
 
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr.String()))
+	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
 
 	if newChecksum != oldChecksum {
 		fmt.Printf("[CSIDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)

bfcodegen/enum-generate.go

@@ -95,17 +95,16 @@ func _generateEnumSpecs(sourceDir string, destFile string, oldChecksum string, g
 	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
 	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
 
-	var newChecksumStr strings.Builder
+	newChecksumStr := goext.GoextVersion
-	newChecksumStr.WriteString(goext.GoextVersion)
 	for _, f := range files {
 		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
 		if err != nil {
 			return "", "", false, err
 		}
-		newChecksumStr.WriteString("\n" + f.Name() + "\t" + cryptext.BytesSha256(content))
+		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
 	}
 
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr.String()))
+	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
 
 	if newChecksum != oldChecksum {
 		fmt.Printf("[EnumGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
@@ -214,7 +213,7 @@ func processEnumFile(basedir string, fn string, debugOutput bool) ([]EnumDef, st
 			var descr *string = nil
 			var data *map[string]any = nil
 			if comment != nil {
-				comment = new(strings.TrimSpace(*comment))
+				comment = langext.Ptr(strings.TrimSpace(*comment))
 				if strings.HasPrefix(*comment, "{") {
 					if v, ok := tryParseDataComment(*comment); ok {
 						data = &v
@@ -279,7 +278,7 @@ func tryParseDataComment(s string) (map[string]any, bool) {
 
 		rv := reflect.ValueOf(v)
 
-		if rv.Kind() == reflect.Pointer && rv.IsNil() {
+		if rv.Kind() == reflect.Ptr && rv.IsNil() {
 			continue
 		}
 		if rv.Kind() == reflect.Bool {

bfcodegen/id-generate.go

@@ -5,11 +5,11 @@ import (
 	_ "embed"
 	"errors"
 	"fmt"
+	"go/format"
 	"git.blackforestbytes.com/BlackForestBytes/goext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
-	"go/format"
 	"io"
 	"os"
 	"path"
@@ -63,17 +63,16 @@ func GenerateIDSpecs(sourceDir string, destFile string, opt IDGenOptions) error
 	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
 	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
 
-	var newChecksumStr strings.Builder
+	newChecksumStr := goext.GoextVersion
-	newChecksumStr.WriteString(goext.GoextVersion)
 	for _, f := range files {
 		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
 		if err != nil {
 			return err
 		}
-		newChecksumStr.WriteString("\n" + f.Name() + "\t" + cryptext.BytesSha256(content))
+		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
 	}
 
-	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr.String()))
+	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
 
 	if newChecksum != oldChecksum {
 		fmt.Printf("[IDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)

bfcodegen/id-generate.template

@@ -2,9 +2,7 @@
 
 package {{.PkgName}}
 
-import "go.mongodb.org/mongo-driver/bson"
+import "go.mongodb.org/mongo-driver/v2/bson"
-import "go.mongodb.org/mongo-driver/bson/bsontype"
-import "go.mongodb.org/mongo-driver/bson/primitive"
 import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 
 const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
@@ -13,9 +11,10 @@ const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
 
 // ================================ {{.Name}} ({{.FileRelative}}) ================================
 
-func (i {{.Name}}) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (i {{.Name}}) MarshalBSONValue() (byte, []byte, error) {
-	if objId, err := primitive.ObjectIDFromHex(string(i)); err == nil {
+	if objId, err := bson.ObjectIDFromHex(string(i)); err == nil {
-		return bson.MarshalValue(objId)
+		tp, data, err := bson.MarshalValue(objId)
+		return byte(tp), data, err
 	} else {
 		return 0, nil, exerr.New(exerr.TypeMarshalEntityID, "Failed to marshal {{.Name}}("+i.String()+") to ObjectId").Str("value", string(i)).Type("type", i).Build()
 	}
@@ -25,12 +24,12 @@ func (i {{.Name}}) String() string {
 	return string(i)
 }
 
-func (i {{.Name}}) ObjID() (primitive.ObjectID, error) {
+func (i {{.Name}}) ObjID() (bson.ObjectID, error) {
-	return primitive.ObjectIDFromHex(string(i))
+	return bson.ObjectIDFromHex(string(i))
 }
 
 func (i {{.Name}}) Valid() bool {
-	_, err := primitive.ObjectIDFromHex(string(i))
+	_, err := bson.ObjectIDFromHex(string(i))
 	return err == nil
 }
 
@@ -50,7 +49,7 @@ func (i {{.Name}}) IsZero() bool {
 }
 
 func New{{.Name}}() {{.Name}} {
-	return {{.Name}}(primitive.NewObjectID().Hex())
+	return {{.Name}}(bson.NewObjectID().Hex())
 }
 
 {{end}}

cmdext/builder.go

@@ -61,12 +61,12 @@ func (r *CommandRunner) Envs(env []string) *CommandRunner {
 }
 
 func (r *CommandRunner) EnsureExitcode(arg ...int) *CommandRunner {
-	r.enforceExitCodes = new(langext.ForceArray(arg))
+	r.enforceExitCodes = langext.Ptr(langext.ForceArray(arg))
 	return r
 }
 
 func (r *CommandRunner) FailOnExitCode() *CommandRunner {
-	r.enforceExitCodes = new([]int{0})
+	r.enforceExitCodes = langext.Ptr([]int{0})
 	return r
 }
 

cmdext/cmdrunner.go

@@ -37,7 +37,7 @@ func run(opt CommandRunner) (CommandResult, error) {
 	}
 
 	preader := pipeReader{
-		lineBufferSize: new(128 * 1024 * 1024), // 128MB max size of a single line, is hopefully enough....
+		lineBufferSize: langext.Ptr(128 * 1024 * 1024), // 128MB max size of a single line, is hopefully enough....
 		stdout:         stdoutPipe,
 		stderr:         stderrPipe,
 	}
@@ -66,7 +66,7 @@ func run(opt CommandRunner) (CommandResult, error) {
 
 		if opt.enforceNoStderr {
 			listener = append(listener, genericCommandListener{
-				_readRawStderr: new(func(v []byte) {
+				_readRawStderr: langext.Ptr(func(v []byte) {
 					if len(v) > 0 {
 						stderrFailChan <- true
 					}

cmdext/pipereader.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
 	"io"
-	"strings"
 	"sync"
 )
 
@@ -30,14 +29,14 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 
 	wg.Add(1)
 	stdoutBufferReader, stdoutBufferWriter := io.Pipe()
-	var stdout strings.Builder
+	stdout := ""
 	go func() {
 		buf := make([]byte, 128)
 		for {
 			n, err := pr.stdout.Read(buf)
 			if n > 0 {
 				txt := string(buf[:n])
-				stdout.WriteString(txt)
+				stdout += txt
 				_, _ = stdoutBufferWriter.Write(buf[:n])
 				for _, lstr := range listener {
 					lstr.ReadRawStdout(buf[:n])
@@ -59,7 +58,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 
 	wg.Add(1)
 	stderrBufferReader, stderrBufferWriter := io.Pipe()
-	var stderr strings.Builder
+	stderr := ""
 	go func() {
 		buf := make([]byte, 128)
 		for {
@@ -67,7 +66,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 
 			if n > 0 {
 				txt := string(buf[:n])
-				stderr.WriteString(txt)
+				stderr += txt
 				_, _ = stderrBufferWriter.Write(buf[:n])
 				for _, lstr := range listener {
 					lstr.ReadRawStderr(buf[:n])
@@ -89,7 +88,8 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 
 	// [3] collect stdout line-by-line
 
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
 		scanner := bufio.NewScanner(stdoutBufferReader)
 		if pr.lineBufferSize != nil {
 			scanner.Buffer([]byte{}, *pr.lineBufferSize)
@@ -105,11 +105,13 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			errch <- err
 		}
 		combch <- combevt{"", true}
-	})
+		wg.Done()
+	}()
 
 	// [4] collect stderr line-by-line
 
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
 		scanner := bufio.NewScanner(stderrBufferReader)
 		if pr.lineBufferSize != nil {
 			scanner.Buffer([]byte{}, *pr.lineBufferSize)
@@ -125,12 +127,13 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			errch <- err
 		}
 		combch <- combevt{"", true}
-	})
+		wg.Done()
+	}()
 
 	// [5] combine stdcombined
 
 	wg.Add(1)
-	var stdcombined strings.Builder
+	stdcombined := ""
 	go func() {
 		stopctr := 0
 		for stopctr < 2 {
@@ -138,7 +141,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 			if vvv.stop {
 				stopctr++
 			} else {
-				stdcombined.WriteString(vvv.line + "\n") // this comes from bufio.Scanner and has no newlines...
+				stdcombined += vvv.line + "\n" // this comes from bufio.Scanner and has no newlines...
 			}
 		}
 		wg.Done()
@@ -151,5 +154,5 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 		return "", "", "", err
 	}
 
-	return stdout.String(), stderr.String(), stdcombined.String(), nil
+	return stdout, stderr, stdcombined, nil
 }

confext/confParser.go

@@ -101,11 +101,11 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 }
 
 func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (reflect.Value, error) {
-	if rvtype == reflect.TypeFor[string]() {
+	if rvtype == reflect.TypeOf("") {
 
 		return reflect.ValueOf(envval), nil
 
-	} else if rvtype == reflect.TypeFor[int]() {
+	} else if rvtype == reflect.TypeOf(int(0)) {
 
 		envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
 		if err != nil {
@@ -114,7 +114,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return reflect.ValueOf(int(envint)), nil
 
-	} else if rvtype == reflect.TypeFor[int64]() {
+	} else if rvtype == reflect.TypeOf(int64(0)) {
 
 		envint, err := strconv.ParseInt(envval, 10, 64)
 		if err != nil {
@@ -123,7 +123,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return reflect.ValueOf(int64(envint)), nil
 
-	} else if rvtype == reflect.TypeFor[int32]() {
+	} else if rvtype == reflect.TypeOf(int32(0)) {
 
 		envint, err := strconv.ParseInt(envval, 10, 32)
 		if err != nil {
@@ -132,7 +132,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return reflect.ValueOf(int32(envint)), nil
 
-	} else if rvtype == reflect.TypeFor[int8]() {
+	} else if rvtype == reflect.TypeOf(int8(0)) {
 
 		envint, err := strconv.ParseInt(envval, 10, 8)
 		if err != nil {
@@ -141,7 +141,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return reflect.ValueOf(int8(envint)), nil
 
-	} else if rvtype == reflect.TypeFor[time.Duration]() {
+	} else if rvtype == reflect.TypeOf(time.Duration(0)) {
 
 		dur, err := timeext.ParseDurationShortString(envval)
 		if err != nil {
@@ -159,7 +159,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return reflect.ValueOf(tim), nil
 
-	} else if rvtype.ConvertibleTo(reflect.TypeFor[int]()) {
+	} else if rvtype.ConvertibleTo(reflect.TypeOf(int(0))) {
 
 		envint, err := strconv.ParseInt(envval, 10, 8)
 		if err != nil {
@@ -170,7 +170,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 
 		return envcvl, nil
 
-	} else if rvtype.ConvertibleTo(reflect.TypeFor[bool]()) {
+	} else if rvtype.ConvertibleTo(reflect.TypeOf(false)) {
 
 		if strings.TrimSpace(strings.ToLower(envval)) == "true" {
 			return reflect.ValueOf(true).Convert(rvtype), nil
@@ -184,7 +184,7 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 			return reflect.Value{}, errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,bool> (value := '%s')", rvtype.Name(), fullEnvKey, envval))
 		}
 
-	} else if rvtype.ConvertibleTo(reflect.TypeFor[string]()) {
+	} else if rvtype.ConvertibleTo(reflect.TypeOf("")) {
 
 		envcvl := reflect.ValueOf(envval).Convert(rvtype)
 		return envcvl, nil

cryptext/passHash_test.go

@@ -1,6 +1,7 @@
 package cryptext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/totpext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
@@ -31,7 +32,7 @@ func TestPassHashTOTP(t *testing.T) {
 
 	tst.AssertFalse(t, ph.Verify("test123", nil))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", new(totpext.TOTP(sec))))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
 }
 
@@ -140,7 +141,7 @@ func TestPassHashUpgrade_V3_TOTP(t *testing.T) {
 
 	tst.AssertFalse(t, ph.Verify("test123", nil))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", new(totpext.TOTP(sec))))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
 
 	ph, err = ph.Upgrade("test123")
@@ -152,7 +153,7 @@ func TestPassHashUpgrade_V3_TOTP(t *testing.T) {
 
 	tst.AssertFalse(t, ph.Verify("test123", nil))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", new(totpext.TOTP(sec))))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
 }
 
@@ -192,7 +193,7 @@ func TestPassHashUpgrade_V4_TOTP(t *testing.T) {
 
 	tst.AssertFalse(t, ph.Verify("test123", nil))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", new(totpext.TOTP(sec))))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
 
 	ph, err = ph.Upgrade("test123")
@@ -204,6 +205,6 @@ func TestPassHashUpgrade_V4_TOTP(t *testing.T) {
 
 	tst.AssertFalse(t, ph.Verify("test123", nil))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
-	tst.AssertTrue(t, ph.Verify("test123", new(totpext.TOTP(sec))))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
 	tst.AssertFalse(t, ph.Verify("test124", nil))
 }

cryptext/pronouncablePassword_test.go

@@ -7,21 +7,21 @@ import (
 )
 
 func TestPronouncablePasswordExt(t *testing.T) {
-	for i := range 20 {
+	for i := 0; i < 20; i++ {
 		pw, entropy := PronouncablePasswordExt(rand.New(rand.NewSource(int64(i))), 16)
 		fmt.Printf("[%.2f] => %s\n", entropy, pw)
 	}
 }
 
 func TestPronouncablePasswordSeeded(t *testing.T) {
-	for i := range 20 {
+	for i := 0; i < 20; i++ {
 		pw := PronouncablePasswordSeeded(int64(i), 8)
 		fmt.Printf("%s\n", pw)
 	}
 }
 
 func TestPronouncablePassword(t *testing.T) {
-	for i := range 20 {
+	for i := 0; i < 20; i++ {
 		pw := PronouncablePassword(i + 1)
 		fmt.Printf("%s\n", pw)
 	}

cursortoken/filter.go

@@ -2,7 +2,8 @@ package cursortoken
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/mongo"
+
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 type RawFilter interface {

cursortoken/tokenKeySort.go

@@ -3,8 +3,9 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"time"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type CTKeySort struct {
@@ -119,18 +120,18 @@ func (c CTKeySort) IsStart() bool {
 	return c.Mode == CTMStart
 }
 
-func (c CTKeySort) valuePrimaryObjectId() (primitive.ObjectID, bool) {
+func (c CTKeySort) valuePrimaryObjectId() (bson.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValuePrimary); err == nil {
+	if oid, err := bson.ObjectIDFromHex(c.ValuePrimary); err == nil {
 		return oid, true
 	} else {
-		return primitive.ObjectID{}, false
+		return bson.ObjectID{}, false
 	}
 }
 
-func (c CTKeySort) valueSecondaryObjectId() (primitive.ObjectID, bool) {
+func (c CTKeySort) valueSecondaryObjectId() (bson.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValueSecondary); err == nil {
+	if oid, err := bson.ObjectIDFromHex(c.ValueSecondary); err == nil {
 		return oid, true
 	} else {
-		return primitive.ObjectID{}, false
+		return bson.ObjectID{}, false
 	}
 }

dataext/broadcaster_test.go

@@ -90,17 +90,15 @@ func TestBroadcast_SubscribeByIter(t *testing.T) {
 
 	// Channel to communicate when message is received
 	done := make(chan bool)
-	goroutineDone := make(chan struct{})
 	received := false
 
 	// Start a goroutine to use the iterator
 	go func() {
-		defer close(goroutineDone)
 		for msg := range iterSeq {
 			if msg == "hello" {
 				received = true
 				done <- true
-				return // Stop iteration — triggers Unsubscribe via yield returning false
+				return // Stop iteration
 			}
 		}
 	}()
@@ -121,14 +119,6 @@ func TestBroadcast_SubscribeByIter(t *testing.T) {
 		t.Fatal("Timed out waiting for message")
 	}
 
-	// Wait for the goroutine to fully exit so Unsubscribe (triggered by the
-	// iterator cleanup when yield returns false) has completed.
-	select {
-	case <-goroutineDone:
-	case <-time.After(time.Second):
-		t.Fatal("Timed out waiting for goroutine to finish")
-	}
-
 	subCount := bb.SubscriberCount()
 	if subCount != 0 {
 		t.Fatalf("Expected 0 receivers, got %d", subCount)

dataext/delayedCombiningInvoker.go

@@ -97,7 +97,10 @@ func (d *DelayedCombiningInvoker) run() {
 
 	for {
 		d.syncLock.Lock()
-		timeOut := max(min(d.maxDelay-time.Since(d.initialRequestTime), d.delay-time.Since(d.lastRequestTime)), 0)
+		timeOut := min(d.maxDelay-time.Since(d.initialRequestTime), d.delay-time.Since(d.lastRequestTime))
+		if timeOut < 0 {
+			timeOut = 0
+		}
 		d.syncLock.Unlock()
 
 		immediately := false

dataext/merge.go

@@ -14,7 +14,7 @@ func ObjectMerge[T1 any, T2 any](base T1, override T2) T1 {
 		fieldBase := reflBase.Field(i)
 		fieldOvrd := reflOvrd.Field(i)
 
-		if fieldBase.Kind() != reflect.Pointer || fieldOvrd.Kind() != reflect.Pointer {
+		if fieldBase.Kind() != reflect.Ptr || fieldOvrd.Kind() != reflect.Ptr {
 			continue
 		}
 

dataext/merge_test.go

@@ -1,6 +1,7 @@
 package dataext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
@@ -25,17 +26,17 @@ func TestObjectMerge(t *testing.T) {
 
 	valueA := A{
 		Field1:   nil,
-		Field2:   new("99"),
+		Field2:   langext.Ptr("99"),
-		Field3:   new(12.2),
+		Field3:   langext.Ptr(12.2),
 		Field4:   nil,
 		OnlyA:    1,
 		DiffType: 2,
 	}
 
 	valueB := B{
-		Field1:   new(12),
+		Field1:   langext.Ptr(12),
 		Field2:   nil,
-		Field3:   new(13.2),
+		Field3:   langext.Ptr(13.2),
 		Field4:   nil,
 		OnlyB:    1,
 		DiffType: "X",

dataext/pubsub_test.go

@@ -129,17 +129,15 @@ func TestPubSub_SubscribeByIter(t *testing.T) {
 
 	// Channel to communicate when message is received
 	done := make(chan bool)
-	goroutineDone := make(chan struct{})
 	received := false
 
 	// Start a goroutine to use the iterator
 	go func() {
-		defer close(goroutineDone)
 		for msg := range iterSeq {
 			if msg == "hello" {
 				received = true
 				done <- true
-				return // Stop iteration — triggers Unsubscribe via yield returning false
+				return // Stop iteration
 			}
 		}
 	}()
@@ -160,14 +158,6 @@ func TestPubSub_SubscribeByIter(t *testing.T) {
 		t.Fatal("Timed out waiting for message")
 	}
 
-	// Wait for the goroutine to fully exit so Unsubscribe (triggered by the
-	// iterator cleanup when yield returns false) has completed.
-	select {
-	case <-goroutineDone:
-	case <-time.After(time.Second):
-		t.Fatal("Timed out waiting for goroutine to finish")
-	}
-
 	subCount := ps.SubscriberCount("test-ns")
 	if subCount != 0 {
 		t.Fatalf("Expected 0 receivers, got %d", subCount)

dataext/stack.go

@@ -2,6 +2,7 @@ package dataext
 
 import (
 	"errors"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"sync"
 )
 
@@ -63,7 +64,7 @@ func (s *Stack[T]) OptPop() *T {
 	result := s.data[l-1]
 	s.data = s.data[:l-1]
 
-	return new(result)
+	return langext.Ptr(result)
 }
 
 func (s *Stack[T]) Peek() (T, error) {
@@ -93,7 +94,7 @@ func (s *Stack[T]) OptPeek() *T {
 		return nil
 	}
 
-	return new(s.data[l-1])
+	return langext.Ptr(s.data[l-1])
 }
 
 func (s *Stack[T]) Length() int {

dataext/structHash.go

@@ -82,7 +82,7 @@ func binarize(writer io.Writer, dat reflect.Value, opt StructHashOptions) error
 
 	err = binary.Write(writer, binary.LittleEndian, uint8(dat.Kind()))
 	switch dat.Kind() {
-	case reflect.Pointer, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice, reflect.Interface:
+	case reflect.Ptr, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice, reflect.Interface:
 		if dat.IsNil() {
 			err = binary.Write(writer, binary.LittleEndian, uint64(0))
 			if err != nil {

dataext/structHash_test.go

@@ -1,6 +1,7 @@
 package dataext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
@@ -45,7 +46,7 @@ func TestStructHashSimpleStruct(t *testing.T) {
 	tst.AssertHexEqual(t, "5d09090dc34ac59dd645f197a255f653387723de3afa1b614721ea5a081c675f", noErrStructHash(t, t0{
 		F1: 10,
 		F2: []string{"1", "2", "3"},
-		F3: new(99),
+		F3: langext.Ptr(99),
 	}))
 
 }

enums/enum.go

@@ -1,7 +1,5 @@
 package enums
 
-import "maps"
-
 import "encoding/json"
 
 type Enum interface {
@@ -47,7 +45,9 @@ type EnumDataMetaValue struct {
 func (v EnumDataMetaValue) MarshalJSON() ([]byte, error) {
 	m := make(map[string]any, 8)
 
-	maps.Copy(m, v.Data)
+	for k, dv := range v.Data {
+		m[k] = dv
+	}
 
 	m["varName"] = v.VarName
 	m["value"] = v.Value

excelext/mapper.go

@@ -78,7 +78,7 @@ func (em *ExcelMapper[T]) InitNewFile(sheetName string) (*excelize.File, error)
 
 func (em *ExcelMapper[T]) InitStyles(f *excelize.File) error {
 	styleDate, err := f.NewStyle(&excelize.Style{
-		CustomNumFmt: new("dd.mm.yyyy"),
+		CustomNumFmt: langext.Ptr("dd.mm.yyyy"),
 	})
 	if err != nil {
 		return err

exerr/builder.go

@@ -16,7 +16,7 @@ import (
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 //
@@ -253,7 +253,7 @@ func (b *Builder) Bytes(key string, val []byte) *Builder {
 	return b.addMeta(key, MDTBytes, val)
 }
 
-func (b *Builder) ObjectID(key string, val primitive.ObjectID) *Builder {
+func (b *Builder) ObjectID(key string, val bson.ObjectID) *Builder {
 	return b.addMeta(key, MDTObjectID, val)
 }
 
@@ -277,11 +277,11 @@ func (b *Builder) Ints32(key string, val []int32) *Builder {
 	return b.addMeta(key, MDTInt32Array, val)
 }
 
-func (b *Builder) Type(key string, cls any) *Builder {
+func (b *Builder) Type(key string, cls interface{}) *Builder {
 	return b.addMeta(key, MDTString, fmt.Sprintf("%T", cls))
 }
 
-func (b *Builder) Interface(key string, val any) *Builder {
+func (b *Builder) Interface(key string, val interface{}) *Builder {
 	return b.addMeta(key, MDTAny, newAnyWrap(val))
 }
 
@@ -566,7 +566,7 @@ func (b *Builder) doLogFatal() {
 
 // ----------------------------------------------------------------------------
 
-func (b *Builder) addMeta(key string, mdtype metaDataType, val any) *Builder {
+func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {
 	b.errorData.Meta.add(key, mdtype, val)
 	return b
 }

exerr/constructor.go

@@ -3,14 +3,14 @@ package exerr
 import (
 	"encoding/json"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"maps"
 	"reflect"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
-var reflectTypeStr = reflect.TypeFor[string]()
+var reflectTypeStr = reflect.TypeOf("")
 
 func FromError(err error) *ExErr {
 
@@ -153,18 +153,20 @@ func getForeignMeta(err error) (mm MetaMap) {
 	}()
 
 	rval := reflect.ValueOf(err)
-	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Pointer {
+	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Ptr {
 		rval = reflect.ValueOf(err).Elem()
 	}
 
 	mm.add("foreign.errortype", MDTString, rval.Type().String())
 
-	maps.Copy(mm, addMetaPrefix("foreign", getReflectedMetaValues(err, 8)))
+	for k, v := range addMetaPrefix("foreign", getReflectedMetaValues(err, 8)) {
+		mm[k] = v
+	}
 
 	return mm
 }
 
-func getReflectedMetaValues(value any, remainingDepth int) map[string]MetaValue {
+func getReflectedMetaValues(value interface{}, remainingDepth int) map[string]MetaValue {
 
 	if remainingDepth <= 0 {
 		return map[string]MetaValue{}
@@ -176,7 +178,7 @@ func getReflectedMetaValues(value any, remainingDepth int) map[string]MetaValue
 
 	rval := reflect.ValueOf(value)
 
-	if rval.Type().Kind() == reflect.Pointer {
+	if rval.Type().Kind() == reflect.Ptr {
 
 		if rval.IsNil() {
 			return map[string]MetaValue{"*": {DataType: MDTNil, Value: nil}}
@@ -222,7 +224,7 @@ func getReflectedMetaValues(value any, remainingDepth int) map[string]MetaValue
 		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
 	case []int32:
 		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
-	case primitive.ObjectID:
+	case bson.ObjectID:
 		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
 	case []string:
 		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
@@ -236,7 +238,9 @@ func getReflectedMetaValues(value any, remainingDepth int) map[string]MetaValue
 			fieldname := fieldtype.Name
 
 			if fieldtype.IsExported() {
-				maps.Copy(m, addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)))
+				for k, v := range addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)) {
+					m[k] = v
+				}
 			}
 		}
 		return m

exerr/dataCategory.go

@@ -4,11 +4,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 )
 
 type ErrorCategory struct{ Category string }
@@ -28,8 +25,8 @@ func (e ErrorCategory) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Category)
 }
 
-func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (e *ErrorCategory) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -37,11 +34,11 @@ func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		*e = ErrorCategory{}
 		return nil
 	}
-	if bt != bson.TypeString {
+	if bson.Type(bt) != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -49,40 +46,9 @@ func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 	return nil
 }
 
-func (e ErrorCategory) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (e ErrorCategory) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(e.Category)
+	tp, data, err := bson.MarshalValue(e.Category)
-}
+	return byte(tp), data, err
-
-func (e ErrorCategory) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
 }
 
 //goland:noinspection GoUnusedGlobalVariable

exerr/dataSeverity.go

@@ -4,11 +4,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 )
 
 type ErrorSeverity struct{ Severity string }
@@ -30,8 +27,8 @@ func (e ErrorSeverity) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Severity)
 }
 
-func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (e *ErrorSeverity) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -39,11 +36,11 @@ func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		*e = ErrorSeverity{}
 		return nil
 	}
-	if bt != bson.TypeString {
+	if bson.Type(bt) != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -51,40 +48,9 @@ func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 	return nil
 }
 
-func (e ErrorSeverity) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (e ErrorSeverity) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(e.Severity)
+	tp, data, err := bson.MarshalValue(e.Severity)
-}
+	return byte(tp), data, err
-
-func (e ErrorSeverity) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
 }
 
 //goland:noinspection GoUnusedGlobalVariable

exerr/dataType.go

@@ -4,13 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 
 	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
-	"go.mongodb.org/mongo-driver/bson"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type ErrorType struct {
@@ -20,42 +17,42 @@ type ErrorType struct {
 
 //goland:noinspection GoUnusedGlobalVariable
 var (
-	TypeInternal       = NewType("INTERNAL_ERROR", new(500))
+	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
-	TypePanic          = NewType("PANIC", new(500))
+	TypePanic          = NewType("PANIC", langext.Ptr(500))
-	TypeNotImplemented = NewType("NOT_IMPLEMENTED", new(500))
+	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
-	TypeAssert         = NewType("ASSERT", new(500))
+	TypeAssert         = NewType("ASSERT", langext.Ptr(500))
 
-	TypeMongoQuery        = NewType("MONGO_QUERY", new(500))
+	TypeMongoQuery        = NewType("MONGO_QUERY", langext.Ptr(500))
-	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", new(500))
+	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500))
-	TypeMongoFilter       = NewType("MONGO_FILTER", new(500))
+	TypeMongoFilter       = NewType("MONGO_FILTER", langext.Ptr(500))
-	TypeMongoReflection   = NewType("MONGO_REFLECTION", new(500))
+	TypeMongoReflection   = NewType("MONGO_REFLECTION", langext.Ptr(500))
-	TypeMongoInvalidOpt   = NewType("MONGO_INVALIDOPT", new(500))
+	TypeMongoInvalidOpt   = NewType("MONGO_INVALIDOPT", langext.Ptr(500))
 
-	TypeSQLQuery  = NewType("SQL_QUERY", new(500))
+	TypeSQLQuery  = NewType("SQL_QUERY", langext.Ptr(500))
-	TypeSQLBuild  = NewType("SQL_BUILD", new(500))
+	TypeSQLBuild  = NewType("SQL_BUILD", langext.Ptr(500))
-	TypeSQLDecode = NewType("SQL_DECODE", new(500))
+	TypeSQLDecode = NewType("SQL_DECODE", langext.Ptr(500))
 
 	TypeWrap = NewType("Wrap", nil)
 
-	TypeBindFailURI      = NewType("BINDFAIL_URI", new(400))
+	TypeBindFailURI      = NewType("BINDFAIL_URI", langext.Ptr(400))
-	TypeBindFailQuery    = NewType("BINDFAIL_QUERY", new(400))
+	TypeBindFailQuery    = NewType("BINDFAIL_QUERY", langext.Ptr(400))
-	TypeBindFailJSON     = NewType("BINDFAIL_JSON", new(400))
+	TypeBindFailJSON     = NewType("BINDFAIL_JSON", langext.Ptr(400))
-	TypeBindFailFormData = NewType("BINDFAIL_FORMDATA", new(400))
+	TypeBindFailFormData = NewType("BINDFAIL_FORMDATA", langext.Ptr(400))
-	TypeBindFailHeader   = NewType("BINDFAIL_HEADER", new(400))
+	TypeBindFailHeader   = NewType("BINDFAIL_HEADER", langext.Ptr(400))
 
-	TypeMarshalEntityID = NewType("MARSHAL_ENTITY_ID", new(400))
+	TypeMarshalEntityID = NewType("MARSHAL_ENTITY_ID", langext.Ptr(400))
-	TypeInvalidCSID     = NewType("INVALID_CSID", new(400))
+	TypeInvalidCSID     = NewType("INVALID_CSID", langext.Ptr(400))
 
-	TypeGoogleStatuscode = NewType("GOOGLE_STATUSCODE", new(400))
+	TypeGoogleStatuscode = NewType("GOOGLE_STATUSCODE", langext.Ptr(400))
-	TypeGoogleResponse   = NewType("GOOGLE_RESPONSE", new(400))
+	TypeGoogleResponse   = NewType("GOOGLE_RESPONSE", langext.Ptr(400))
 
-	TypeUnauthorized = NewType("UNAUTHORIZED", new(401))
+	TypeUnauthorized = NewType("UNAUTHORIZED", langext.Ptr(401))
-	TypeAuthFailed   = NewType("AUTH_FAILED", new(401))
+	TypeAuthFailed   = NewType("AUTH_FAILED", langext.Ptr(401))
 
-	TypeInvalidImage    = NewType("IMAGEEXT_INVALID_IMAGE", new(400))
+	TypeInvalidImage    = NewType("IMAGEEXT_INVALID_IMAGE", langext.Ptr(400))
-	TypeInvalidMimeType = NewType("IMAGEEXT_INVALID_MIMETYPE", new(400))
+	TypeInvalidMimeType = NewType("IMAGEEXT_INVALID_MIMETYPE", langext.Ptr(400))
 
-	TypeWebsocket = NewType("WEBSOCKET", new(500))
+	TypeWebsocket = NewType("WEBSOCKET", langext.Ptr(500))
 
 	// other values come from the downstream application that uses goext
 )
@@ -80,8 +77,8 @@ func (e ErrorType) MarshalJSON() ([]byte, error) {
 	return json.Marshal(e.Key)
 }
 
-func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (e *ErrorType) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -89,11 +86,11 @@ func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*e = ErrorType{}
 		return nil
 	}
-	if bt != bson.TypeString {
+	if bson.Type(bt) != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bson.Type(bt)))
 	}
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -107,40 +104,9 @@ func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	}
 }
 
-func (e ErrorType) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (e ErrorType) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(e.Key)
+	tp, data, err := bson.MarshalValue(e.Key)
-}
+	return byte(tp), data, err
-
-func (e ErrorType) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = e.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&e))
-	} else {
-		val.Set(reflect.ValueOf(e))
-	}
-
-	return nil
 }
 
 var registeredTypes = dataext.SyncMap[string, ErrorType]{}

exerr/data_test.go

@@ -3,12 +3,12 @@ package exerr
 import (
 	"context"
 	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-	"go.mongodb.org/mongo-driver/mongo"
-	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func TestJSONMarshalErrorCategory(t *testing.T) {
@@ -57,7 +57,7 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -68,7 +68,7 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": CatSystem})
 	tst.AssertNoErr(t, err)
@@ -76,8 +76,8 @@ func TestBSONMarshalErrorCategory(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
+		ID  bson.ObjectID `bson:"_id"`
-		Val ErrorCategory      `bson:"val"`
+		Val ErrorCategory `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)
@@ -90,7 +90,7 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -101,7 +101,7 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": SevErr})
 	tst.AssertNoErr(t, err)
@@ -109,8 +109,8 @@ func TestBSONMarshalErrorSeverity(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
+		ID  bson.ObjectID `bson:"_id"`
-		Val ErrorSeverity      `bson:"val"`
+		Val ErrorSeverity `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)
@@ -123,7 +123,7 @@ func TestBSONMarshalErrorType(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
 	defer cancel()
 
-	client, err := mongo.Connect(ctx)
+	client, err := mongo.Connect()
 	if err != nil {
 		t.Skip("Skip test - no local mongo found")
 		return
@@ -134,7 +134,7 @@ func TestBSONMarshalErrorType(t *testing.T) {
 		return
 	}
 
-	primimd := primitive.NewObjectID()
+	primimd := bson.NewObjectID()
 
 	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": TypeNotImplemented})
 	tst.AssertNoErr(t, err)
@@ -142,8 +142,8 @@ func TestBSONMarshalErrorType(t *testing.T) {
 	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
 
 	var c1 struct {
-		ID  primitive.ObjectID `bson:"_id"`
+		ID  bson.ObjectID `bson:"_id"`
-		Val ErrorType          `bson:"val"`
+		Val ErrorType     `bson:"val"`
 	}
 
 	err = cursor.Decode(&c1)

exerr/exerr.go

@@ -2,13 +2,12 @@ package exerr
 
 import (
 	"fmt"
+	"github.com/rs/xid"
+	"github.com/rs/zerolog"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strings"
 	"time"
-
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"github.com/rs/xid"
-	"github.com/rs/zerolog"
 )
 
 type ExErr struct {
@@ -126,37 +125,35 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 
 	} else if lvl == LogPrintOverview {
 
-		var str strings.Builder
+		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
-		str.WriteString("[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n")
 
 		for exk, exv := range ee.Extra {
-			str.WriteString(fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv))
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
 		}
 
-		var indent strings.Builder
+		indent := ""
 		for curr := ee; curr != nil; curr = curr.OriginalError {
-			indent.WriteString("  ")
+			indent += "  "
 
-			str.WriteString(indent.String())
+			str += indent
-			str.WriteString("-> ")
+			str += "-> "
 			strmsg := strings.Trim(curr.Message, " \r\n\t")
 			if lbidx := strings.Index(curr.Message, "\n"); lbidx >= 0 {
 				strmsg = strmsg[0:lbidx]
 			}
 			strmsg = langext.StrLimit(strmsg, 61, "...")
-			str.WriteString(strmsg)
+			str += strmsg
-			str.WriteString("\n")
+			str += "\n"
 
 		}
-		return str.String()
+		return str
 
 	} else if lvl == LogPrintFull {
 
-		var str strings.Builder
+		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
-		str.WriteString("[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n")
 
 		for exk, exv := range ee.Extra {
-			str.WriteString(fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv))
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
 		}
 
 		indent := ""
@@ -168,33 +165,33 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 				etype = "~"
 			}
 
-			str.WriteString(indent)
+			str += indent
-			str.WriteString("-> [")
+			str += "-> ["
-			str.WriteString(etype)
+			str += etype
 			if curr.Category == CatForeign {
-				str.WriteString("|Foreign")
+				str += "|Foreign"
 			}
-			str.WriteString("] ")
+			str += "] "
-			str.WriteString(strings.ReplaceAll(curr.Message, "\n", " "))
+			str += strings.ReplaceAll(curr.Message, "\n", " ")
 			if curr.Caller != "" {
-				str.WriteString(" (@ ")
+				str += " (@ "
-				str.WriteString(curr.Caller)
+				str += curr.Caller
-				str.WriteString(")")
+				str += ")"
 			}
-			str.WriteString("\n")
+			str += "\n"
 
 			if curr.Meta.Any() {
 				meta := indent + "   {" + curr.Meta.FormatOneLine(240) + "}"
 				if len(meta) < 200 {
-					str.WriteString(meta)
+					str += meta
-					str.WriteString("\n")
+					str += "\n"
 				} else {
-					str.WriteString(curr.Meta.FormatMultiLine(indent+"   ", "  ", 1024))
+					str += curr.Meta.FormatMultiLine(indent+"   ", "  ", 1024)
-					str.WriteString("\n")
+					str += "\n"
 				}
 			}
 		}
-		return str.String()
+		return str
 
 	} else {
 
@@ -204,7 +201,7 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 }
 
 func (ee *ExErr) ShortLog(evt *zerolog.Event) {
-	ee.Meta.Apply(evt, new(240)).Msg(ee.FormatLog(LogPrintShort))
+	ee.Meta.Apply(evt, langext.Ptr(240)).Msg(ee.FormatLog(LogPrintShort))
 }
 
 // RecursiveMessage returns the message to show
@@ -257,7 +254,7 @@ func (ee *ExErr) RecursiveType() ErrorType {
 func (ee *ExErr) RecursiveStatuscode() *int {
 	for curr := ee; curr != nil; curr = curr.OriginalError {
 		if curr.StatusCode != nil {
-			return new(*curr.StatusCode)
+			return langext.Ptr(*curr.StatusCode)
 		}
 	}
 
@@ -282,7 +279,7 @@ func (ee *ExErr) RecursiveCategory() ErrorCategory {
 func (ee *ExErr) RecursiveMeta(key string) *MetaValue {
 	for curr := ee; curr != nil; curr = curr.OriginalError {
 		if metaval, ok := curr.Meta[key]; ok {
-			return new(metaval)
+			return langext.Ptr(metaval)
 		}
 	}
 

exerr/gin.go

@@ -1,8 +1,6 @@
 package exerr
 
 import (
-	"maps"
-
 	json "git.blackforestbytes.com/BlackForestBytes/goext/gojson"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
@@ -52,7 +50,9 @@ func (ee *ExErr) toJson(depth int, applyExtendListener bool, outputMeta bool) la
 		ginJson["meta"] = metaJson
 
 		extraJson := langext.H{}
-		maps.Copy(extraJson, ee.Extra)
+		for extraKey, extraVal := range ee.Extra {
+			extraJson[extraKey] = extraVal
+		}
 		ginJson["extra"] = extraJson
 	}
 

exerr/meta.go

@@ -5,14 +5,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"math"
 	"strconv"
 	"strings"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 // This is a buffed up map[string]any
@@ -49,13 +49,13 @@ const (
 
 type MetaValue struct {
 	DataType metaDataType `json:"dataType"`
-	Value    any          `json:"value"`
+	Value    interface{}  `json:"value"`
 }
 
 type metaValueSerialization struct {
 	DataType metaDataType `bson:"dataType"`
 	Value    string       `bson:"value"`
-	Raw      any          `bson:"raw"`
+	Raw      interface{}  `bson:"raw"`
 }
 
 func (v MetaValue) SerializeValue() (string, error) {
@@ -99,7 +99,7 @@ func (v MetaValue) SerializeValue() (string, error) {
 	case MDTBytes:
 		return hex.EncodeToString(v.Value.([]byte)), nil
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex(), nil
+		return v.Value.(bson.ObjectID).Hex(), nil
 	case MDTTime:
 		return strconv.FormatInt(v.Value.(time.Time).Unix(), 10) + "|" + strconv.FormatInt(int64(v.Value.(time.Time).Nanosecond()), 10), nil
 	case MDTDuration:
@@ -178,7 +178,7 @@ func (v MetaValue) ShortString(lim int) string {
 	case MDTBytes:
 		return langext.StrLimit(hex.EncodeToString(v.Value.([]byte)), lim, "...")
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	case MDTTime:
 		return v.Value.(time.Time).Format(time.RFC3339)
 	case MDTDuration:
@@ -266,7 +266,7 @@ func (v MetaValue) Apply(key string, evt *zerolog.Event, limitLen *int) *zerolog
 	case MDTBytes:
 		return evt.Bytes(key, v.Value.([]byte))
 	case MDTObjectID:
-		return evt.Str(key, v.Value.(primitive.ObjectID).Hex())
+		return evt.Str(key, v.Value.(bson.ObjectID).Hex())
 	case MDTTime:
 		return evt.Time(key, v.Value.(time.Time))
 	case MDTDuration:
@@ -379,7 +379,7 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 			v.DataType = datatype
 			return nil
 		} else {
-			v.Value = new(value[1:])
+			v.Value = langext.Ptr(value[1:])
 			v.DataType = datatype
 			return nil
 		}
@@ -460,7 +460,7 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 		v.DataType = datatype
 		return nil
 	case MDTObjectID:
-		r, err := primitive.ObjectIDFromHex(value)
+		r, err := bson.ObjectIDFromHex(value)
 		if err != nil {
 			return err
 		}
@@ -577,7 +577,7 @@ func (v MetaValue) ValueString() string {
 	case MDTBytes:
 		return hex.EncodeToString(v.Value.([]byte))
 	case MDTObjectID:
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	case MDTTime:
 		return v.Value.(time.Time).Format(time.RFC3339Nano)
 	case MDTDuration:
@@ -628,8 +628,8 @@ func (v MetaValue) rawValueForJson() any {
 		if v.Value.(AnyWrap).IsError {
 			return bson.M{"@error": true}
 		}
-		jsonobj := primitive.M{}
+		jsonobj := bson.M{}
-		jsonarr := primitive.A{}
+		jsonarr := bson.A{}
 		if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonobj); err == nil {
 			return jsonobj
 		} else if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonarr); err == nil {
@@ -654,7 +654,7 @@ func (v MetaValue) rawValueForJson() any {
 		return v.Value.(time.Time).Format(time.RFC3339Nano)
 	}
 	if v.DataType == MDTObjectID {
-		return v.Value.(primitive.ObjectID).Hex()
+		return v.Value.(bson.ObjectID).Hex()
 	}
 	if v.DataType == MDTNil {
 		return nil
@@ -694,28 +694,28 @@ func (v MetaValue) rawValueForJson() any {
 }
 
 func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
-	var r strings.Builder
+	r := ""
 
 	i := 0
 	for key, val := range mm {
 		if i > 0 {
-			r.WriteString(", ")
+			r += ", "
 		}
 
-		r.WriteString("\"" + key + "\"")
+		r += "\"" + key + "\""
-		r.WriteString(": ")
+		r += ": "
-		r.WriteString("\"" + val.ShortString(singleMaxLen) + "\"")
+		r += "\"" + val.ShortString(singleMaxLen) + "\""
 
 		i++
 	}
 
-	return r.String()
+	return r
 }
 
 func (mm MetaMap) FormatMultiLine(indentFront string, indentKeys string, maxLenValue int) string {
-	var r strings.Builder
+	r := ""
 
-	r.WriteString(indentFront + "{" + "\n")
+	r += indentFront + "{" + "\n"
 	for key, val := range mm {
 		if key == "gin.body" {
 			continue
@@ -724,16 +724,16 @@ func (mm MetaMap) FormatMultiLine(indentFront string, indentKeys string, maxLenV
 			continue
 		}
 
-		r.WriteString(indentFront)
+		r += indentFront
-		r.WriteString(indentKeys)
+		r += indentKeys
-		r.WriteString("\"" + key + "\"")
+		r += "\"" + key + "\""
-		r.WriteString(": ")
+		r += ": "
-		r.WriteString("\"" + val.ShortString(maxLenValue) + "\"")
+		r += "\"" + val.ShortString(maxLenValue) + "\""
-		r.WriteString(",\n")
+		r += ",\n"
 	}
-	r.WriteString(indentFront + "}")
+	r += indentFront + "}"
 
-	return r.String()
+	return r
 }
 
 func (mm MetaMap) Any() bool {
@@ -747,7 +747,7 @@ func (mm MetaMap) Apply(evt *zerolog.Event, limitLen *int) *zerolog.Event {
 	return evt
 }
 
-func (mm MetaMap) add(key string, mdtype metaDataType, val any) {
+func (mm MetaMap) add(key string, mdtype metaDataType, val interface{}) {
 	if _, ok := mm[key]; !ok {
 		mm[key] = MetaValue{DataType: mdtype, Value: val}
 		return

ginext/preContext.go

@@ -4,11 +4,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
 	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"github.com/gin-gonic/gin"
-	"github.com/gin-gonic/gin/binding"
 	"io"
 	"runtime/debug"
 	"time"
@@ -84,7 +84,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailURI).
 				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
 				Build()
-			return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
 		}
 	}
 
@@ -94,7 +94,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailQuery).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
 		}
 	}
 
@@ -108,7 +108,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 						WithType(exerr.TypeBindFailJSON).
 						Str("struct_type", fmt.Sprintf("%T", pctx.body)).
 						Build()
-					return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+					return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
 				}
 			}
 			if err := pctx.ginCtx.ShouldBindJSON(pctx.body); err != nil {
@@ -116,14 +116,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailJSON).
 					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
 					Build()
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
 			}
 		} else {
 			if !pctx.ignoreWrongContentType {
 				err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
 					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
 					Build()
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
 			}
 		}
 	}
@@ -132,14 +132,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		if brc, ok := pctx.ginCtx.Request.Body.(dataext.BufferedReadCloser); ok {
 			v, err := brc.BufferedAll()
 			if err != nil {
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = v
 		} else {
 			buf := &bytes.Buffer{}
 			_, err := io.Copy(buf, pctx.ginCtx.Request.Body)
 			if err != nil {
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = buf.Bytes()
 		}
@@ -152,7 +152,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else if pctx.ginCtx.ContentType() == "application/x-www-form-urlencoded" {
 			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
@@ -160,14 +160,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else {
 			if !pctx.ignoreWrongContentType {
 				err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		}
 	}
@@ -178,7 +178,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailHeader).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
 		}
 	}
 
@@ -190,7 +190,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, actx)
 		if err != nil {
 			actx.Cancel()
-			return CreateBackgroundAppContext(), nil, new(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
 		}
 	}
 

ginext/responseData.go

@@ -1,8 +1,8 @@
 package ginext
 
 import (
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type dataHTTPResponse struct {
@@ -42,7 +42,7 @@ func (j dataHTTPResponse) Statuscode() int {
 }
 
 func (j dataHTTPResponse) BodyString(*gin.Context) *string {
-	return new(string(j.data))
+	return langext.Ptr(string(j.data))
 }
 
 func (j dataHTTPResponse) ContentType() string {

ginext/responseDownload.go

@@ -2,8 +2,8 @@ package ginext
 
 import (
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type downloadDataHTTPResponse struct {
@@ -48,7 +48,7 @@ func (j downloadDataHTTPResponse) Statuscode() int {
 }
 
 func (j downloadDataHTTPResponse) BodyString(*gin.Context) *string {
-	return new(string(j.data))
+	return langext.Ptr(string(j.data))
 }
 
 func (j downloadDataHTTPResponse) ContentType() string {

ginext/responseFile.go

@@ -2,8 +2,8 @@ package ginext
 
 import (
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"os"
 )
 
@@ -53,7 +53,7 @@ func (j fileHTTPResponse) BodyString(*gin.Context) *string {
 	if err != nil {
 		return nil
 	}
-	return new(string(data))
+	return langext.Ptr(string(data))
 }
 
 func (j fileHTTPResponse) ContentType() string {

ginext/responseSeekable.go

@@ -1,9 +1,9 @@
 package ginext
 
 import (
+	"github.com/gin-gonic/gin"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"github.com/gin-gonic/gin"
 	"io"
 	"net/http"
 	"time"
@@ -56,7 +56,7 @@ func (j seekableResponse) Statuscode() int {
 }
 
 func (j seekableResponse) BodyString(*gin.Context) *string {
-	return new("(seekable)")
+	return langext.Ptr("(seekable)")
 }
 
 func (j seekableResponse) ContentType() string {

ginext/responseText.go

@@ -1,8 +1,8 @@
 package ginext
 
 import (
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 )
 
 type textHTTPResponse struct {
@@ -41,7 +41,7 @@ func (j textHTTPResponse) Statuscode() int {
 }
 
 func (j textHTTPResponse) BodyString(*gin.Context) *string {
-	return new(j.data)
+	return langext.Ptr(j.data)
 }
 
 func (j textHTTPResponse) ContentType() string {

go.mod

@@ -1,14 +1,14 @@
 module git.blackforestbytes.com/BlackForestBytes/goext
 
-go 1.26.0
+go 1.25.0
 
 require (
 	github.com/gin-gonic/gin v1.12.0
 	github.com/glebarez/go-sqlite v1.22.0 // only needed for tests -.-
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.6.0
-	github.com/rs/zerolog v1.35.1
+	github.com/rs/zerolog v1.35.0
-	go.mongodb.org/mongo-driver v1.17.9
+	go.mongodb.org/mongo-driver/v2 v2.5.1
 	golang.org/x/crypto v0.50.0
 	golang.org/x/sys v0.43.0
 	golang.org/x/term v0.42.0
@@ -20,6 +20,8 @@ require (
 	github.com/gorilla/websocket v1.5.3
 	github.com/jung-kurt/gofpdf v1.16.2
 	github.com/xuri/excelize/v2 v2.10.1
+	go.mongodb.org/mongo-driver v1.17.9
+	golang.org/x/net v0.53.0
 	golang.org/x/sync v0.20.0
 )
 
@@ -36,8 +38,7 @@ require (
 	github.com/go-playground/validator/v10 v10.30.2 // indirect
 	github.com/goccy/go-json v0.10.6 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
-	github.com/golang/snappy v1.0.0 // indirect
+	github.com/google/uuid v1.5.0 // indirect
-	github.com/google/uuid v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/compress v1.18.5 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
@@ -47,8 +48,6 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
-	github.com/montanaflynn/stats v0.9.0 // indirect
-	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.3.0 // indirect
 	github.com/quic-go/qpack v0.6.0 // indirect
 	github.com/quic-go/quic-go v0.59.0 // indirect
@@ -64,14 +63,12 @@ require (
 	github.com/xuri/efp v0.0.1 // indirect
 	github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	go.mongodb.org/mongo-driver/v2 v2.5.1 // indirect
 	golang.org/x/arch v0.26.0 // indirect
 	golang.org/x/image v0.39.0 // indirect
-	golang.org/x/net v0.53.0 // indirect
 	golang.org/x/text v0.36.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
-	modernc.org/libc v1.72.0 // indirect
+	modernc.org/libc v1.37.6 // indirect
-	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
-	modernc.org/memory v1.11.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
-	modernc.org/sqlite v1.49.1 // indirect
+	modernc.org/sqlite v1.28.0 // indirect
 )

go.sum

@@ -40,19 +40,15 @@ github.com/goccy/go-json v0.10.6 h1:p8HrPJzOakx/mn/bQtjgNjdTcN+/S6FcG2CTtQOrHVU=
 github.com/goccy/go-json v0.10.6/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
 github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
-github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
-github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
 github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -81,10 +77,6 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
-github.com/montanaflynn/stats v0.9.0 h1:tsBJ0RXwph9BmAuFoCmqGv6e8xa0MENQ8m0ptKq29mQ=
-github.com/montanaflynn/stats v0.9.0/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
-github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
-github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/pelletier/go-toml/v2 v2.3.0 h1:k59bC/lIZREW0/iVaQR8nDHxVq8OVlIzYCOJf421CaM=
 github.com/pelletier/go-toml/v2 v2.3.0/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/phpdave11/gofpdi v1.0.7/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
@@ -103,8 +95,8 @@ github.com/richardlehane/msoleps v1.0.6 h1:9BvkpjvD+iUBalUY4esMwv6uBkfOip/Lzvd93
 github.com/richardlehane/msoleps v1.0.6/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
 github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
 github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI=
+github.com/rs/zerolog v1.35.0 h1:VD0ykx7HMiMJytqINBsKcbLS+BJ4WYjz+05us+LRTdI=
-github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
+github.com/rs/zerolog v1.35.0/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
 github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
@@ -157,8 +149,6 @@ golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+o
 golang.org/x/image v0.39.0 h1:skVYidAEVKgn8lZ602XO75asgXBgLj9G/FE3RbuPFww=
 golang.org/x/image v0.39.0/go.mod h1:sIbmppfU+xFLPIG0FoVUTvyBMmgng1/XAMhQ2ft0hpA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
-golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
@@ -188,8 +178,6 @@ golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
-golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
@@ -197,31 +185,11 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-modernc.org/cc/v4 v4.27.3 h1:uNCgn37E5U09mTv1XgskEVUJ8ADKpmFMPxzGJ0TSo+U=
+modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw=
-modernc.org/cc/v4 v4.27.3/go.mod h1:3YjcbCqhoTTHPycJDRl2WZKKFj0nwcOIPBfEZK0Hdk8=
+modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
-modernc.org/ccgo/v4 v4.32.4 h1:L5OB8rpEX4ZsXEQwGozRfJyJSFHbbNVOoQ59DU9/KuU=
+modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
-modernc.org/ccgo/v4 v4.32.4/go.mod h1:lY7f+fiTDHfcv6YlRgSkxYfhs+UvOEEzj49jAn2TOx0=
+modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
-modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
+modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
-modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
+modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
-modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
-modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=
-modernc.org/gc/v3 v3.1.2 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo=
-modernc.org/gc/v3 v3.1.2/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
-modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
-modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.72.0 h1:IEu559v9a0XWjw0DPoVKtXpO2qt5NVLAnFaBbjq+n8c=
-modernc.org/libc v1.72.0/go.mod h1:tTU8DL8A+XLVkEY3x5E/tO7s2Q/q42EtnNWda/L5QhQ=
-modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
-modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
-modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
-modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
-modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
-modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
-modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
-modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.49.1 h1:dYGHTKcX1sJ+EQDnUzvz4TJ5GbuvhNJa8Fg6ElGx73U=
-modernc.org/sqlite v1.49.1/go.mod h1:m0w8xhwYUVY3H6pSDwc3gkJ/irZT/0YEXwBlhaxQEew=
-modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
-modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
-modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
-modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

gojson/decode_test.go

@@ -108,11 +108,11 @@ func (u unmarshalerText) MarshalText() ([]byte, error) {
 }
 
 func (u *unmarshalerText) UnmarshalText(b []byte) error {
-	before, after, ok := bytes.Cut(b, []byte{':'})
+	pos := bytes.IndexByte(b, ':')
-	if !ok {
+	if pos == -1 {
 		return errors.New("missing separator")
 	}
-	u.A, u.B = string(before), string(after)
+	u.A, u.B = string(b[:pos]), string(b[pos+1:])
 	return nil
 }
 
@@ -126,7 +126,7 @@ type ustructText struct {
 type u8marshal uint8
 
 func (u8 u8marshal) MarshalText() ([]byte, error) {
-	return fmt.Appendf(nil, "u%d", u8), nil
+	return []byte(fmt.Sprintf("u%d", u8)), nil
 }
 
 var errMissingU8Prefix = errors.New("missing 'u' prefix")
@@ -275,7 +275,7 @@ func (unexportedWithMethods) F() {}
 type byteWithMarshalJSON byte
 
 func (b byteWithMarshalJSON) MarshalJSON() ([]byte, error) {
-	return fmt.Appendf(nil, `"Z%.2x"`, byte(b)), nil
+	return []byte(fmt.Sprintf(`"Z%.2x"`, byte(b))), nil
 }
 
 func (b *byteWithMarshalJSON) UnmarshalJSON(data []byte) error {
@@ -303,7 +303,7 @@ func (b *byteWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
 type byteWithMarshalText byte
 
 func (b byteWithMarshalText) MarshalText() ([]byte, error) {
-	return fmt.Appendf(nil, `Z%.2x`, byte(b)), nil
+	return []byte(fmt.Sprintf(`Z%.2x`, byte(b))), nil
 }
 
 func (b *byteWithMarshalText) UnmarshalText(data []byte) error {
@@ -331,7 +331,7 @@ func (b *byteWithPtrMarshalText) UnmarshalText(data []byte) error {
 type intWithMarshalJSON int
 
 func (b intWithMarshalJSON) MarshalJSON() ([]byte, error) {
-	return fmt.Appendf(nil, `"Z%.2x"`, int(b)), nil
+	return []byte(fmt.Sprintf(`"Z%.2x"`, int(b))), nil
 }
 
 func (b *intWithMarshalJSON) UnmarshalJSON(data []byte) error {
@@ -359,7 +359,7 @@ func (b *intWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
 type intWithMarshalText int
 
 func (b intWithMarshalText) MarshalText() ([]byte, error) {
-	return fmt.Appendf(nil, `Z%.2x`, int(b)), nil
+	return []byte(fmt.Sprintf(`Z%.2x`, int(b))), nil
 }
 
 func (b *intWithMarshalText) UnmarshalText(data []byte) error {

gojson/encode.go

@@ -177,7 +177,7 @@ type IndentOpt struct {
 
 // MarshalSafeCollections is like Marshal except it will marshal nil maps and
 // slices as '{}' and '[]' respectfully instead of 'null'
-func MarshalSafeCollections(v any, nilSafeSlices bool, nilSafeMaps bool, indent *IndentOpt, filter *string) ([]byte, error) {
+func MarshalSafeCollections(v interface{}, nilSafeSlices bool, nilSafeMaps bool, indent *IndentOpt, filter *string) ([]byte, error) {
 	e := &encodeState{}
 	err := e.marshal(v, encOpts{escapeHTML: true, nilSafeSlices: nilSafeSlices, nilSafeMaps: nilSafeMaps, filter: filter})
 	if err != nil {
@@ -891,7 +891,7 @@ func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 		// Here we use a struct to memorize the pointer to the first element of the slice
 		// and its length.
 		ptr := struct {
-			ptr any // always an unsafe.Pointer, but avoids a dependency on package unsafe
+			ptr interface{} // always an unsafe.Pointer, but avoids a dependency on package unsafe
 			len int
 		}{v.UnsafePointer(), v.Len()}
 		if _, ok := e.ptrSeen[ptr]; ok {
@@ -923,7 +923,7 @@ type arrayEncoder struct {
 func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 	e.WriteByte('[')
 	n := v.Len()
-	for i := range n {
+	for i := 0; i < n; i++ {
 		if i > 0 {
 			e.WriteByte(',')
 		}
@@ -1075,7 +1075,10 @@ func appendString[Bytes []byte | string](dst []byte, src Bytes, escapeHTML bool)
 		// For now, cast only a small portion of byte slices to a string
 		// so that it can be stack allocated. This slows down []byte slightly
 		// due to the extra copy, but keeps string performance roughly the same.
-		n := min(len(src)-i, utf8.UTFMax)
+		n := len(src) - i
+		if n > utf8.UTFMax {
+			n = utf8.UTFMax
+		}
 		c, size := utf8.DecodeRuneInString(string(src[i : i+n]))
 		if c == utf8.RuneError && size == 1 {
 			dst = append(dst, src[start:i]...)
@@ -1127,7 +1130,12 @@ type field struct {
 type jsonfilter []string
 
 func (j jsonfilter) Contains(t string) bool {
-	return slices.Contains(j, t)
+	for _, tag := range j {
+		if t == tag {
+			return true
+		}
+	}
+	return false
 }
 
 // typeFields returns a list of fields that JSON should recognize for the given type.

gojson/encode_test.go

@@ -41,7 +41,7 @@ type Optionals struct {
 	Uo uint `json:"uo,omitempty"`
 
 	Str struct{} `json:"str"`
-	Sto struct{} `json:"sto"`
+	Sto struct{} `json:"sto,omitempty"`
 }
 
 func TestOmitEmpty(t *testing.T) {
@@ -1166,7 +1166,8 @@ func TestMarshalUncommonFieldNames(t *testing.T) {
 }
 
 func TestMarshalerError(t *testing.T) {
-	st := reflect.TypeFor[string]()
+	s := "test variable"
+	st := reflect.TypeOf(s)
 	const errText = "json: test error"
 
 	tests := []struct {
@@ -1221,18 +1222,18 @@ func TestIssue63379(t *testing.T) {
 
 func TestMarshalSafeCollections(t *testing.T) {
 	var (
-		nilSlice  []any
+		nilSlice  []interface{}
-		pNilSlice *[]any
+		pNilSlice *[]interface{}
-		nilMap    map[string]any
+		nilMap    map[string]interface{}
-		pNilMap   *map[string]any
+		pNilMap   *map[string]interface{}
 	)
 
 	type (
 		nilSliceStruct struct {
-			NilSlice []any `json:"nil_slice"`
+			NilSlice []interface{} `json:"nil_slice"`
 		}
 		nilMapStruct struct {
-			NilMap map[string]any `json:"nil_map"`
+			NilMap map[string]interface{} `json:"nil_map"`
 		}
 		testWithFilter struct {
 			Test1 string `json:"test1" jsonfilter:"FILTERONE"`
@@ -1241,19 +1242,19 @@ func TestMarshalSafeCollections(t *testing.T) {
 	)
 
 	tests := []struct {
-		in   any
+		in   interface{}
 		want string
 	}{
 		{nilSlice, "[]"},
-		{[]any{}, "[]"},
+		{[]interface{}{}, "[]"},
-		{make([]any, 0), "[]"},
+		{make([]interface{}, 0), "[]"},
 		{[]int{1, 2, 3}, "[1,2,3]"},
 		{pNilSlice, "null"},
 		{nilSliceStruct{}, "{\"nil_slice\":[]}"},
 		{nilMap, "{}"},
-		{map[string]any{}, "{}"},
+		{map[string]interface{}{}, "{}"},
-		{make(map[string]any, 0), "{}"},
+		{make(map[string]interface{}, 0), "{}"},
-		{map[string]any{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}"},
+		{map[string]interface{}{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}"},
 		{pNilMap, "null"},
 		{nilMapStruct{}, "{\"nil_map\":{}}"},
 		{testWithFilter{}, "{\"test1\":\"\"}"},

gojson/fuzz_test.go

@@ -28,10 +28,10 @@ func FuzzUnmarshalJSON(f *testing.F) {
 }`))
 
 	f.Fuzz(func(t *testing.T, b []byte) {
-		for _, typ := range []func() any{
+		for _, typ := range []func() interface{}{
-			func() any { return new(any) },
+			func() interface{} { return new(interface{}) },
-			func() any { return new(map[string]any) },
+			func() interface{} { return new(map[string]interface{}) },
-			func() any { return new([]any) },
+			func() interface{} { return new([]interface{}) },
 		} {
 			i := typ()
 			if err := Unmarshal(b, i); err != nil {

gojson/indent.go

@@ -90,7 +90,7 @@ func appendCompact(dst, src []byte, escape bool) ([]byte, error) {
 func appendNewline(dst []byte, prefix, indent string, depth int) []byte {
 	dst = append(dst, '\n')
 	dst = append(dst, prefix...)
-	for range depth {
+	for i := 0; i < depth; i++ {
 		dst = append(dst, indent...)
 	}
 	return dst

gojson/scanner_test.go

@@ -210,7 +210,10 @@ func diff(t *testing.T, a, b []byte) {
 	t.Helper()
 	for i := 0; ; i++ {
 		if i >= len(a) || i >= len(b) || a[i] != b[i] {
-			j := max(i-10, 0)
+			j := i - 10
+			if j < 0 {
+				j = 0
+			}
 			t.Errorf("diverge at %d: «%s» vs «%s»", i, trim(a[j:]), trim(b[j:]))
 			return
 		}
@@ -271,7 +274,10 @@ func genString(stddev float64) string {
 }
 
 func genArray(n int) []any {
-	f := min(int(math.Abs(rand.NormFloat64())*math.Min(10, float64(n/2))), n)
+	f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
+	if f > n {
+		f = n
+	}
 	if f < 1 {
 		f = 1
 	}
@@ -283,7 +289,10 @@ func genArray(n int) []any {
 }
 
 func genMap(n int) map[string]any {
-	f := min(int(math.Abs(rand.NormFloat64())*math.Min(10, float64(n/2))), n)
+	f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
+	if f > n {
+		f = n
+	}
 	if n > 0 && f == 0 {
 		f = 1
 	}

googleapi/oAuth.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"io"
 	"net/http"
@@ -82,8 +83,8 @@ func (c *oauth) AccessToken() (string, error) {
 	}
 
 	c.lock.Lock()
-	c.expiryDate = new(reqStartTime.Add(timeext.FromSeconds(r.ExpiresIn - 10)))
+	c.expiryDate = langext.Ptr(reqStartTime.Add(timeext.FromSeconds(r.ExpiresIn - 10)))
-	c.accessToken = new(r.AccessToken)
+	c.accessToken = langext.Ptr(r.AccessToken)
 	c.lock.Unlock()
 
 	return r.AccessToken, nil

langext/array.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"math/rand"
 	"reflect"
-	"slices"
-	"strings"
 )
 
 func BoolCount(arr ...bool) int {
@@ -43,12 +41,22 @@ func ReverseArray[T any](v []T) {
 }
 
 func InArray[T comparable](needle T, haystack []T) bool {
-	return slices.Contains(haystack, needle)
+	for _, v := range haystack {
+		if v == needle {
+			return true
+		}
+	}
+	return false
 }
 
 // ArrContains checks if the value is contained in the array (same as InArray, but odther name for better findability)
 func ArrContains[T comparable](haystack []T, needle T) bool {
-	return slices.Contains(haystack, needle)
+	for _, v := range haystack {
+		if v == needle {
+			return true
+		}
+	}
+	return false
 }
 
 func ArrUnique[T comparable](array []T) []T {
@@ -111,7 +119,12 @@ func ArrAllErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
 }
 
 func ArrNone[T any](arr []T, fn func(T) bool) bool {
-	return !slices.ContainsFunc(arr, fn)
+	for _, av := range arr {
+		if fn(av) {
+			return false
+		}
+	}
+	return true
 }
 
 func ArrNoneErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
@@ -128,7 +141,12 @@ func ArrNoneErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
 }
 
 func ArrAny[T any](arr []T, fn func(T) bool) bool {
-	return slices.ContainsFunc(arr, fn)
+	for _, av := range arr {
+		if fn(av) {
+			return true
+		}
+	}
+	return false
 }
 
 func ArrAnyErr[T any](arr []T, fn func(T) (bool, error)) (bool, error) {
@@ -228,7 +246,7 @@ func ArrFirst[T any](arr []T, comp func(v T) bool) (T, bool) {
 func ArrFirstOrNil[T any](arr []T, comp func(v T) bool) *T {
 	for _, v := range arr {
 		if comp(v) {
-			return new(v)
+			return Ptr(v)
 		}
 	}
 	return nil
@@ -256,7 +274,7 @@ func ArrLastOrNil[T any](arr []T, comp func(v T) bool) *T {
 		}
 	}
 	if found {
-		return new(result)
+		return Ptr(result)
 	} else {
 		return nil
 	}
@@ -301,8 +319,10 @@ func ArrLastIndexFunc[T any](arr []T, comp func(v T) bool) int {
 }
 
 func AddToSet[T comparable](set []T, add T) []T {
-	if slices.Contains(set, add) {
+	for _, v := range set {
-		return set
+		if v == add {
+			return set
+		}
 	}
 	return append(set, add)
 }
@@ -502,7 +522,7 @@ func ArrAppend[T any](arr []T, add ...T) []T {
 func ArrPrepend[T any](arr []T, add ...T) []T {
 	out := make([]T, len(arr)+len(add))
 	copy(out[len(add):], arr)
-	for i := range add {
+	for i := 0; i < len(add); i++ {
 		out[len(add)-i-1] = add[i]
 	}
 	return out
@@ -538,8 +558,8 @@ func ArrExcept[T comparable](arr []T, needles ...T) []T {
 	return r
 }
 
-func ArrayToInterface[T any](t []T) []any {
+func ArrayToInterface[T any](t []T) []interface{} {
-	res := make([]any, 0, len(t))
+	res := make([]interface{}, 0, len(t))
 	for i, _ := range t {
 		res = append(res, t[i])
 	}
@@ -547,15 +567,15 @@ func ArrayToInterface[T any](t []T) []any {
 }
 
 func JoinString(arr []string, delimiter string) string {
-	var str strings.Builder
+	str := ""
 	for i, v := range arr {
-		str.WriteString(v)
+		str += v
 		if i < len(arr)-1 {
-			str.WriteString(delimiter)
+			str += delimiter
 		}
 	}
 
-	return str.String()
+	return str
 }
 
 // ArrChunk splits the array into buckets of max-size `chunkSize`
@@ -575,7 +595,10 @@ func ArrChunk[T any](arr []T, chunkSize int) [][]T {
 	i := 0
 	for i < len(arr) {
 
-		right := min(i+chunkSize, len(arr))
+		right := i + chunkSize
+		if right >= len(arr) {
+			right = len(arr)
+		}
 
 		res = append(res, arr[i:right])
 

langext/base58.go

@@ -44,8 +44,8 @@ func newBase58Encoding(alphabet string) *B58Encoding {
 
 	b58 := make([]byte, 0, 256)
 
-	for i := range byte(32) {
+	for i := byte(0); i < 32; i++ {
-		for j := range byte(8) {
+		for j := byte(0); j < 8; j++ {
 
 			b := i*8 + j
 
@@ -100,7 +100,7 @@ func (enc *B58Encoding) Encode(src []byte) ([]byte, error) {
 			}
 		} else {
 			m := mod.Int64()
-			for range 10 {
+			for i := 0; i < 10; i++ {
 				answer = append(answer, enc.alphabet[m%58])
 				m /= 58
 			}
@@ -137,7 +137,10 @@ func (enc *B58Encoding) Decode(src []byte) ([]byte, error) {
 	scratch := new(big.Int)
 
 	for t := src; len(t) > 0; {
-		n := min(len(t), 10)
+		n := len(t)
+		if n > 10 {
+			n = 10
+		}
 
 		total := uint64(0)
 		for _, v := range t[:n] {

langext/base62.go

@@ -18,18 +18,18 @@ func RandBase62(rlen int) string {
 
 	randMax := big.NewInt(math.MaxInt64)
 
-	var r strings.Builder
+	r := ""
 
-	for range rlen {
+	for i := 0; i < rlen; i++ {
 		v, err := rand.Int(rand.Reader, randMax)
 		if err != nil {
 			panic(err)
 		}
 
-		r.WriteString(string(base62CharacterSet[v.Mod(v, bi52).Int64()]))
+		r += string(base62CharacterSet[v.Mod(v, bi52).Int64()])
 	}
 
-	return r.String()
+	return r
 }
 
 func EncodeBase62(num uint64) string {

langext/baseAny.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"math"
 	"math/big"
-	"strings"
 )
 
 type AnyBaseConverter struct {
@@ -26,18 +25,18 @@ func (bc AnyBaseConverter) Rand(rlen int) string {
 
 	randMax := big.NewInt(math.MaxInt64)
 
-	var r strings.Builder
+	r := ""
 
-	for range rlen {
+	for i := 0; i < rlen; i++ {
 		v, err := rand.Int(rand.Reader, randMax)
 		if err != nil {
 			panic(err)
 		}
 
-		r.WriteString(string(bc.charset[v.Mod(v, biBase).Int64()]))
+		r += string(bc.charset[v.Mod(v, biBase).Int64()])
 	}
 
-	return r.String()
+	return r
 }
 
 func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
@@ -45,7 +44,7 @@ func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
 		return "0"
 	}
 
-	var b strings.Builder
+	b := ""
 
 	// loop as long the num is bigger than zero
 	for num > 0 {
@@ -54,10 +53,10 @@ func (bc AnyBaseConverter) EncodeUInt64(num uint64) string {
 		num -= r
 		num /= base62Base
 
-		b.WriteString(string(bc.charset[int(r)]))
+		b += string(bc.charset[int(r)])
 	}
 
-	return b.String()
+	return b
 }
 
 func (bc AnyBaseConverter) DecodeUInt64(str string) (uint64, error) {

langext/bytes.go

@@ -25,7 +25,7 @@ func BytesXOR(a []byte, b []byte) ([]byte, error) {
 
 	r := make([]byte, len(a))
 
-	for i := range a {
+	for i := 0; i < len(a); i++ {
 		r[i] = a[i] ^ b[i]
 	}
 

langext/json.go

@@ -85,7 +85,7 @@ func MarshalJsonOrNil(v any) *string {
 	if err != nil {
 		return nil
 	}
-	return new(string(bin))
+	return Ptr(string(bin))
 }
 
 func MarshalJsonIndentOrPanic(v any, prefix, indent string) string {
@@ -109,5 +109,5 @@ func MarshalJsonIndentOrNil(v any, prefix, indent string) *string {
 	if err != nil {
 		return nil
 	}
-	return new(string(bin))
+	return Ptr(string(bin))
 }

langext/maps.go

@@ -1,7 +1,5 @@
 package langext
 
-import "maps"
-
 import "encoding/json"
 
 type MapEntry[T comparable, V any] struct {
@@ -62,7 +60,9 @@ func MapToArr[T comparable, V any](v map[T]V) []MapEntry[T, V] {
 
 func CopyMap[K comparable, V any](a map[K]V) map[K]V {
 	result := make(map[K]V, len(a))
-	maps.Copy(result, a)
+	for k, v := range a {
+		result[k] = v
+	}
 	return result
 }
 
@@ -90,10 +90,14 @@ func ForceJsonMapOrPanic(v any) map[string]any {
 func MapMerge[K comparable, V any](base map[K]V, arr ...map[K]V) map[K]V {
 	res := make(map[K]V, len(base)*(1+len(arr)))
 
-	maps.Copy(res, base)
+	for k, v := range base {
+		res[k] = v
+	}
 
 	for _, m := range arr {
-		maps.Copy(res, m)
+		for k, v := range m {
+			res[k] = v
+		}
 	}
 
 	return res

langext/pointer.go

@@ -5,17 +5,16 @@ import (
 )
 
 // PTrue := &true
-var PTrue = new(true)
+var PTrue = Ptr(true)
 
 // PFalse := &false
-var PFalse = new(false)
+var PFalse = Ptr(false)
 
 // PNil := &nil
 var PNil = Ptr[any](nil)
 
-//go:fix inline
 func Ptr[T any](v T) *T {
-	return new(v)
+	return &v
 }
 
 func DblPtr[T any](v T) **T {
@@ -35,37 +34,32 @@ func DblPtrNil[T any]() **T {
 	return &v
 }
 
-//go:fix inline
 func ArrPtr[T any](v ...T) *[]T {
-	return new(v)
+	return &v
 }
 
-//go:fix inline
 func PtrInt32(v int32) *int32 {
-	return new(v)
+	return &v
 }
 
-//go:fix inline
 func PtrInt64(v int64) *int64 {
-	return new(v)
+	return &v
 }
 
-//go:fix inline
 func PtrFloat32(v float32) *float32 {
-	return new(v)
+	return &v
 }
 
-//go:fix inline
 func PtrFloat64(v float64) *float64 {
-	return new(v)
+	return &v
 }
 
-func IsNil(i any) bool {
+func IsNil(i interface{}) bool {
 	if i == nil {
 		return true
 	}
 	switch reflect.TypeOf(i).Kind() {
-	case reflect.Pointer, reflect.Map, reflect.Chan, reflect.Slice, reflect.Func, reflect.UnsafePointer:
+	case reflect.Ptr, reflect.Map, reflect.Chan, reflect.Slice, reflect.Func, reflect.UnsafePointer:
 		return reflect.ValueOf(i).IsNil()
 	}
 	return false

langext/sort.go

@@ -1,16 +1,18 @@
 package langext
 
-import "slices"
-
 import "sort"
 
 func Sort[T OrderedConstraint](arr []T) {
-	slices.Sort(arr)
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
 }
 
 func AsSorted[T OrderedConstraint](arr []T) []T {
 	arr = ArrCopy(arr)
-	slices.Sort(arr)
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
 	return arr
 }
 

langext/string.go

@@ -15,7 +15,7 @@ func StrLimit(val string, maxlen int, suffix string) string {
 
 func StrSplit(val string, sep string, allowEmpty bool) []string {
 	var arr []string
-	for k := range strings.SplitSeq(val, sep) {
+	for _, k := range strings.Split(val, sep) {
 		if allowEmpty || k != "" {
 			arr = append(arr, k)
 		}
@@ -51,7 +51,7 @@ func DeRefStringer(v fmt.Stringer) *string {
 	if v == nil {
 		return nil
 	} else {
-		return new(v.String())
+		return Ptr(v.String())
 	}
 }
 
@@ -93,7 +93,7 @@ func Indent(str string, pad string) string {
 		str = str[0 : len(str)-1]
 	}
 	r := ""
-	for v := range strings.SplitSeq(str, "\n") {
+	for _, v := range strings.Split(str, "\n") {
 		r += pad + v + "\n"
 	}
 
@@ -113,29 +113,29 @@ func NumToStringOpt[V IntConstraint](v *V, fallback string) string {
 }
 
 func StrRepeat(val string, count int) string {
-	var r strings.Builder
+	r := ""
-	for range count {
+	for i := 0; i < count; i++ {
-		r.WriteString(val)
+		r += val
 	}
-	return r.String()
+	return r
 }
 
 func StrWrap(val string, linelen int, seperator string) string {
-	var res strings.Builder
+	res := ""
 
 	for iPos := 0; ; {
 		next := min(iPos+linelen, len(val))
-		res.WriteString(val[iPos:next])
+		res += val[iPos:next]
 
 		iPos = next
 		if iPos >= len(val) {
 			break
 		}
 
-		res.WriteString(seperator)
+		res += seperator
 	}
 
-	return res.String()
+	return res
 }
 
 func StrRemoveControlCharacters(str string) string {

mongoext/pipeline.go

@@ -1,8 +1,8 @@
 package mongoext
 
 import (
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 // FixTextSearchPipeline moves {$match:{$text:{$search}}} entries to the front of the pipeline (otherwise its an mongo error)

mongoext/projections.go

@@ -1,16 +1,17 @@
 package mongoext
 
 import (
-	"go.mongodb.org/mongo-driver/bson"
 	"reflect"
 	"strings"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 // ProjectionFromStruct automatically generated a mongodb projection for a struct
 // This way you can pretty much always write
 // `options.FindOne().SetProjection(mongoutils.ProjectionFromStruct(...your_model...))`
 // to only get the data from mongodb that you will actually use in the later decode step
-func ProjectionFromStruct(obj any) bson.M {
+func ProjectionFromStruct(obj interface{}) bson.M {
 	v := reflect.ValueOf(obj)
 	t := v.Type()
 

mongoext/registry.go

@@ -1,51 +1,17 @@
 package mongoext
 
 import (
-	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"reflect"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
-func CreateGoExtBsonRegistry() *bsoncodec.Registry {
+func CreateGoExtBsonRegistry() *bson.Registry {
 	reg := bson.NewRegistry()
 
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.RFC3339Time](), rfctime.RFC3339Time{})
+	// otherwise we get []bson.E when unmarshalling into any
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.RFC3339Time](), rfctime.RFC3339Time{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.RFC3339NanoTime](), rfctime.RFC3339NanoTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.RFC3339NanoTime](), rfctime.RFC3339NanoTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixTime](), rfctime.UnixTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixTime](), rfctime.UnixTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixMilliTime](), rfctime.UnixMilliTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixMilliTime](), rfctime.UnixMilliTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.UnixNanoTime](), rfctime.UnixNanoTime{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.UnixNanoTime](), rfctime.UnixNanoTime{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.Date](), rfctime.Date{})
-	reg.RegisterTypeDecoder(reflect.TypeFor[*rfctime.Date](), rfctime.Date{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[rfctime.SecondsF64](), rfctime.SecondsF64(0))
-	reg.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorCategory](), exerr.ErrorCategory{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorCategory{})), exerr.ErrorCategory{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorSeverity](), exerr.ErrorSeverity{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorSeverity{})), exerr.ErrorSeverity{})
-
-	reg.RegisterTypeDecoder(reflect.TypeFor[exerr.ErrorType](), exerr.ErrorType{})
-	reg.RegisterTypeDecoder(reflect.TypeOf(new(exerr.ErrorType{})), exerr.ErrorType{})
-
-	// otherwise we get []primitve.E when unmarshalling into any
 	// which will result in {'key': .., 'value': ...}[] json when json-marshalling
-	reg.RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeFor[primitive.M]())
+	reg.RegisterTypeMapEntry(bson.TypeEmbeddedDocument, reflect.TypeOf(bson.M{}))
 
 	return reg
 }

pagination/filter.go

@@ -2,8 +2,9 @@ package pagination
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 type MongoFilter interface {

reflectext/casting.go

@@ -5,23 +5,23 @@ import (
 )
 
 var reflectBasicTypes = map[reflect.Kind]reflect.Type{
-	reflect.Bool:       reflect.TypeFor[bool](),
+	reflect.Bool:       reflect.TypeOf(false),
-	reflect.Int:        reflect.TypeFor[int](),
+	reflect.Int:        reflect.TypeOf(int(0)),
-	reflect.Int8:       reflect.TypeFor[int8](),
+	reflect.Int8:       reflect.TypeOf(int8(0)),
-	reflect.Int16:      reflect.TypeFor[int16](),
+	reflect.Int16:      reflect.TypeOf(int16(0)),
-	reflect.Int32:      reflect.TypeFor[int32](),
+	reflect.Int32:      reflect.TypeOf(int32(0)),
-	reflect.Int64:      reflect.TypeFor[int64](),
+	reflect.Int64:      reflect.TypeOf(int64(0)),
-	reflect.Uint:       reflect.TypeFor[uint](),
+	reflect.Uint:       reflect.TypeOf(uint(0)),
-	reflect.Uint8:      reflect.TypeFor[uint8](),
+	reflect.Uint8:      reflect.TypeOf(uint8(0)),
-	reflect.Uint16:     reflect.TypeFor[uint16](),
+	reflect.Uint16:     reflect.TypeOf(uint16(0)),
-	reflect.Uint32:     reflect.TypeFor[uint32](),
+	reflect.Uint32:     reflect.TypeOf(uint32(0)),
-	reflect.Uint64:     reflect.TypeFor[uint64](),
+	reflect.Uint64:     reflect.TypeOf(uint64(0)),
-	reflect.Uintptr:    reflect.TypeFor[uintptr](),
+	reflect.Uintptr:    reflect.TypeOf(uintptr(0)),
-	reflect.Float32:    reflect.TypeFor[float32](),
+	reflect.Float32:    reflect.TypeOf(float32(0)),
-	reflect.Float64:    reflect.TypeFor[float64](),
+	reflect.Float64:    reflect.TypeOf(float64(0)),
-	reflect.Complex64:  reflect.TypeFor[complex64](),
+	reflect.Complex64:  reflect.TypeOf(complex64(0)),
-	reflect.Complex128: reflect.TypeFor[complex128](),
+	reflect.Complex128: reflect.TypeOf(complex128(0)),
-	reflect.String:     reflect.TypeFor[string](),
+	reflect.String:     reflect.TypeOf(""),
 }
 
 // Underlying returns the underlying type of t (without type alias)
@@ -48,17 +48,17 @@ func Underlying(t reflect.Type) (ret reflect.Type) {
 		nOut := t.NumOut()
 		in := make([]reflect.Type, nIn)
 		out := make([]reflect.Type, nOut)
-		for i := range nIn {
+		for i := 0; i < nIn; i++ {
 			in[i] = t.In(i)
 		}
-		for i := range nOut {
+		for i := 0; i < nOut; i++ {
 			out[i] = t.Out(i)
 		}
 		ret = reflect.FuncOf(in, out, t.IsVariadic())
 	case reflect.Interface:
 		// not supported
-	case reflect.Pointer:
+	case reflect.Ptr:
-		ret = reflect.PointerTo(t.Elem())
+		ret = reflect.PtrTo(t.Elem())
 	case reflect.Slice:
 		ret = reflect.SliceOf(t.Elem())
 	case reflect.Struct:
@@ -72,7 +72,7 @@ func Underlying(t reflect.Type) (ret reflect.Type) {
 		}()
 		n := t.NumField()
 		fields := make([]reflect.StructField, n)
-		for i := range n {
+		for i := 0; i < n; i++ {
 			fields[i] = t.Field(i)
 		}
 		ret = reflect.StructOf(fields)

reflectext/convertToMap.go

@@ -36,7 +36,7 @@ func reflectToMap(fv reflect.Value, depth int, opt ConvertStructToMapOpt) any {
 		return fv.Interface()
 	}
 
-	if fv.Kind() == reflect.Pointer {
+	if fv.Kind() == reflect.Ptr {
 
 		if fv.IsNil() {
 			return nil
@@ -57,7 +57,7 @@ func reflectToMap(fv reflect.Value, depth int, opt ConvertStructToMapOpt) any {
 
 		arrlen := fv.Len()
 		arr := make([]any, arrlen)
-		for i := range arrlen {
+		for i := 0; i < arrlen; i++ {
 			arr[i] = reflectToMap(fv.Index(i), depth+1, opt)
 		}
 		return arr
@@ -68,7 +68,7 @@ func reflectToMap(fv reflect.Value, depth int, opt ConvertStructToMapOpt) any {
 
 		arrlen := fv.Len()
 		arr := make([]any, arrlen)
-		for i := range arrlen {
+		for i := 0; i < arrlen; i++ {
 			arr[i] = reflectToMap(fv.Index(i), depth+1, opt)
 		}
 		return arr

reflectext/convertToMap_test.go

@@ -29,7 +29,7 @@ func TestConvertStructToMap(t *testing.T) {
 		FieldD:  []float64{1, 2, 3, 4, 5, 6, 7},
 		FieldE1: nil,
 		FieldE2: nil,
-		FieldE3: new(12),
+		FieldE3: langext.Ptr(12),
 		FieldE4: langext.DblPtr(12),
 		FieldE5: nil,
 		FieldE6: langext.DblPtrNil[int](),

reflectext/mapAccess.go

@@ -39,7 +39,7 @@ func GetMapField[TData any, TKey comparable](mapval any, key TKey) (TData, bool)
 
 	rval := reflect.ValueOf(mapval)
 
-	for rval.Kind() == reflect.Pointer && !rval.IsNil() {
+	for rval.Kind() == reflect.Ptr && !rval.IsNil() {
 		rval = rval.Elem()
 	}
 
@@ -58,7 +58,7 @@ func GetMapField[TData any, TKey comparable](mapval any, key TKey) (TData, bool)
 		return *new(TData), false // key does not exist in mapval
 	}
 
-	destType := reflect.TypeFor[TData]()
+	destType := reflect.TypeOf(new(TData)).Elem()
 
 	if eval.Type() == destType {
 		return eval.Interface().(TData), true
@@ -68,11 +68,11 @@ func GetMapField[TData any, TKey comparable](mapval any, key TKey) (TData, bool)
 		return eval.Convert(destType).Interface().(TData), true
 	}
 
-	if (eval.Kind() == reflect.Pointer || eval.Kind() == reflect.Interface) && eval.IsNil() && destType.Kind() == reflect.Pointer {
+	if (eval.Kind() == reflect.Ptr || eval.Kind() == reflect.Interface) && eval.IsNil() && destType.Kind() == reflect.Ptr {
 		return *new(TData), false // special case: mapval[key] is nil
 	}
 
-	for (eval.Kind() == reflect.Pointer || eval.Kind() == reflect.Interface) && !eval.IsNil() {
+	for (eval.Kind() == reflect.Ptr || eval.Kind() == reflect.Interface) && !eval.IsNil() {
 		eval = eval.Elem()
 
 		if eval.Type() == destType {

reflectext/primStrSer.go

@@ -3,34 +3,35 @@ package reflectext
 import (
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 var primitiveSerializer = map[reflect.Type]genSerializer{
 
-	reflect.TypeFor[string](): newGenSerializer(serStringToString, serStringToString),
+	reflect.TypeOf(""): newGenSerializer(serStringToString, serStringToString),
 
-	reflect.TypeFor[int]():   newGenSerializer(serIntNumToString[int], serStringToSIntNum[int]),
+	reflect.TypeOf(int(0)):   newGenSerializer(serIntNumToString[int], serStringToSIntNum[int]),
-	reflect.TypeFor[int32](): newGenSerializer(serIntNumToString[int32], serStringToSIntNum[int32]),
+	reflect.TypeOf(int32(0)): newGenSerializer(serIntNumToString[int32], serStringToSIntNum[int32]),
-	reflect.TypeFor[int64](): newGenSerializer(serIntNumToString[int64], serStringToSIntNum[int64]),
+	reflect.TypeOf(int64(0)): newGenSerializer(serIntNumToString[int64], serStringToSIntNum[int64]),
 
-	reflect.TypeFor[uint]():   newGenSerializer(serIntNumToString[uint], serStringToUIntNum[uint]),
+	reflect.TypeOf(uint(0)):   newGenSerializer(serIntNumToString[uint], serStringToUIntNum[uint]),
-	reflect.TypeFor[uint32](): newGenSerializer(serIntNumToString[uint32], serStringToUIntNum[uint32]),
+	reflect.TypeOf(uint32(0)): newGenSerializer(serIntNumToString[uint32], serStringToUIntNum[uint32]),
-	reflect.TypeFor[uint64](): newGenSerializer(serIntNumToString[uint64], serStringToUIntNum[uint64]),
+	reflect.TypeOf(uint64(0)): newGenSerializer(serIntNumToString[uint64], serStringToUIntNum[uint64]),
 
-	reflect.TypeFor[float32](): newGenSerializer(serFloatNumToString[float32], serStringToFloatNum[float32]),
+	reflect.TypeOf(float32(0)): newGenSerializer(serFloatNumToString[float32], serStringToFloatNum[float32]),
-	reflect.TypeFor[float64](): newGenSerializer(serFloatNumToString[float64], serStringToFloatNum[float64]),
+	reflect.TypeOf(float64(0)): newGenSerializer(serFloatNumToString[float64], serStringToFloatNum[float64]),
 
-	reflect.TypeFor[bool](): newGenSerializer(serBoolToString, serStringToBool),
+	reflect.TypeOf(true): newGenSerializer(serBoolToString, serStringToBool),
 
-	reflect.TypeFor[primitive.ObjectID](): newGenSerializer(serObjectIDToString, serStringToObjectID),
+	reflect.TypeOf(bson.ObjectID{}): newGenSerializer(serObjectIDToString, serStringToObjectID),
 
-	reflect.TypeFor[time.Time](): newGenSerializer(serTimeToString, serStringToTime),
+	reflect.TypeOf(time.Time{}): newGenSerializer(serTimeToString, serStringToTime),
 }
 
 type genSerializer struct {
@@ -111,15 +112,15 @@ func serStringToBool(v string) (bool, error) {
 	return false, errors.New(fmt.Sprintf("invalid boolean value '%s'", v))
 }
 
-func serObjectIDToString(v primitive.ObjectID) (string, error) {
+func serObjectIDToString(v bson.ObjectID) (string, error) {
 	return v.Hex(), nil
 }
 
-func serStringToObjectID(v string) (primitive.ObjectID, error) {
+func serStringToObjectID(v string) (bson.ObjectID, error) {
-	if rv, err := primitive.ObjectIDFromHex(v); err == nil {
+	if rv, err := bson.ObjectIDFromHex(v); err == nil {
 		return rv, nil
 	} else {
-		return primitive.ObjectID{}, err
+		return bson.ObjectID{}, err
 	}
 }
 

reflectext/primitiveStringSerializer.go

@@ -20,11 +20,11 @@ func (pss PrimitiveStringSerializer) ValueToString(v any) (string, error) {
 
 	inType := reflect.TypeOf(v)
 
-	if inType.Kind() == reflect.Pointer && langext.IsNil(v) {
+	if inType.Kind() == reflect.Ptr && langext.IsNil(v) {
 		return "", nil
 	}
 
-	if inType.Kind() == reflect.Pointer {
+	if inType.Kind() == reflect.Ptr {
 		rval1 := reflect.ValueOf(v)
 		rval2 := rval1.Elem()
 		rval3 := rval2.Interface()
@@ -46,7 +46,7 @@ func (pss PrimitiveStringSerializer) ValueToString(v any) (string, error) {
 
 func (pss PrimitiveStringSerializer) ValueFromString(str string, outType reflect.Type) (any, error) {
 
-	if outType.Kind() == reflect.Pointer && str == "" {
+	if outType.Kind() == reflect.Ptr && str == "" {
 		return reflect.Zero(outType).Interface(), nil // = nil.(outType), nil
 	}
 
@@ -54,7 +54,7 @@ func (pss PrimitiveStringSerializer) ValueFromString(str string, outType reflect
 		return reflect.Zero(outType).Interface(), nil // = <default>(outType), nil
 	}
 
-	if outType.Kind() == reflect.Pointer {
+	if outType.Kind() == reflect.Ptr {
 
 		innerValue, err := pss.ValueFromString(str, outType.Elem())
 		if err != nil {

reflectext/structAccess.go

@@ -2,6 +2,7 @@ package reflectext
 
 import (
 	"errors"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strconv"
 	"strings"
@@ -28,7 +29,7 @@ type AccessStructOpt struct {
 }
 
 func AccessJSONStruct[TResult any](v any, path string) (TResult, error) {
-	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: new("json")})
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: langext.Ptr("json")})
 }
 
 func AccessStruct[TResult any](v any, path string) (TResult, error) {
@@ -83,7 +84,7 @@ func accessStructByPath(val reflect.Value, path []string, opt AccessStructOpt) (
 
 	currPath := path[0]
 
-	if val.Kind() == reflect.Pointer {
+	if val.Kind() == reflect.Ptr {
 		if val.IsNil() {
 			if opt.ReturnNilOnNilPtrFields {
 				return nil, nil

rext/wrapper.go

@@ -1,6 +1,7 @@
 package rext
 
 import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"regexp"
 )
 
@@ -169,7 +170,7 @@ func (g OptRegexMatchGroup) ValueOrNil() *string {
 	if g.v == nil {
 		return nil
 	}
-	return new(g.v.Value())
+	return langext.Ptr(g.v.Value())
 }
 
 func (g OptRegexMatchGroup) IsEmpty() bool {

rfctime/date.go

@@ -4,14 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type Date struct {
@@ -83,8 +80,8 @@ func (t *Date) UnmarshalText(data []byte) error {
 	return t.ParseString(string(data))
 }
 
-func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *Date) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bsontype.Null {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -92,12 +89,12 @@ func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = Date{}
 		return nil
 	}
-	if bt != bsontype.String {
+	if bson.Type(bt) != bson.TypeString {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into Date", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into Date", bson.Type(bt)))
 	}
 
 	var tt string
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -120,43 +117,16 @@ func (t *Date) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t Date) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t Date) MarshalBSONValue() (byte, []byte, error) {
+	var tp bson.Type
+	var data []byte
+	var err error
 	if t.IsZero() {
-		return bson.MarshalValue("")
+		tp, data, err = bson.MarshalValue("")
-	}
-	return bson.MarshalValue(t.String())
-}
-
-func (t Date) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
 	} else {
-		val.Set(reflect.ValueOf(t))
+		tp, data, err = bson.MarshalValue(t.String())
 	}
-
+	return byte(tp), data, err
-	return nil
 }
 
 func (t Date) Serialize() string {

rfctime/rfc3339.go

@@ -4,13 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type RFC3339Time time.Time
@@ -69,8 +66,8 @@ func (t *RFC3339Time) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *RFC3339Time) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -78,11 +75,11 @@ func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = RFC3339Time{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
+	if bson.Type(bt) != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339Time", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339Time", bson.Type(bt)))
 	}
 	var tt time.Time
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -90,40 +87,9 @@ func (t *RFC3339Time) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t RFC3339Time) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t RFC3339Time) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
+	tp, data, err := bson.MarshalValue(time.Time(t))
-}
+	return byte(tp), data, err
-
-func (t RFC3339Time) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
-	} else {
-		val.Set(reflect.ValueOf(t))
-	}
-
-	return nil
 }
 
 func (t RFC3339Time) Serialize() string {
@@ -257,7 +223,7 @@ func NewRFC3339Ptr(t *time.Time) *RFC3339Time {
 	if t == nil {
 		return nil
 	}
-	return new(RFC3339Time(*t))
+	return langext.Ptr(RFC3339Time(*t))
 }
 
 func NowRFC3339() RFC3339Time {

rfctime/rfc3339Nano.go

@@ -4,12 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type RFC3339NanoTime time.Time
@@ -68,8 +66,8 @@ func (t *RFC3339NanoTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *RFC3339NanoTime) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -77,11 +75,11 @@ func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) erro
 		*t = RFC3339NanoTime{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
+	if bson.Type(bt) != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into RFC3339NanoTime", bson.Type(bt)))
 	}
 	var tt time.Time
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&tt)
 	if err != nil {
 		return err
 	}
@@ -89,40 +87,9 @@ func (t *RFC3339NanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) erro
 	return nil
 }
 
-func (t RFC3339NanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t RFC3339NanoTime) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(time.Time(t))
+	tp, data, err := bson.MarshalValue(time.Time(t))
-}
+	return byte(tp), data, err
-
-func (t RFC3339NanoTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = t.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&t))
-	} else {
-		val.Set(reflect.ValueOf(t))
-	}
-
-	return nil
 }
 
 func (t RFC3339NanoTime) Serialize() string {
@@ -256,7 +223,7 @@ func NewRFC3339NanoPtr(t *time.Time) *RFC3339NanoTime {
 	if t == nil {
 		return nil
 	}
-	return new(RFC3339NanoTime(*t))
+	return langext.Ptr(RFC3339NanoTime(*t))
 }
 
 func NowRFC3339Nano() RFC3339NanoTime {

rfctime/seconds.go

@@ -4,13 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
+
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 type SecondsF64 time.Duration
@@ -61,8 +58,8 @@ func (d SecondsF64) MarshalJSON() ([]byte, error) {
 	return json.Marshal(secs)
 }
 
-func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (d *SecondsF64) UnmarshalBSONValue(bt byte, data []byte) error {
-	if bt == bson.TypeNull {
+	if bson.Type(bt) == bson.TypeNull {
 		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
 		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
 		// https://stackoverflow.com/questions/75167597
@@ -70,11 +67,11 @@ func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*d = SecondsF64(0)
 		return nil
 	}
-	if bt != bson.TypeDouble {
+	if bson.Type(bt) != bson.TypeDouble {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bson.Type(bt)))
 	}
 	var secValue float64
-	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&secValue)
+	err := bson.RawValue{Type: bson.Type(bt), Value: data}.Unmarshal(&secValue)
 	if err != nil {
 		return err
 	}
@@ -82,40 +79,9 @@ func (d *SecondsF64) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (d SecondsF64) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (d SecondsF64) MarshalBSONValue() (byte, []byte, error) {
-	return bson.MarshalValue(d.Seconds())
+	tp, data, err := bson.MarshalValue(d.Seconds())
-}
+	return byte(tp), data, err
-
-func (d SecondsF64) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
-		if !val.CanSet() {
-			return errors.New("ValueUnmarshalerDecodeValue")
-		}
-		val.Set(reflect.New(val.Type().Elem()))
-	}
-
-	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
-		val.Set(reflect.Zero(val.Type()))
-		return nil
-	}
-
-	err = d.UnmarshalBSONValue(tp, src)
-	if err != nil {
-		return err
-	}
-
-	if val.Kind() == reflect.Pointer {
-		val.Set(reflect.ValueOf(&d))
-	} else {
-		val.Set(reflect.ValueOf(d))
-	}
-
-	return nil
 }
 
 func NewSecondsF64(t time.Duration) SecondsF64 {

rfctime/unix.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
@@ -92,7 +93,7 @@ func (t UnixTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
 }
 
 func (t UnixTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
 		if !val.CanSet() {
 			return errors.New("ValueUnmarshalerDecodeValue")
 		}
@@ -104,7 +105,7 @@ func (t UnixTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader,
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
 		val.Set(reflect.Zero(val.Type()))
 		return nil
 	}
@@ -114,7 +115,7 @@ func (t UnixTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader,
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer {
+	if val.Kind() == reflect.Ptr {
 		val.Set(reflect.ValueOf(&t))
 	} else {
 		val.Set(reflect.ValueOf(t))
@@ -250,7 +251,7 @@ func NewUnixPtr(t *time.Time) *UnixTime {
 	if t == nil {
 		return nil
 	}
-	return new(UnixTime(*t))
+	return langext.Ptr(UnixTime(*t))
 }
 
 func NowUnix() UnixTime {

rfctime/unixMilli.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
@@ -92,7 +93,7 @@ func (t UnixMilliTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
 }
 
 func (t UnixMilliTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
 		if !val.CanSet() {
 			return errors.New("ValueUnmarshalerDecodeValue")
 		}
@@ -104,7 +105,7 @@ func (t UnixMilliTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueRe
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
 		val.Set(reflect.Zero(val.Type()))
 		return nil
 	}
@@ -114,7 +115,7 @@ func (t UnixMilliTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueRe
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer {
+	if val.Kind() == reflect.Ptr {
 		val.Set(reflect.ValueOf(&t))
 	} else {
 		val.Set(reflect.ValueOf(t))
@@ -250,7 +251,7 @@ func NewUnixMilliPtr(t *time.Time) *UnixMilliTime {
 	if t == nil {
 		return nil
 	}
-	return new(UnixMilliTime(*t))
+	return langext.Ptr(UnixMilliTime(*t))
 }
 
 func NowUnixMilli() UnixMilliTime {

rfctime/unixNano.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsonrw"
@@ -92,7 +93,7 @@ func (t UnixNanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
 }
 
 func (t UnixNanoTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
-	if val.Kind() == reflect.Pointer && val.IsNil() {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
 		if !val.CanSet() {
 			return errors.New("ValueUnmarshalerDecodeValue")
 		}
@@ -104,7 +105,7 @@ func (t UnixNanoTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueRea
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer && len(src) == 0 {
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
 		val.Set(reflect.Zero(val.Type()))
 		return nil
 	}
@@ -114,7 +115,7 @@ func (t UnixNanoTime) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueRea
 		return err
 	}
 
-	if val.Kind() == reflect.Pointer {
+	if val.Kind() == reflect.Ptr {
 		val.Set(reflect.ValueOf(&t))
 	} else {
 		val.Set(reflect.ValueOf(t))
@@ -250,7 +251,7 @@ func NewUnixNanoPtr(t *time.Time) *UnixNanoTime {
 	if t == nil {
 		return nil
 	}
-	return new(UnixNanoTime(*t))
+	return langext.Ptr(UnixNanoTime(*t))
 }
 
 func NowUnixNano() UnixNanoTime {

sq/builder.go

@@ -43,7 +43,7 @@ func BuildUpdateStatement[TData any](q Queryable, tableName string, obj TData, i
 			continue
 		}
 
-		if rsfield.Type.Kind() == reflect.Pointer && rvfield.IsNil() {
+		if rsfield.Type.Kind() == reflect.Ptr && rvfield.IsNil() {
 
 			setClauses = append(setClauses, fmt.Sprintf("%s = NULL", columnName))
 
@@ -94,7 +94,7 @@ func BuildInsertStatement[TData any](q Queryable, tableName string, obj TData) (
 			continue
 		}
 
-		if rsfield.Type.Kind() == reflect.Pointer && rvfield.IsNil() {
+		if rsfield.Type.Kind() == reflect.Ptr && rvfield.IsNil() {
 
 			fields = append(fields, columnName)
 			values = append(values, "NULL")
@@ -132,8 +132,8 @@ func BuildInsertMultipleStatement[TData any](q Queryable, tableName string, vArr
 	{
 		columns := make([]string, 0)
 
-		for rsfield := range rtyp.Fields() {
+		for i := 0; i < rtyp.NumField(); i++ {
-			rsfield := rsfield
+			rsfield := rtyp.Field(i)
 
 			if !rsfield.IsExported() {
 				continue
@@ -174,7 +174,7 @@ func BuildInsertMultipleStatement[TData any](q Queryable, tableName string, vArr
 				continue
 			}
 
-			if rsfield.Type.Kind() == reflect.Pointer && rvfield.IsNil() {
+			if rsfield.Type.Kind() == reflect.Ptr && rvfield.IsNil() {
 
 				params = append(params, "NULL")
 

sq/commentTrimmer.go

@@ -11,7 +11,7 @@ func fnTrimComments(ctx context.Context, cmdtype string, id *uint16, sql *string
 
 	res := make([]string, 0)
 
-	for s := range strings.SplitSeq(*sql, "\n") {
+	for _, s := range strings.Split(*sql, "\n") {
 		if strings.HasPrefix(strings.TrimSpace(s), "--") {
 			continue
 		}

sq/converter.go

@@ -79,7 +79,7 @@ func convertValueToDB(q Queryable, value any) (any, error) {
 		}
 	}
 
-	if value != nil && reflect.TypeOf(value).Kind() == reflect.Pointer {
+	if value != nil && reflect.TypeOf(value).Kind() == reflect.Ptr {
 		vof := reflect.ValueOf(value)
 		if vof.IsNil() {
 			return nil, nil

sq/hasher.go

@@ -6,8 +6,8 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/jmoiron/sqlx"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"os"
 	"path/filepath"
 	"strings"
@@ -186,14 +186,14 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 		result = append(result, tableList[i])
 	}
 
-	var strBuilderResult strings.Builder
+	strBuilderResult := ""
 	for _, vTab := range result {
 		jbinTable, err := json.Marshal(vTab)
 		if err != nil {
 			return "", err
 		}
 
-		strBuilderResult.WriteString(fmt.Sprintf("#TABLE: %s\n{\n", string(jbinTable)))
+		strBuilderResult += fmt.Sprintf("#TABLE: %s\n{\n", string(jbinTable))
 
 		for _, vCol := range vTab.ColumnInfo {
 			jbinColumn, err := json.Marshal(vCol)
@@ -201,7 +201,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 				return "", err
 			}
 
-			strBuilderResult.WriteString(fmt.Sprintf("    COLUMN: %s\n", string(jbinColumn)))
+			strBuilderResult += fmt.Sprintf("    COLUMN: %s\n", string(jbinColumn))
 		}
 
 		for _, vIdx := range vTab.IndexInfo {
@@ -210,7 +210,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 				return "", err
 			}
 
-			strBuilderResult.WriteString(fmt.Sprintf("    INDEX:  %s\n", string(jbinIndex)))
+			strBuilderResult += fmt.Sprintf("    INDEX:  %s\n", string(jbinIndex))
 		}
 
 		for _, vFky := range vTab.FKeyInfo {
@@ -219,11 +219,11 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 				return "", err
 			}
 
-			strBuilderResult.WriteString(fmt.Sprintf("    FKEY:   %s\n", string(jbinFKey)))
+			strBuilderResult += fmt.Sprintf("    FKEY:   %s\n", string(jbinFKey))
 		}
 
-		strBuilderResult.WriteString("}\n\n")
+		strBuilderResult += "}\n\n"
 	}
 
-	return strBuilderResult.String(), nil
+	return strBuilderResult, nil
 }

sq/list.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"strings"
 )
 
 func Iterate[TData any](ctx context.Context, q Queryable, table string, filter PaginateFilter, scanMode StructScanMode, scanSec StructScanSafety, page int, limit *int, consumer func(ctx context.Context, v TData) error) (int, error) {
@@ -33,13 +32,12 @@ func Iterate[TData any](ctx context.Context, q Queryable, table string, filter P
 
 	filterCond, joinCond, joinTables := filter.SQL(prepParams)
 
-	var selectCond strings.Builder
+	selectCond := table + ".*"
-	selectCond.WriteString(table + ".*")
 	for _, v := range joinTables {
-		selectCond.WriteString(", " + v + ".*")
+		selectCond += ", " + v + ".*"
 	}
 
-	sqlQueryData := "SELECT " + selectCond.String() + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) " + sortCond + " " + pageCond
+	sqlQueryData := "SELECT " + selectCond + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) " + sortCond + " " + pageCond
 
 	rows, err := q.Query(ctx, sqlQueryData, prepParams)
 	if err != nil {

sq/paginate.go

@@ -6,7 +6,6 @@ import (
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	pag "git.blackforestbytes.com/BlackForestBytes/goext/pagination"
-	"strings"
 )
 
 func Paginate[TData any](ctx context.Context, q Queryable, table string, filter PaginateFilter, scanMode StructScanMode, scanSec StructScanSafety, page int, limit *int) ([]TData, pag.Pagination, error) {
@@ -35,13 +34,12 @@ func Paginate[TData any](ctx context.Context, q Queryable, table string, filter
 
 	filterCond, joinCond, joinTables := filter.SQL(prepParams)
 
-	var selectCond strings.Builder
+	selectCond := table + ".*"
-	selectCond.WriteString(table + ".*")
 	for _, v := range joinTables {
-		selectCond.WriteString(", " + v + ".*")
+		selectCond += ", " + v + ".*"
 	}
 
-	sqlQueryData := "SELECT " + selectCond.String() + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) " + sortCond + " " + pageCond
+	sqlQueryData := "SELECT " + selectCond + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) " + sortCond + " " + pageCond
 	sqlQueryCount := "SELECT " + "COUNT(*)" + " FROM " + table + " " + joinCond + " WHERE ( " + filterCond + " ) "
 
 	rows, err := q.Query(ctx, sqlQueryData, prepParams)

sq/params.go

@@ -1,7 +1,5 @@
 package sq
 
-import "maps"
-
 import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
 
 type PP map[string]any
@@ -9,7 +7,9 @@ type PP map[string]any
 func Join(pps ...PP) PP {
 	r := PP{}
 	for _, add := range pps {
-		maps.Copy(r, add)
+		for k, v := range add {
+			r[k] = v
+		}
 	}
 	return r
 }
@@ -21,7 +21,9 @@ func (pp *PP) Add(v any) string {
 }
 
 func (pp *PP) AddAll(other PP) {
-	maps.Copy((*pp), other)
+	for id, v := range other {
+		(*pp)[id] = v
+	}
 }
 
 func PPID() string {

sq/structscanner.go

@@ -3,9 +3,9 @@ package sq
 import (
 	"errors"
 	"fmt"
-	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/jmoiron/sqlx"
 	"github.com/jmoiron/sqlx/reflectx"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"reflect"
 	"strings"
 )
@@ -39,7 +39,7 @@ type ssConverter struct {
 func (r *StructScanner) Start(dest any) error {
 	v := reflect.ValueOf(dest)
 
-	if v.Kind() != reflect.Pointer {
+	if v.Kind() != reflect.Ptr {
 		return errors.New("must pass a pointer, not a value, to StructScan destination")
 	}
 
@@ -54,7 +54,7 @@ func (r *StructScanner) Start(dest any) error {
 	if f, err := missingFields(r.fields); err != nil && !r.unsafe {
 		return fmt.Errorf("missing destination name %s in %T", columns[f], dest)
 	}
-	r.values = make([]any, len(columns))
+	r.values = make([]interface{}, len(columns))
 	r.converter = make([]ssConverter, len(columns))
 
 	return nil
@@ -66,7 +66,7 @@ func (r *StructScanner) Start(dest any) error {
 func (r *StructScanner) StructScanExt(q Queryable, dest any) error {
 	v := reflect.ValueOf(dest)
 
-	if v.Kind() != reflect.Pointer {
+	if v.Kind() != reflect.Ptr {
 		return errors.New("must pass a pointer, not a value, to StructScan destination")
 	}
 
@@ -177,7 +177,7 @@ func (r *StructScanner) StructScanExt(q Queryable, dest any) error {
 func (r *StructScanner) StructScanBase(dest any) error {
 	v := reflect.ValueOf(dest)
 
-	if v.Kind() != reflect.Pointer {
+	if v.Kind() != reflect.Ptr {
 		return errors.New("must pass a pointer, not a value, to StructScan destination")
 	}
 
@@ -196,7 +196,7 @@ func (r *StructScanner) StructScanBase(dest any) error {
 }
 
 // fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
-func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int, values []any, converter []ssConverter) error {
+func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int, values []interface{}, converter []ssConverter) error {
 	v = reflect.Indirect(v)
 	if v.Kind() != reflect.Struct {
 		return errors.New("argument not a struct")
@@ -204,7 +204,7 @@ func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int,
 
 	for i, traversal := range traversals {
 		if len(traversal) == 0 {
-			values[i] = new(any)
+			values[i] = new(interface{})
 			continue
 		}
 		f := reflectx.FieldByIndexes(v, traversal)
@@ -243,7 +243,7 @@ func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int,
 }
 
 // fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
-func fieldsByTraversalBase(v reflect.Value, traversals [][]int, values []any, ptrs bool) error {
+func fieldsByTraversalBase(v reflect.Value, traversals [][]int, values []interface{}, ptrs bool) error {
 	v = reflect.Indirect(v)
 	if v.Kind() != reflect.Struct {
 		return errors.New("argument not a struct")
@@ -251,7 +251,7 @@ func fieldsByTraversalBase(v reflect.Value, traversals [][]int, values []any, pt
 
 	for i, traversal := range traversals {
 		if len(traversal) == 0 {
-			values[i] = new(any)
+			values[i] = new(interface{})
 			continue
 		}
 		f := reflectx.FieldByIndexes(v, traversal)

sq/transaction.go

@@ -3,8 +3,9 @@ package sq
 import (
 	"context"
 	"database/sql"
-	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"github.com/jmoiron/sqlx"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -110,7 +111,7 @@ func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Re
 
 	preMeta := PreExecMeta{Context: ctx, TransactionConstructorContext: tx.constructorContext}
 	for _, v := range tx.db.lstr {
-		err := v.PreExec(ctx, new(tx.id), &sqlstr, &prep, preMeta)
+		err := v.PreExec(ctx, langext.Ptr(tx.id), &sqlstr, &prep, preMeta)
 		if err != nil {
 			return nil, exerr.Wrap(err, "failed to call SQL pre-exec listener").Int("tx.id", int(tx.id)).Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 		}
@@ -127,7 +128,7 @@ func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Re
 
 	postMeta := PostExecMeta{Context: ctx, TransactionConstructorContext: tx.constructorContext, Init: t0, Start: t1, End: time.Now()}
 	for _, v := range tx.db.lstr {
-		v.PostExec(new(tx.id), origsql, sqlstr, prep, err, postMeta)
+		v.PostExec(langext.Ptr(tx.id), origsql, sqlstr, prep, err, postMeta)
 	}
 
 	if err != nil {
@@ -143,7 +144,7 @@ func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx
 
 	preMeta := PreQueryMeta{Context: ctx, TransactionConstructorContext: tx.constructorContext}
 	for _, v := range tx.db.lstr {
-		err := v.PreQuery(ctx, new(tx.id), &sqlstr, &prep, preMeta)
+		err := v.PreQuery(ctx, langext.Ptr(tx.id), &sqlstr, &prep, preMeta)
 		if err != nil {
 			return nil, exerr.Wrap(err, "failed to call SQL pre-query listener").Int("tx.id", int(tx.id)).Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 		}
@@ -160,7 +161,7 @@ func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx
 
 	postMeta := PostQueryMeta{Context: ctx, TransactionConstructorContext: tx.constructorContext, Init: t0, Start: t1, End: time.Now()}
 	for _, v := range tx.db.lstr {
-		v.PostQuery(new(tx.id), origsql, sqlstr, prep, err, postMeta)
+		v.PostQuery(langext.Ptr(tx.id), origsql, sqlstr, prep, err, postMeta)
 	}
 
 	if err != nil {

syncext/channel.go

@@ -1,8 +1,7 @@
 package syncext
 
 import (
-	context0 "context"
+	"golang.org/x/net/context"
-
 	"time"
 )
 
@@ -28,7 +27,7 @@ func WriteChannelWithTimeout[T any](c chan T, msg T, timeout time.Duration) bool
 	}
 }
 
-func WriteChannelWithContext[T any](ctx context0.Context, c chan T, msg T) error {
+func WriteChannelWithContext[T any](ctx context.Context, c chan T, msg T) error {
 	select {
 	case c <- msg:
 		return nil

timeext/range.go

@@ -44,15 +44,15 @@ func NewOpenTimeRange(from *time.Time, to *time.Time) *OpenTimeRange {
 	}
 }
 
-func (r OpenTimeRange) ToMongoPipeline(key string) []any {
+func (r OpenTimeRange) ToMongoPipeline(key string) []interface{} {
-	type bsonM map[string]any
+	type bsonM map[string]interface{}
 	type bsonE struct {
 		Key   string
-		Value any
+		Value interface{}
 	}
 	type bsonD []bsonE
 
-	pipeline := make([]any, 0)
+	pipeline := make([]interface{}, 0)
 
 	if r.From != nil {
 		pipeline = append(pipeline, bsonD{{Key: "$match", Value: bsonM{key: bsonM{"$ne": nil, "$gt": r.From}}}})
@@ -64,7 +64,7 @@ func (r OpenTimeRange) ToMongoPipeline(key string) []any {
 	return pipeline
 }
 
-func (r *OpenTimeRange) AppendToMongoPipeline(pipeline []any, key string) []any {
+func (r *OpenTimeRange) AppendToMongoPipeline(pipeline []interface{}, key string) []interface{} {
 	if r == nil {
 		return pipeline
 	}

timeext/weekcount.go

@@ -51,7 +51,10 @@ func GetIsoWeekCount(year int) int {
 	w2 -= 1
 	w3 -= 1
 
-	w := max(w2, w1)
+	w := w1
+	if w2 > w {
+		w = w2
+	}
 	if w3 > w {
 		w = w3
 	}

tst/assertions.go

@@ -21,7 +21,7 @@ func AssertArrayEqual[T comparable](t *testing.T, actual []T, expected []T) {
 		t.Errorf("values differ: Actual: '%v', Expected: '%v' (len %d <> %d)", actual, expected, len(actual), len(expected))
 		return
 	}
-	for i := range actual {
+	for i := 0; i < len(actual); i++ {
 		if actual[i] != expected[i] {
 			t.Errorf("values differ: Actual: '%v', Expected: '%v' (at index %d)", actual, expected, i)
 			return

wmo/collection.go

@@ -2,16 +2,16 @@ package wmo
 
 import (
 	"context"
+	"reflect"
+
 	ct "git.blackforestbytes.com/BlackForestBytes/goext/cursortoken"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"go.mongodb.org/mongo-driver/v2/mongo"
-	"go.mongodb.org/mongo-driver/mongo"
-	"reflect"
 )
 
 type EntityID interface {
-	MarshalBSONValue() (bsontype.Type, []byte, error)
+	MarshalBSONValue() (byte, []byte, error)
 	String() string
 }
 
@@ -80,7 +80,7 @@ func (c *Coll[TData]) WithDecodeFunc(cdf func(ctx context.Context, dec Decodable
 
 	c.EnsureInitializedReflection(example)
 
-	c.customDecoder = new(cdf)
+	c.customDecoder = langext.Ptr(cdf)
 	return c
 }
 

wmo/decoding.go

@@ -2,8 +2,9 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
 )
 
 func (c *Coll[TData]) decodeSingle(ctx context.Context, dec Decodable) (TData, error) {

wmo/mongo.go

@@ -1,6 +1,6 @@
 package wmo
 
-import "go.mongodb.org/mongo-driver/mongo"
+import "go.mongodb.org/mongo-driver/v2/mongo"
 
 func W[TData any](collection *mongo.Collection) *Coll[TData] {
 	c := Coll[TData]{coll: collection}

wmo/queryAggregate.go

@@ -2,13 +2,14 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/mongo"
+
-	"go.mongodb.org/mongo-driver/mongo/options"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
-func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) ([]TData, error) {
+func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) ([]TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))
@@ -29,7 +30,7 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op
 	return res, nil
 }
 
-func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) (*TData, error) {
+func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) (*TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))
@@ -53,7 +54,7 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli
 	return nil, nil
 }
 
-func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) (TData, error) {
+func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline, opts ...options.Lister[options.AggregateOptions]) (TData, error) {
 
 	for _, ppl := range c.extraModPipeline {
 		pipeline = langext.ArrConcat(pipeline, ppl(ctx))

wmo/queryDelete.go

@@ -2,9 +2,10 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/mongo"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) DeleteOneByID(ctx context.Context, id EntityID) error {

wmo/queryFind.go

@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+	"iter"
-	"go.mongodb.org/mongo-driver/mongo"
+
-	"go.mongodb.org/mongo-driver/mongo/options"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
 func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (*mongo.Cursor, error) {
@@ -51,7 +52,7 @@ func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts .
 		}
 	}
 
-	convOpts := make([]*options.AggregateOptions, 0, len(opts))
+	convOpts := make([]*options.AggregateOptionsBuilder, 0, len(opts))
 	for _, v := range opts {
 		vConv, err := convertFindOpt(v)
 		if err != nil {
@@ -60,7 +61,14 @@ func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts .
 		convOpts = append(convOpts, vConv)
 	}
 
-	cursor, err := c.coll.Aggregate(ctx, pipeline, convOpts...)
+	convOptsLister := make([]options.Lister[options.AggregateOptions], 0, len(convOpts))
+	for _, v := range convOpts {
+		if v != nil {
+			convOptsLister = append(convOptsLister, v)
+		}
+	}
+
+	cursor, err := c.coll.Aggregate(ctx, pipeline, convOptsLister...)
 	if err != nil {
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
@@ -137,7 +145,7 @@ func (c *Coll[TData]) FindIterate(ctx context.Context, filter bson.M, opts ...*o
 }
 
 // converts FindOptions to AggregateOptions
-func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
+func convertFindOpt(v *options.FindOptions) (*options.AggregateOptionsBuilder, error) {
 	if v == nil {
 		return nil, nil
 	}
@@ -157,7 +165,7 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 		r.SetCollation(v.Collation)
 	}
 	if v.Comment != nil {
-		r.SetComment(*v.Comment)
+		r.SetComment(v.Comment)
 	}
 	if v.CursorType != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'CursorType' (cannot convert to AggregateOptions)").Build()
@@ -171,9 +179,6 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 	if v.MaxAwaitTime != nil {
 		r.SetMaxAwaitTime(*v.MaxAwaitTime)
 	}
-	if v.MaxTime != nil {
-		r.SetMaxTime(*v.MaxTime)
-	}
 	if v.Min != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'Min' (cannot convert to AggregateOptions)").Build()
 	}
@@ -189,9 +194,6 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 	if v.ShowRecordID != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'ShowRecordID' (cannot convert to AggregateOptions)").Build()
 	}
-	if v.Snapshot != nil {
-		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'Snapshot' (cannot convert to AggregateOptions)").Build()
-	}
 	if v.Let != nil {
 		r.SetLet(v.Let)
 	}

wmo/queryFindOne.go

@@ -3,10 +3,11 @@ package wmo
 import (
 	"context"
 	"errors"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/mongo"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) FindOne(ctx context.Context, filter bson.M) (TData, error) {

wmo/queryInsert.go

@@ -2,10 +2,11 @@ package wmo
 
 import (
 	"context"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) InsertOne(ctx context.Context, valueIn TData) (TData, error) {
@@ -41,7 +42,7 @@ func (c *Coll[TData]) InsertOneUnchecked(ctx context.Context, valueIn any) (TDat
 
 func (c *Coll[TData]) InsertMany(ctx context.Context, valueIn []TData) (*mongo.InsertManyResult, error) {
 	for _, hook := range c.marshalHooks {
-		for i := range valueIn {
+		for i := 0; i < len(valueIn); i++ {
 			valueIn[i] = hook(valueIn[i])
 		}
 	}

wmo/queryList.go

@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+	"iter"
-	"go.mongodb.org/mongo-driver/mongo"
+
 	ct "git.blackforestbytes.com/BlackForestBytes/goext/cursortoken"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, inTok ct.CursorToken) ([]TData, ct.CursorToken, error) {

wmo/queryPaginate.go

@@ -2,12 +2,13 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+	"iter"
-	"go.mongodb.org/mongo-driver/mongo"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	pag "git.blackforestbytes.com/BlackForestBytes/goext/pagination"
-	"iter"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.MongoFilter, page int, limit *int) ([]TData, pag.Pagination, error) {

wmo/queryUpdate.go

@@ -2,10 +2,11 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
+
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
 
 func (c *Coll[TData]) FindOneAndUpdate(ctx context.Context, filterQuery bson.M, updateQuery bson.M) (TData, error) {

wmo/reflection.go

@@ -34,7 +34,7 @@ func (c *Coll[TData]) init() {
 
 	example := *new(TData)
 
-	datatype := reflect.TypeFor[TData]()
+	datatype := reflect.TypeOf(&example).Elem()
 
 	if datatype.Kind() == reflect.Interface {