v0.0.133

2023-06-06 21:18:40 +02:00
parent 1fbae343a4
commit c338d23070
14 changed files with 1076 additions and 9 deletions
--- a/wmo/mongo.go
+++ b/wmo/mongo.go
@@ -0,0 +1,11 @@
+package wmo
+
+import "go.mongodb.org/mongo-driver/mongo"
+
+func W[TData any](collection *mongo.Collection) *Coll[TData] {
+	c := Coll[TData]{coll: collection}
+
+	c.init()
+
+	return &c
+}
--- a/wmo/pagination.go
+++ b/wmo/pagination.go
@@ -0,0 +1,69 @@
+package wmo
+
+import (
+	"go.mongodb.org/mongo-driver/bson"
+	ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken"
+)
+
+func CreatePagination[TData any](coll *Coll[TData], token ct.CursorToken, fieldPrimary string, sortPrimary ct.SortDirection, fieldSecondary *string, sortSecondary *ct.SortDirection, pageSize *int) ([]bson.D, error) {
+
+	cond := bson.A{}
+	sort := bson.D{}
+
+	valuePrimary, err := coll.getTokenValueAsMongoType(token.ValuePrimary, fieldPrimary)
+	if err != nil {
+		return nil, err
+	}
+
+	if sortPrimary == ct.SortASC {
+		// We sort ASC on <field> - so we want all entries newer ($gt) than the $primary
+		cond = append(cond, bson.M{fieldPrimary: bson.M{"$gt": valuePrimary}})
+		sort = append(sort, bson.E{Key: fieldPrimary, Value: +1})
+	} else if sortPrimary == ct.SortDESC {
+		// We sort DESC on <field> - so we want all entries older ($lt) than the $primary
+		cond = append(cond, bson.M{fieldPrimary: bson.M{"$lt": valuePrimary}})
+		sort = append(sort, bson.E{Key: fieldPrimary, Value: -1})
+	}
+
+	if fieldSecondary != nil && sortSecondary != nil && *fieldSecondary != fieldPrimary {
+
+		valueSecondary, err := coll.getTokenValueAsMongoType(token.ValueSecondary, *fieldSecondary)
+		if err != nil {
+			return nil, err
+		}
+
+		if *sortSecondary == ct.SortASC {
+
+			// the conflict-resolution condition, for entries with the _same_ <field> as the $primary we take the ones with a greater $secondary (= newer)
+			cond = append(cond, bson.M{"$and": bson.A{
+				bson.M{fieldPrimary: valuePrimary},
+				bson.M{*fieldSecondary: bson.M{"$gt": valueSecondary}},
+			}})
+
+			sort = append(sort, bson.E{Key: fieldPrimary, Value: +1})
+
+		} else if *sortSecondary == ct.SortDESC {
+
+			// the conflict-resolution condition, for entries with the _same_ <field> as the $primary we take the ones with a smaller $secondary (= older)
+			cond = append(cond, bson.M{"$and": bson.A{
+				bson.M{fieldPrimary: valuePrimary},
+				bson.M{*fieldSecondary: bson.M{"$lt": valueSecondary}},
+			}})
+
+			sort = append(sort, bson.E{Key: fieldPrimary, Value: -1})
+
+		}
+	}
+
+	pipeline := make([]bson.D, 0, 3)
+
+	pipeline = append(pipeline, bson.D{{Key: "$match", Value: bson.M{"$or": cond}}})
+
+	pipeline = append(pipeline, bson.D{{Key: "$sort", Value: sort}})
+
+	if pageSize != nil {
+		pipeline = append(pipeline, bson.D{{Key: "$limit", Value: int64(*pageSize + 1)}})
+	}
+
+	return pipeline, nil
+}
--- a/wmo/reflection.go
+++ b/wmo/reflection.go
@@ -0,0 +1,294 @@
+package wmo
+
+import (
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+func (c *Coll[TData]) init() {
+
+	c.dataTypeMap = make(map[string]fullTypeRef[TData])
+
+	example := *new(TData)
+
+	v := reflect.ValueOf(example)
+
+	c.initFields("", v, make([]int, 0))
+
+}
+
+func (c *Coll[TData]) initFields(prefix string, rval reflect.Value, idxarr []int) {
+
+	rtyp := rval.Type()
+
+	for i := 0; i < rtyp.NumField(); i++ {
+
+		rsfield := rtyp.Field(i)
+		rvfield := rval.Field(i)
+
+		if !rsfield.IsExported() {
+			continue
+		}
+
+		bsonkey, found := rsfield.Tag.Lookup("bson")
+		if !found || bsonkey == "-" {
+			continue
+		}
+
+		fullKey := prefix + bsonkey
+
+		newIdxArr := langext.ArrCopy(idxarr)
+		newIdxArr = append(newIdxArr, i)
+
+		if rvfield.Type().Kind() == reflect.Pointer {
+
+			c.dataTypeMap[fullKey] = fullTypeRef[TData]{
+				IsPointer:      true,
+				Kind:           rvfield.Type().Elem().Kind(),
+				Type:           rvfield.Type().Elem(),
+				UnderlyingType: langext.Underlying(rvfield.Type().Elem()),
+				Name:           rsfield.Name,
+				Index:          newIdxArr,
+			}
+
+		} else {
+
+			c.dataTypeMap[fullKey] = fullTypeRef[TData]{
+				IsPointer:      false,
+				Kind:           rvfield.Type().Kind(),
+				Type:           rvfield.Type(),
+				UnderlyingType: langext.Underlying(rvfield.Type()),
+				Name:           rsfield.Name,
+				Index:          newIdxArr,
+			}
+
+		}
+
+		if rvfield.Kind() == reflect.Struct {
+			c.initFields(fullKey+".", rvfield, newIdxArr)
+		}
+
+	}
+
+}
+
+func (c *Coll[TData]) getTokenValueAsMongoType(value string, fieldName string) (any, error) {
+	fref := c.dataTypeMap[fieldName]
+
+	if fref.IsPointer && value == "" {
+		pointertype := reflect.New(fref.Type).Type()
+		nilvalue := reflect.Zero(pointertype)
+		outvalue := nilvalue.Interface()
+		return outvalue, nil
+	}
+
+	pointerize := func(v any) any {
+		if !fref.IsPointer {
+			return v
+		}
+
+		rval1 := reflect.ValueOf(v)
+		rval2 := rval1.Convert(fref.Type)
+		rval3 := reflect.New(fref.Type)
+		rval3.Elem().Set(rval2)
+		return rval3.Interface()
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf("") {
+
+		rt, ok := langext.TryCastType(value, fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from string to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(time.Time{}) {
+
+		t, err := time.Parse(time.RFC3339Nano, value)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as time.Time ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(t, fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from time.Time to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int(0)) {
+
+		t, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int64 ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(int(t), fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int32(0)) {
+
+		t, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int32 ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(int32(t), fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int32 to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int64(0)) {
+
+		t, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as int64 ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(int64(t), fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from int64 to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(float32(0)) {
+
+		t, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as float32 ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(float32(t), fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from float32 to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(float64(0)) {
+
+		t, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' as float64 ('%s')", fieldName, value))
+		}
+
+		rt, ok := langext.TryCastType(float64(t), fref.Type)
+		if !ok {
+			return nil, errors.New(fmt.Sprintf("failed to parse field '%s' from float64 to %s", fieldName, fref.Type.String()))
+		}
+
+		return pointerize(rt), nil
+	}
+
+	return nil, errors.New(fmt.Sprintf("failed to parse field '%s' of type %s (%s)", fieldName, fref.Type.String(), fref.UnderlyingType.String()))
+}
+
+func (c *Coll[TData]) getFieldValueAsTokenString(entity TData, fieldName string) (string, error) {
+	fref := c.dataTypeMap[fieldName]
+
+	realValue := c.getFieldValue(entity, fieldName)
+
+	if langext.IsNil(realValue) {
+		return "", nil
+	}
+
+	reflValue := reflect.ValueOf(realValue)
+	if reflValue.Kind() == reflect.Pointer {
+		reflValue = reflValue.Elem()
+		realValue = reflValue.Interface()
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf("") {
+
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(""))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to string", fieldName, fref.Type.String()))
+		}
+
+		return rt.(string), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(time.Time{}) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(time.Time{}))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to time.Time", fieldName, fref.Type.String()))
+		}
+
+		return rt.(time.Time).Format(time.RFC3339Nano), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int(0)) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int(0)))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int", fieldName, fref.Type.String()))
+		}
+
+		return strconv.Itoa(rt.(int)), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int32(0)) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int32(0)))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int32", fieldName, fref.Type.String()))
+		}
+
+		return strconv.FormatInt(int64(rt.(int32)), 10), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(int64(0)) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(int64(0)))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to int64", fieldName, fref.Type.String()))
+		}
+
+		return strconv.FormatInt(rt.(int64), 10), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(float32(0)) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(float32(0)))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to float32", fieldName, fref.Type.String()))
+		}
+
+		return strconv.FormatFloat(float64(rt.(float32)), 'f', -1, 32), nil
+	}
+
+	if fref.UnderlyingType == reflect.TypeOf(float64(0)) {
+		rt, ok := langext.TryCastType(realValue, reflect.TypeOf(float64(0)))
+		if !ok {
+			return "", errors.New(fmt.Sprintf("failed to cast field '%s' from %s to float64", fieldName, fref.Type.String()))
+		}
+
+		return strconv.FormatFloat(rt.(float64), 'f', -1, 64), nil
+	}
+
+	return "", errors.New(fmt.Sprintf("failed to parse field '%s' of type %s (%s)", fieldName, fref.Type.String(), fref.UnderlyingType.String()))
+}
+
+func (c *Coll[TData]) getFieldType(fieldName string) fullTypeRef[TData] {
+	return c.dataTypeMap[fieldName]
+}
+
+func (c *Coll[TData]) getFieldValue(data TData, fieldName string) any {
+	fref := c.dataTypeMap[fieldName]
+	rval := reflect.ValueOf(data)
+	return rval.FieldByIndex(fref.Index).Interface()
+}
--- a/wmo/reflection_test.go
+++ b/wmo/reflection_test.go
@@ -0,0 +1,160 @@
+package wmo
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"testing"
+	"time"
+)
+
+func TestReflectionGetFieldType(t *testing.T) {
+
+	type IDType string
+
+	type TestData struct {
+		ID    IDType    `bson:"_id"`
+		CDate time.Time `bson:"cdate"`
+		Sub   struct {
+			A string `bson:"a"`
+		} `bson:"sub"`
+		Str string `bson:"str"`
+		Ptr *int   `bson:"ptr"`
+	}
+
+	coll := W[TestData](&mongo.Collection{})
+
+	coll.init()
+
+	t0 := time.Now()
+
+	d := TestData{
+		ID:    "1",
+		CDate: t0,
+		Sub: struct {
+			A string `bson:"a"`
+		}{
+			A: "2",
+		},
+		Str: "3",
+		Ptr: langext.Ptr(4),
+	}
+
+	tst.AssertEqual(t, coll.getFieldType("_id").Kind.String(), "string")
+	tst.AssertEqual(t, coll.getFieldType("_id").Type.String(), "wmo.IDType")
+	tst.AssertEqual(t, coll.getFieldType("_id").Name, "ID")
+	tst.AssertEqual(t, coll.getFieldType("_id").IsPointer, false)
+	tst.AssertEqual(t, coll.getFieldValue(d, "_id").(IDType), "1")
+
+	tst.AssertEqual(t, coll.getFieldType("cdate").Kind.String(), "struct")
+	tst.AssertEqual(t, coll.getFieldType("cdate").Type.String(), "time.Time")
+	tst.AssertEqual(t, coll.getFieldType("cdate").Name, "CDate")
+	tst.AssertEqual(t, coll.getFieldType("cdate").IsPointer, false)
+	tst.AssertEqual(t, coll.getFieldValue(d, "cdate").(time.Time), t0)
+
+	tst.AssertEqual(t, coll.getFieldType("sub.a").Kind.String(), "string")
+	tst.AssertEqual(t, coll.getFieldType("sub.a").Type.String(), "string")
+	tst.AssertEqual(t, coll.getFieldType("sub.a").Name, "A")
+	tst.AssertEqual(t, coll.getFieldType("sub.a").IsPointer, false)
+	tst.AssertEqual(t, coll.getFieldValue(d, "sub.a").(string), "2")
+
+	tst.AssertEqual(t, coll.getFieldType("str").Kind.String(), "string")
+	tst.AssertEqual(t, coll.getFieldType("str").Type.String(), "string")
+	tst.AssertEqual(t, coll.getFieldType("str").Name, "Str")
+	tst.AssertEqual(t, coll.getFieldType("str").IsPointer, false)
+	tst.AssertEqual(t, coll.getFieldValue(d, "str").(string), "3")
+
+	tst.AssertEqual(t, coll.getFieldType("ptr").Kind.String(), "int")
+	tst.AssertEqual(t, coll.getFieldType("ptr").Type.String(), "int")
+	tst.AssertEqual(t, coll.getFieldType("ptr").Name, "Ptr")
+	tst.AssertEqual(t, coll.getFieldType("ptr").IsPointer, true)
+	tst.AssertEqual(t, *coll.getFieldValue(d, "ptr").(*int), 4)
+}
+
+func TestReflectionGetTokenValueAsMongoType(t *testing.T) {
+
+	type IDType string
+
+	type TestData struct {
+		ID    IDType    `bson:"_id"`
+		CDate time.Time `bson:"cdate"`
+		Sub   struct {
+			A string `bson:"a"`
+		} `bson:"sub"`
+		Str string `bson:"str"`
+		Ptr *int   `bson:"ptr"`
+		Num int    `bson:"num"`
+	}
+
+	coll := W[TestData](&mongo.Collection{})
+
+	coll.init()
+
+	gtvasmt := func(value string, fieldName string) any {
+		v, err := coll.getTokenValueAsMongoType(value, fieldName)
+		if err != nil {
+			t.Errorf("%s", "failed to getTokenValueAsMongoType")
+		}
+		return v
+	}
+
+	tst.AssertEqual(t, gtvasmt("hello", "str").(string), "hello")
+	tst.AssertEqual(t, gtvasmt("4", "num").(int), 4)
+	tst.AssertEqual(t, gtvasmt("asdf", "_id").(IDType), "asdf")
+	tst.AssertEqual(t, gtvasmt("", "ptr").(*int), nil)
+	tst.AssertEqual(t, *(gtvasmt("123", "ptr").(*int)), 123)
+}
+
+func TestReflectionGetFieldValueAsTokenString(t *testing.T) {
+
+	type IDType string
+
+	type TestData struct {
+		ID    IDType    `bson:"_id"`
+		CDate time.Time `bson:"cdate"`
+		Sub   struct {
+			A string `bson:"a"`
+		} `bson:"sub"`
+		Str  string  `bson:"str"`
+		Ptr  *int    `bson:"ptr"`
+		Num  int     `bson:"num"`
+		Ptr2 *int    `bson:"ptr2"`
+		FFF  float64 `bson:"fff"`
+	}
+
+	coll := W[TestData](&mongo.Collection{})
+
+	coll.init()
+
+	t0 := time.Now()
+
+	d := TestData{
+		ID:    "1",
+		CDate: t0,
+		Sub: struct {
+			A string `bson:"a"`
+		}{
+			A: "2",
+		},
+		Str:  "3",
+		Ptr:  langext.Ptr(4),
+		Num:  22,
+		FFF:  22.5,
+		Ptr2: nil,
+	}
+
+	gfvats := func(value TestData, fieldName string) string {
+		v, err := coll.getFieldValueAsTokenString(value, fieldName)
+		if err != nil {
+			t.Errorf("%s", "failed to getTokenValueAsMongoType")
+		}
+		return v
+	}
+
+	tst.AssertEqual(t, gfvats(d, "str"), "3")
+	tst.AssertEqual(t, gfvats(d, "num"), "22")
+	tst.AssertEqual(t, gfvats(d, "_id"), "1")
+	tst.AssertEqual(t, gfvats(d, "ptr"), "4")
+	tst.AssertEqual(t, gfvats(d, "ptr2"), "")
+	tst.AssertEqual(t, gfvats(d, "fff"), "22.5")
+}
--- a/wmo/wrapper.go
+++ b/wmo/wrapper.go
@@ -0,0 +1,231 @@
+package wmo
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+)
+
+type fullTypeRef[TData any] struct {
+	IsPointer      bool
+	Kind           reflect.Kind
+	Type           reflect.Type
+	UnderlyingType reflect.Type
+	Name           string
+	Index          []int
+}
+
+type Coll[TData any] struct {
+	coll        *mongo.Collection
+	dataTypeMap map[string]fullTypeRef[TData]
+}
+
+func (c *Coll[TData]) Collection() *mongo.Collection {
+	return c.coll
+}
+
+func (c *Coll[TData]) Name() string {
+	return c.coll.Name()
+}
+
+func (c *Coll[TData]) Indexes() mongo.IndexView {
+	return c.coll.Indexes()
+}
+
+func (c *Coll[TData]) Drop(ctx context.Context) error {
+	return c.coll.Drop(ctx)
+}
+
+func (c *Coll[TData]) FindOne(ctx context.Context, filter any) (TData, error) {
+	var res TData
+
+	err := c.coll.FindOne(ctx, filter).Decode(&res)
+	if err != nil {
+		return *new(TData), err
+	}
+
+	return res, nil
+}
+
+func (c *Coll[TData]) FindOneOpt(ctx context.Context, filter any) (*TData, error) {
+	var res TData
+
+	err := c.coll.FindOne(ctx, filter).Decode(&res)
+	if err == mongo.ErrNoDocuments {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (c *Coll[TData]) FindOneByID(ctx context.Context, id any) (TData, error) {
+	var res TData
+
+	err := c.coll.FindOne(ctx, bson.M{"_id": id}).Decode(&res)
+	if err != nil {
+		return *new(TData), err
+	}
+
+	return res, nil
+}
+
+func (c *Coll[TData]) FindOneOptByID(ctx context.Context, id any) (*TData, error) {
+	var res TData
+
+	err := c.coll.FindOne(ctx, bson.M{"_id": id}).Decode(&res)
+	if err == mongo.ErrNoDocuments {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &res, nil
+}
+
+func (c *Coll[TData]) Find(ctx context.Context, filter any, opts ...*options.FindOptions) ([]TData, error) {
+	cursor, err := c.coll.Find(ctx, filter, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]TData, 0, cursor.RemainingBatchLength())
+	err = cursor.All(ctx, &res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) ([]TData, error) {
+	cursor, err := c.coll.Aggregate(ctx, pipeline, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]TData, 0, cursor.RemainingBatchLength())
+	err = cursor.All(ctx, &res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (c *Coll[TData]) ReplaceOne(ctx context.Context, id any, value TData) error {
+	_, err := c.coll.UpdateOne(ctx, bson.M{"_id": id}, value)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Coll[TData]) UpdateOne(ctx context.Context, id any, updateQuery any) error {
+	_, err := c.coll.UpdateOne(ctx, bson.M{"_id": id}, updateQuery)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Coll[TData]) UpdateOneAndReturn(ctx context.Context, id any, updateQuery any) (TData, error) {
+	_, err := c.coll.UpdateOne(ctx, bson.M{"_id": id}, updateQuery)
+	if err != nil {
+		return *new(TData), err
+	}
+
+	var res TData
+
+	err = c.coll.FindOne(ctx, bson.M{"_id": id}).Decode(&res)
+	if err != nil {
+		return *new(TData), err
+	}
+
+	return res, nil
+}
+
+func (c *Coll[TData]) DeleteOne(ctx context.Context, id any) error {
+	_, err := c.coll.DeleteOne(ctx, bson.M{"_id": id})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, inTok ct.CursorToken) ([]TData, ct.CursorToken, error) {
+	if inTok.Mode == ct.CTMEnd {
+		return make([]TData, 0), ct.End(), nil
+	}
+
+	pipeline := filter.FilterQuery()
+
+	sortPrimary, sortDirPrimary, sortSecondary, sortDirSecondary := filter.Pagination()
+
+	paginationPipeline, err := CreatePagination(c, inTok, sortPrimary, sortDirPrimary, sortSecondary, sortDirSecondary, pageSize)
+	if err != nil {
+		return nil, ct.CursorToken{}, err
+	}
+
+	pipeline = append(pipeline, paginationPipeline...)
+
+	cursor, err := c.coll.Aggregate(ctx, pipeline)
+	if err != nil {
+		return nil, ct.CursorToken{}, err
+	}
+
+	entities := make([]TData, 0, cursor.RemainingBatchLength()+1)
+	for (pageSize == nil || len(entities) != *pageSize) && cursor.Next(ctx) {
+		var entry TData
+		err = cursor.Decode(&entry)
+		if err != nil {
+			return nil, ct.CursorToken{}, err
+		}
+		entities = append(entities, entry)
+	}
+
+	if pageSize == nil || len(entities) <= *pageSize || !cursor.TryNext(ctx) {
+		return entities, ct.End(), nil
+	}
+
+	last := entities[len(entities)-1]
+
+	nextToken, _ := c.createToken(sortPrimary, sortDirPrimary, sortSecondary, sortDirSecondary, last, pageSize)
+
+	return entities, nextToken, nil
+}
+
+func (c *Coll[TData]) createToken(fieldPrimary string, dirPrimary ct.SortDirection, fieldSecondary *string, dirSecondary *ct.SortDirection, lastEntity TData, pageSize *int) (ct.CursorToken, error) {
+
+	valuePrimary, err := c.getFieldValueAsTokenString(lastEntity, fieldPrimary)
+	if err != nil {
+		return ct.CursorToken{}, err
+	}
+
+	valueSeconary := ""
+	if fieldSecondary != nil && dirSecondary != nil {
+		valueSeconary, err = c.getFieldValueAsTokenString(lastEntity, *fieldSecondary)
+		if err != nil {
+			return ct.CursorToken{}, err
+		}
+	}
+
+	return ct.CursorToken{
+		Mode:           ct.CTMNormal,
+		ValuePrimary:   valuePrimary,
+		ValueSecondary: valueSeconary,
+		Direction:      dirPrimary,
+		PageSize:       langext.Coalesce(pageSize, 0),
+		Extra:          ct.Extra{},
+	}, nil
+}