Merge remote-tracking branch 'origin/feature/mongo-driver-v2' into feature/mongo-driver-v2

# Conflicts:
#	exerr/constructor.go
#	exerr/dataCategory.go
#	exerr/dataSeverity.go
#	exerr/dataType.go
#	exerr/exerr.go
#	go.mod
#	mongoext/registry.go
#	reflectext/primStrSer.go
#	rfctime/date.go
#	rfctime/rfc3339.go
#	rfctime/rfc3339Nano.go
#	rfctime/seconds.go
#	rfctime/unix.go
#	rfctime/unixMilli.go
#	rfctime/unixNano.go
#	wmo/collection.go
#	wmo/queryInsert.go

cursortoken/filter.go

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

cursortoken/tokenKeySort.go

@@ -3,7 +3,7 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
 	"time"
 )
 
@@ -119,18 +119,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
 	}
 }

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)
 }
 

exerr/constructor.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
 	"maps"
 	"reflect"
 	"time"
@@ -222,7 +222,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}}

exerr/dataCategory.go

@@ -4,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 )
 
 type ErrorCategory struct{ Category string }
@@ -28,8 +24,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 +33,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 +45,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,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 )
 
 type ErrorSeverity struct{ Severity string }
@@ -30,8 +26,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 +35,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 +47,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,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 
 	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type ErrorType struct {
@@ -80,8 +76,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 +85,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 +103,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,10 +3,9 @@ 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"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 	"testing"
 	"time"
 )
@@ -57,7 +56,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 +67,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 +75,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 +89,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 +100,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 +108,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 +122,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 +133,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 +141,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"
-	"reflect"
-	"strings"
-	"time"
-
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
+	"reflect"
+	"strings"
+	"time"
 )
 
 type ExErr struct {

exerr/meta.go

@@ -7,8 +7,7 @@ import (
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"github.com/rs/zerolog"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"math"
 	"strconv"
 	"strings"
@@ -99,7 +98,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 +177,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 +265,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:
@@ -460,7 +459,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 +576,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 +627,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 +653,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

go.mod

@@ -8,7 +8,7 @@ require (
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.6.0
 	github.com/rs/zerolog v1.35.1
-	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,7 @@ 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/sync v0.20.0
 )
 
@@ -64,7 +65,6 @@ 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

gojson/decode_test.go

@@ -108,11 +108,11 @@ func (u unmarshalerText) MarshalText() ([]byte, error) {
 }
 
 func (u *unmarshalerText) UnmarshalText(b []byte) error {
-	pos := bytes.IndexByte(b, ':')
+	before, after, ok := bytes.Cut(b, []byte{':'})
-	if pos == -1 {
+	if !ok {
 		return errors.New("missing separator")
 	}
-	u.A, u.B = string(b[:pos]), string(b[pos+1:])
+	u.A, u.B = string(before), string(after)
 	return nil
 }
 
@@ -126,7 +126,7 @@ type ustructText struct {
 type u8marshal uint8
 
 func (u8 u8marshal) MarshalText() ([]byte, error) {
-	return []byte(fmt.Sprintf("u%d", u8)), nil
+	return fmt.Appendf(nil, "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 []byte(fmt.Sprintf(`"Z%.2x"`, byte(b))), nil
+	return fmt.Appendf(nil, `"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 []byte(fmt.Sprintf(`Z%.2x`, byte(b))), nil
+	return fmt.Appendf(nil, `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 []byte(fmt.Sprintf(`"Z%.2x"`, int(b))), nil
+	return fmt.Appendf(nil, `"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 []byte(fmt.Sprintf(`Z%.2x`, int(b))), nil
+	return fmt.Appendf(nil, `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 interface{}, nilSafeSlices bool, nilSafeMaps bool, indent *IndentOpt, filter *string) ([]byte, error) {
+func MarshalSafeCollections(v any, 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 interface{} // always an unsafe.Pointer, but avoids a dependency on package unsafe
+			ptr any // 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 := 0; i < n; i++ {
+	for i := range n {
 		if i > 0 {
 			e.WriteByte(',')
 		}
@@ -1075,10 +1075,7 @@ 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 := len(src) - i
+		n := min(len(src)-i, utf8.UTFMax)
-		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]...)
@@ -1130,12 +1127,7 @@ type field struct {
 type jsonfilter []string
 
 func (j jsonfilter) Contains(t string) bool {
-	for _, tag := range j {
+	return slices.Contains(j, t)
-		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,omitempty"`
+	Sto struct{} `json:"sto"`
 }
 
 func TestOmitEmpty(t *testing.T) {
@@ -1166,8 +1166,7 @@ func TestMarshalUncommonFieldNames(t *testing.T) {
 }
 
 func TestMarshalerError(t *testing.T) {
-	s := "test variable"
+	st := reflect.TypeFor[string]()
-	st := reflect.TypeOf(s)
 	const errText = "json: test error"
 
 	tests := []struct {
@@ -1222,18 +1221,18 @@ func TestIssue63379(t *testing.T) {
 
 func TestMarshalSafeCollections(t *testing.T) {
 	var (
-		nilSlice  []interface{}
+		nilSlice  []any
-		pNilSlice *[]interface{}
+		pNilSlice *[]any
-		nilMap    map[string]interface{}
+		nilMap    map[string]any
-		pNilMap   *map[string]interface{}
+		pNilMap   *map[string]any
 	)
 
 	type (
 		nilSliceStruct struct {
-			NilSlice []interface{} `json:"nil_slice"`
+			NilSlice []any `json:"nil_slice"`
 		}
 		nilMapStruct struct {
-			NilMap map[string]interface{} `json:"nil_map"`
+			NilMap map[string]any `json:"nil_map"`
 		}
 		testWithFilter struct {
 			Test1 string `json:"test1" jsonfilter:"FILTERONE"`
@@ -1242,19 +1241,19 @@ func TestMarshalSafeCollections(t *testing.T) {
 	)
 
 	tests := []struct {
-		in   interface{}
+		in   any
 		want string
 	}{
 		{nilSlice, "[]"},
-		{[]interface{}{}, "[]"},
+		{[]any{}, "[]"},
-		{make([]interface{}, 0), "[]"},
+		{make([]any, 0), "[]"},
 		{[]int{1, 2, 3}, "[1,2,3]"},
 		{pNilSlice, "null"},
 		{nilSliceStruct{}, "{\"nil_slice\":[]}"},
 		{nilMap, "{}"},
-		{map[string]interface{}{}, "{}"},
+		{map[string]any{}, "{}"},
-		{make(map[string]interface{}, 0), "{}"},
+		{make(map[string]any, 0), "{}"},
-		{map[string]interface{}{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}"},
+		{map[string]any{"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() interface{}{
+		for _, typ := range []func() any{
-			func() interface{} { return new(interface{}) },
+			func() any { return new(any) },
-			func() interface{} { return new(map[string]interface{}) },
+			func() any { return new(map[string]any) },
-			func() interface{} { return new([]interface{}) },
+			func() any { return new([]any) },
 		} {
 			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 i := 0; i < depth; i++ {
+	for range depth {
 		dst = append(dst, indent...)
 	}
 	return dst

gojson/scanner_test.go

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

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,7 +1,7 @@
 package mongoext
 
 import (
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
 	"reflect"
 	"strings"
 )

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.TypeFor[bson.M]())
 
 	return reg
 }

pagination/filter.go

@@ -2,8 +2,8 @@ package pagination
 
 import (
 	"context"
-	"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"
 )
 
 type MongoFilter interface {

reflectext/primStrSer.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
 	"reflect"
 	"strconv"
 	"strings"
@@ -28,7 +28,7 @@ var primitiveSerializer = map[reflect.Type]genSerializer{
 
 	reflect.TypeFor[bool](): newGenSerializer(serBoolToString, serStringToBool),
 
-	reflect.TypeFor[primitive.ObjectID](): newGenSerializer(serObjectIDToString, serStringToObjectID),
+	reflect.TypeFor[bson.ObjectID](): newGenSerializer(serObjectIDToString, serStringToObjectID),
 
 	reflect.TypeFor[time.Time](): newGenSerializer(serTimeToString, serStringToTime),
 }
@@ -111,15 +111,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
 	}
 }
 

rfctime/date.go

@@ -4,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/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"
@@ -83,8 +79,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 +88,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 +116,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,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"reflect"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type RFC3339Time time.Time
@@ -69,8 +65,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 +74,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 +86,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 {

rfctime/rfc3339Nano.go

@@ -4,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
 )
 
@@ -68,8 +64,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 +73,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 +85,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 {

rfctime/seconds.go

@@ -5,11 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"time"
 )
 
@@ -61,8 +57,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 +66,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 +78,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,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"strconv"
 	"time"
 )
@@ -66,8 +62,8 @@ func (t *UnixTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *UnixTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *UnixTime) 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
@@ -75,11 +71,11 @@ func (t *UnixTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = UnixTime{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
+	if bson.Type(bt) != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixTime", 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
 	}
@@ -87,40 +83,9 @@ func (t *UnixTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t UnixTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t UnixTime) 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 UnixTime) 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 UnixTime) Serialize() string {

rfctime/unixMilli.go

@@ -4,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"strconv"
 	"time"
 )
@@ -66,8 +62,8 @@ func (t *UnixMilliTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *UnixMilliTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *UnixMilliTime) 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
@@ -75,11 +71,11 @@ func (t *UnixMilliTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 		*t = UnixMilliTime{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
+	if bson.Type(bt) != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixMilliTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixMilliTime", 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
 	}
@@ -87,40 +83,9 @@ func (t *UnixMilliTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error
 	return nil
 }
 
-func (t UnixMilliTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t UnixMilliTime) 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 UnixMilliTime) 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 UnixMilliTime) Serialize() string {

rfctime/unixNano.go

@@ -4,11 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/bson/bsoncodec"
-	"go.mongodb.org/mongo-driver/bson/bsonrw"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
-	"reflect"
 	"strconv"
 	"time"
 )
@@ -66,8 +62,8 @@ func (t *UnixNanoTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
-func (t *UnixNanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+func (t *UnixNanoTime) 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
@@ -75,11 +71,11 @@ func (t *UnixNanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 		*t = UnixNanoTime{}
 		return nil
 	}
-	if bt != bson.TypeDateTime {
+	if bson.Type(bt) != bson.TypeDateTime {
-		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixNanoTime", bt))
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixNanoTime", 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
 	}
@@ -87,40 +83,9 @@ func (t *UnixNanoTime) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
 	return nil
 }
 
-func (t UnixNanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+func (t UnixNanoTime) 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 UnixNanoTime) 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 UnixNanoTime) Serialize() string {

wmo/collection.go

@@ -5,13 +5,12 @@ import (
 	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
 }
 

wmo/decoding.go

@@ -2,8 +2,8 @@ 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,13 @@ 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 +29,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 +53,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,9 @@ 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,11 +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"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo/options"
 	"iter"
 )
 
@@ -51,13 +51,15 @@ func (c *Coll[TData]) createFindQuery(ctx context.Context, filter bson.M, opts .
 		}
 	}
 
-	convOpts := make([]*options.AggregateOptions, 0, len(opts))
+	convOpts := make([]options.Lister[options.AggregateOptions], 0, len(opts))
 	for _, v := range opts {
 		vConv, err := convertFindOpt(v)
 		if err != nil {
 			return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 		}
-		convOpts = append(convOpts, vConv)
+		if vConv != nil {
+			convOpts = append(convOpts, vConv)
+		}
 	}
 
 	cursor, err := c.coll.Aggregate(ctx, pipeline, convOpts...)
@@ -137,7 +139,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 +159,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()
@@ -165,33 +167,18 @@ func convertFindOpt(v *options.FindOptions) (*options.AggregateOptions, error) {
 	if v.Hint != nil {
 		r.SetHint(v.Hint)
 	}
-	if v.Max != nil {
-		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'Max' (cannot convert to AggregateOptions)").Build()
-	}
 	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()
-	}
 	if v.NoCursorTimeout != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'NoCursorTimeout' (cannot convert to AggregateOptions)").Build()
 	}
-	if v.OplogReplay != nil {
-		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'OplogReplay' (cannot convert to AggregateOptions)").Build()
-	}
 	if v.ReturnKey != nil {
 		return nil, exerr.New(exerr.TypeMongoInvalidOpt, "Invalid option 'ReturnKey' (cannot convert to AggregateOptions)").Build()
 	}
 	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,10 @@ 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

@@ -4,8 +4,8 @@ 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) {

wmo/queryList.go

@@ -2,11 +2,11 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"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"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 	"iter"
 )
 

wmo/queryPaginate.go

@@ -2,11 +2,11 @@ package wmo
 
 import (
 	"context"
-	"go.mongodb.org/mongo-driver/bson"
-	"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"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 	"iter"
 )
 

wmo/queryUpdate.go

@@ -2,10 +2,10 @@ 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_test.go

@@ -9,8 +9,8 @@ import (
 	"git.blackforestbytes.com/BlackForestBytes/goext/rfctime"
 	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 )
 
 func TestReflectionGetFieldType(t *testing.T) {
@@ -234,8 +234,8 @@ func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
 func TestReflectionWithInterface(t *testing.T) {
 
 	type TestData struct {
-		ID    primitive.ObjectID `bson:"_id"`
+		ID    bson.ObjectID `bson:"_id"`
-		CDate time.Time          `bson:"cdate"`
+		CDate time.Time     `bson:"cdate"`
 	}
 
 	type TestInterface any

wpdf/wpdfTable.go

@@ -1,11 +1,12 @@
 package wpdf
 
 import (
+	"regexp"
+	"strconv"
+
 	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
 	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
-	"regexp"
-	"strconv"
 )
 
 // Column specifier:
@@ -298,7 +299,7 @@ func (b *TableBuilder) calculateColumns() []float64 {
 
 	if remainingWidth > 0.01 {
 		rmSub := 0.0
-		for i, _ := range columnDef {
+		for i := range columnDef {
 			if frColumnWeights[i] != 0 {
 				addW := (remainingWidth / float64(frColumnWidthCount)) * frColumnWeights[i]
 				rmSub += addW