From ae43cbb623366c5c10678bcead3f96bd0b5a757e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mike=20Schw=C3=B6rer?= Date: Mon, 21 Aug 2023 15:08:35 +0200 Subject: [PATCH] v0.0.248 exerr in wmo package --- exerr/data.go | 7 ++++++- goextVersion.go | 4 ++-- wmo/collection.go | 11 ++++++++--- wmo/decoding.go | 13 +++++++++---- wmo/pagination.go | 8 ++++---- wmo/queryAggregate.go | 16 ++++++++-------- wmo/queryDelete.go | 7 ++++--- wmo/queryFind.go | 26 ++++++++++++++++++++------ wmo/queryInsert.go | 10 ++++++++-- wmo/queryList.go | 25 ++++++++++++++++++------- wmo/queryUpdate.go | 37 +++++++++++++++++++++++++++++++++---- wmo/reflection.go | 16 ++++++++-------- 12 files changed, 128 insertions(+), 52 deletions(-) diff --git a/exerr/data.go b/exerr/data.go index 8f23340..7229f4e 100644 --- a/exerr/data.go +++ b/exerr/data.go @@ -42,6 +42,11 @@ var ( TypePanic = NewType("PANIC", langext.Ptr(500)) TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500)) + TypeMongoQuery = NewType("MONGO_QUERY", langext.Ptr(500)) + TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500)) + TypeMongoFilter = NewType("MONGO_FILTER", langext.Ptr(500)) + TypeMongoReflection = NewType("MONGO_REFLECTION", langext.Ptr(500)) + TypeWrap = NewType("Wrap", nil) TypeBindFailURI = NewType("BINDFAIL_URI", langext.Ptr(400)) @@ -53,7 +58,7 @@ var ( TypeUnauthorized = NewType("UNAUTHORIZED", langext.Ptr(401)) TypeAuthFailed = NewType("AUTH_FAILED", langext.Ptr(401)) - // other values come from pkgconfig + // other values come the used package ) var registeredTypes = dataext.SyncSet[string]{} diff --git a/goextVersion.go b/goextVersion.go index 12e3e70..01536da 100644 --- a/goextVersion.go +++ b/goextVersion.go @@ -1,5 +1,5 @@ package goext -const GoextVersion = "0.0.247" +const GoextVersion = "0.0.248" -const GoextVersionTimestamp = "2023-08-21T14:23:44+0200" +const GoextVersionTimestamp = "2023-08-21T15:08:35+0200" diff --git a/wmo/collection.go b/wmo/collection.go index 4a59f42..37297e1 100644 --- a/wmo/collection.go +++ b/wmo/collection.go @@ -5,6 +5,7 @@ import ( "go.mongodb.org/mongo-driver/bson/bsontype" "go.mongodb.org/mongo-driver/mongo" ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" "gogs.mikescher.com/BlackForestBytes/goext/langext" "reflect" ) @@ -66,21 +67,25 @@ func (c *Coll[TData]) Indexes() mongo.IndexView { } func (c *Coll[TData]) Drop(ctx context.Context) error { - return c.coll.Drop(ctx) + err := c.coll.Drop(ctx) + if err != nil { + return exerr.Wrap(err, "failed to drop collection").Str("collection", c.Name()).Build() + } + return 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 + return ct.CursorToken{}, exerr.Wrap(err, "failed to get (primary) field-value as token-string").Type("lastEntity", lastEntity).Str("fieldPrimary", fieldPrimary).Build() } valueSeconary := "" if fieldSecondary != nil && dirSecondary != nil { valueSeconary, err = c.getFieldValueAsTokenString(lastEntity, *fieldSecondary) if err != nil { - return ct.CursorToken{}, err + return ct.CursorToken{}, exerr.Wrap(err, "failed to get (secondary) field-value as token-string").Type("lastEntity", lastEntity).StrPtr("fieldSecondary", fieldSecondary).Build() } } diff --git a/wmo/decoding.go b/wmo/decoding.go index 10d5923..4f7d718 100644 --- a/wmo/decoding.go +++ b/wmo/decoding.go @@ -2,12 +2,17 @@ package wmo import ( "context" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) func (c *Coll[TData]) decodeSingle(ctx context.Context, dec Decodable) (TData, error) { if c.customDecoder != nil { - return (*c.customDecoder)(ctx, dec) + res, err := (*c.customDecoder)(ctx, dec) + if err != nil { + return *new(TData), exerr.Wrap(err, "failed to decode single entity with custom-decoder").Type("decoder", *c.customDecoder).Build() + } + return res, nil } else { @@ -15,7 +20,7 @@ func (c *Coll[TData]) decodeSingle(ctx context.Context, dec Decodable) (TData, e err := dec.Decode(&res) if err != nil { - return *new(TData), err + return *new(TData), exerr.Wrap(err, "failed to decode single entity").Type("target-type", res).Build() } return res, nil @@ -31,7 +36,7 @@ func (c *Coll[TData]) decodeAll(ctx context.Context, cursor Cursorable) ([]TData for cursor.Next(ctx) { entry, err := (*c.customDecoder)(ctx, cursor) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to decode entity with custom-decoder").Type("decoder", *c.customDecoder).Build() } res = append(res, entry) } @@ -44,7 +49,7 @@ func (c *Coll[TData]) decodeAll(ctx context.Context, cursor Cursorable) ([]TData err := cursor.All(ctx, &res) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to batch-decode entity").Type("target-type", res).Build() } return res, nil diff --git a/wmo/pagination.go b/wmo/pagination.go index aebb044..8da91e6 100644 --- a/wmo/pagination.go +++ b/wmo/pagination.go @@ -1,9 +1,9 @@ package wmo import ( - "errors" "go.mongodb.org/mongo-driver/bson" ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) 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) { @@ -13,7 +13,7 @@ func CreatePagination[TData any](coll *Coll[TData], token ct.CursorToken, fieldP valuePrimary, err := coll.getTokenValueAsMongoType(token.ValuePrimary, fieldPrimary) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to get (primary) token-value as mongo-type").Build() } if sortPrimary == ct.SortASC { @@ -30,7 +30,7 @@ func CreatePagination[TData any](coll *Coll[TData], token ct.CursorToken, fieldP valueSecondary, err := coll.getTokenValueAsMongoType(token.ValueSecondary, *fieldSecondary) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to get (secondary) token-value as mongo-type").Build() } if *sortSecondary == ct.SortASC { @@ -73,7 +73,7 @@ func CreatePagination[TData any](coll *Coll[TData], token ct.CursorToken, fieldP } else { - return nil, errors.New("unknown ct mode: " + string(token.Mode)) + return nil, exerr.New(exerr.TypeInternal, "unknown ct mode: "+string(token.Mode)).Any("token.Mode", token.Mode).Build() } diff --git a/wmo/queryAggregate.go b/wmo/queryAggregate.go index beb9c7c..2e1cf79 100644 --- a/wmo/queryAggregate.go +++ b/wmo/queryAggregate.go @@ -2,20 +2,20 @@ package wmo import ( "context" - "errors" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) 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 + return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build() } res, err := c.decodeAll(ctx, cursor) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to decode values").Build() } return res, nil @@ -24,13 +24,13 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op func (c *Coll[TData]) AggregateOneOpt(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 + return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build() } if cursor.Next(ctx) { v, err := c.decodeSingle(ctx, cursor) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to decode single value").Build() } return &v, nil } @@ -41,16 +41,16 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline, opts ...*options.AggregateOptions) (TData, error) { cursor, err := c.coll.Aggregate(ctx, pipeline, opts...) if err != nil { - return *new(TData), err + return *new(TData), exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build() } if cursor.Next(ctx) { v, err := c.decodeSingle(ctx, cursor) if err != nil { - return *new(TData), err + return *new(TData), exerr.Wrap(err, "failed to decode single value").Build() } return v, nil } - return *new(TData), errors.New("no document in result") + return *new(TData), exerr.Wrap(mongo.ErrNoDocuments, "no document in result").Build() } diff --git a/wmo/queryDelete.go b/wmo/queryDelete.go index 38b8b98..5c575d7 100644 --- a/wmo/queryDelete.go +++ b/wmo/queryDelete.go @@ -4,12 +4,13 @@ import ( "context" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) func (c *Coll[TData]) DeleteOneByID(ctx context.Context, id EntityID) error { _, err := c.coll.DeleteOne(ctx, bson.M{"_id": id}) if err != nil { - return err + return exerr.Wrap(err, "mongo-query[delete-one-by-id] failed").Id("id", id).Str("collection", c.Name()).Build() } return nil @@ -18,7 +19,7 @@ func (c *Coll[TData]) DeleteOneByID(ctx context.Context, id EntityID) error { func (c *Coll[TData]) DeleteOne(ctx context.Context, filterQuery bson.M) error { _, err := c.coll.DeleteOne(ctx, filterQuery) if err != nil { - return err + return exerr.Wrap(err, "mongo-query[delete-one] failed").Any("filterQuery", filterQuery).Str("collection", c.Name()).Build() } return nil @@ -27,7 +28,7 @@ func (c *Coll[TData]) DeleteOne(ctx context.Context, filterQuery bson.M) error { func (c *Coll[TData]) DeleteMany(ctx context.Context, filterQuery bson.M) (*mongo.DeleteResult, error) { res, err := c.coll.DeleteMany(ctx, filterQuery) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "mongo-query[delete-many] failed").Any("filterQuery", filterQuery).Str("collection", c.Name()).Build() } return res, nil diff --git a/wmo/queryFind.go b/wmo/queryFind.go index 6e35a4d..9538eb4 100644 --- a/wmo/queryFind.go +++ b/wmo/queryFind.go @@ -2,13 +2,21 @@ package wmo import ( "context" + "errors" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) func (c *Coll[TData]) FindOne(ctx context.Context, filter bson.M) (TData, error) { mongoRes := c.coll.FindOne(ctx, filter) + if err := mongoRes.Err(); err != nil { + return *new(TData), exerr.Wrap(err, "mongo-query[find-one] failed"). + Str("collection", c.Name()). + Any("filter", filter). + Build() + } return c.decodeSingle(ctx, mongoRes) } @@ -17,11 +25,11 @@ func (c *Coll[TData]) FindOneOpt(ctx context.Context, filter bson.M) (*TData, er mongoRes := c.coll.FindOne(ctx, filter) res, err := c.decodeSingle(ctx, mongoRes) - if err == mongo.ErrNoDocuments { + if errors.Is(err, mongo.ErrNoDocuments) { return nil, nil } if err != nil { - return nil, err + return nil, exerr.Wrap(err, "mongo-query[find-one-opt] failed").Any("filter", filter).Str("collection", c.Name()).Build() } return &res, nil @@ -29,6 +37,12 @@ func (c *Coll[TData]) FindOneOpt(ctx context.Context, filter bson.M) (*TData, er func (c *Coll[TData]) FindOneByID(ctx context.Context, id EntityID) (TData, error) { mongoRes := c.coll.FindOne(ctx, bson.M{"_id": id}) + if err := mongoRes.Err(); err != nil { + return *new(TData), exerr.Wrap(err, "mongo-query[find-one-by-id] failed"). + Str("collection", c.Name()). + Id("id", id). + Build() + } return c.decodeSingle(ctx, mongoRes) } @@ -37,11 +51,11 @@ func (c *Coll[TData]) FindOneOptByID(ctx context.Context, id EntityID) (*TData, mongoRes := c.coll.FindOne(ctx, bson.M{"_id": id}) res, err := c.decodeSingle(ctx, mongoRes) - if err == mongo.ErrNoDocuments { + if errors.Is(err, mongo.ErrNoDocuments) { return nil, nil } if err != nil { - return nil, err + return nil, exerr.Wrap(err, "mongo-query[find-one-opt-by-id] failed").Id("id", id).Str("collection", c.Name()).Build() } return &res, nil @@ -50,12 +64,12 @@ func (c *Coll[TData]) FindOneOptByID(ctx context.Context, id EntityID) (*TData, func (c *Coll[TData]) Find(ctx context.Context, filter bson.M, opts ...*options.FindOptions) ([]TData, error) { cursor, err := c.coll.Find(ctx, filter, opts...) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "mongo-query[find-one-opt] failed").Any("filter", filter).Any("opts", opts).Str("collection", c.Name()).Build() } res, err := c.decodeAll(ctx, cursor) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to decode values").Build() } return res, nil diff --git a/wmo/queryInsert.go b/wmo/queryInsert.go index f1eb1c7..f884e10 100644 --- a/wmo/queryInsert.go +++ b/wmo/queryInsert.go @@ -4,13 +4,14 @@ import ( "context" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" "gogs.mikescher.com/BlackForestBytes/goext/langext" ) func (c *Coll[TData]) InsertOne(ctx context.Context, valueIn TData) (TData, error) { insRes, err := c.coll.InsertOne(ctx, valueIn) if err != nil { - return *new(TData), err + return *new(TData), exerr.Wrap(err, "mongo-query[insert-one] failed").Str("collection", c.Name()).Build() } mongoRes := c.coll.FindOne(ctx, bson.M{"_id": insRes.InsertedID}) @@ -19,5 +20,10 @@ func (c *Coll[TData]) InsertOne(ctx context.Context, valueIn TData) (TData, erro } func (c *Coll[TData]) InsertMany(ctx context.Context, valueIn []TData) (*mongo.InsertManyResult, error) { - return c.coll.InsertMany(ctx, langext.ArrayToInterface(valueIn)) + insRes, err := c.coll.InsertMany(ctx, langext.ArrayToInterface(valueIn)) + if err != nil { + return nil, exerr.Wrap(err, "mongo-query[insert-many] failed").Int("len(valueIn)", len(valueIn)).Str("collection", c.Name()).Build() + } + + return insRes, nil } diff --git a/wmo/queryList.go b/wmo/queryList.go index c485290..df79545 100644 --- a/wmo/queryList.go +++ b/wmo/queryList.go @@ -5,6 +5,7 @@ import ( "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" ct "gogs.mikescher.com/BlackForestBytes/goext/cursortoken" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, inTok ct.CursorToken) ([]TData, ct.CursorToken, error) { @@ -35,21 +36,31 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, paginationPipeline, err := CreatePagination(c, inTok, sortPrimary, sortDirPrimary, sortSecondary, sortDirSecondary, pageSize) if err != nil { - return nil, ct.CursorToken{}, err + return nil, ct.CursorToken{}, exerr. + Wrap(err, "failed to create pagination"). + WithType(exerr.TypeCursorTokenDecode). + Str("collection", c.Name()). + Any("inTok", inTok). + Any("sortPrimary", sortPrimary). + Any("sortDirPrimary", sortDirPrimary). + Any("sortSecondary", sortSecondary). + Any("sortDirSecondary", sortDirSecondary). + Any("pageSize", pageSize). + Build() } pipeline = append(pipeline, paginationPipeline...) cursor, err := c.coll.Aggregate(ctx, pipeline) if err != nil { - return nil, ct.CursorToken{}, err + return nil, ct.CursorToken{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build() } // fast branch if pageSize == nil { entries, err := c.decodeAll(ctx, cursor) if err != nil { - return nil, ct.CursorToken{}, err + return nil, ct.CursorToken{}, exerr.Wrap(err, "failed to all-decode entities").Build() } return entries, ct.End(), nil } @@ -59,7 +70,7 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, var entry TData entry, err = c.decodeSingle(ctx, cursor) if err != nil { - return nil, ct.CursorToken{}, err + return nil, ct.CursorToken{}, exerr.Wrap(err, "failed to decode entity").Build() } entities = append(entities, entry) } @@ -74,7 +85,7 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int, nextToken, err := c.createToken(sortPrimary, sortDirPrimary, sortSecondary, sortDirSecondary, last, pageSize) if err != nil { - return nil, ct.CursorToken{}, err + return nil, ct.CursorToken{}, exerr.Wrap(err, "failed to create (out)-token").Build() } return entities, nextToken, nil @@ -91,14 +102,14 @@ func (c *Coll[TData]) Count(ctx context.Context, filter ct.Filter) (int64, error cursor, err := c.coll.Aggregate(ctx, pipeline) if err != nil { - return 0, err + return 0, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build() } if cursor.Next(ctx) { v := countRes{} err = cursor.Decode(&v) if err != nil { - return 0, err + return 0, exerr.Wrap(err, "failed to decode entity").Build() } return v.Count, nil } diff --git a/wmo/queryUpdate.go b/wmo/queryUpdate.go index b004335..1885625 100644 --- a/wmo/queryUpdate.go +++ b/wmo/queryUpdate.go @@ -5,10 +5,18 @@ import ( "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" ) func (c *Coll[TData]) FindOneAndUpdate(ctx context.Context, filterQuery bson.M, updateQuery bson.M) (TData, error) { mongoRes := c.coll.FindOneAndUpdate(ctx, filterQuery, updateQuery, options.FindOneAndUpdate().SetReturnDocument(options.After)) + if err := mongoRes.Err(); err != nil { + return *new(TData), exerr.Wrap(err, "mongo-query[find-one-and-update] failed"). + Str("collection", c.Name()). + Any("filterQuery", filterQuery). + Any("updateQuery", updateQuery). + Build() + } return c.decodeSingle(ctx, mongoRes) } @@ -16,7 +24,11 @@ func (c *Coll[TData]) FindOneAndUpdate(ctx context.Context, filterQuery bson.M, func (c *Coll[TData]) UpdateOne(ctx context.Context, filterQuery bson.M, updateQuery bson.M) error { _, err := c.coll.UpdateOne(ctx, filterQuery, updateQuery) if err != nil { - return err + return exerr.Wrap(err, "mongo-query[update-one] failed"). + Str("collection", c.Name()). + Any("filterQuery", filterQuery). + Any("updateQuery", updateQuery). + Build() } return nil @@ -25,7 +37,11 @@ func (c *Coll[TData]) UpdateOne(ctx context.Context, filterQuery bson.M, updateQ func (c *Coll[TData]) UpdateOneByID(ctx context.Context, id EntityID, updateQuery bson.M) error { _, err := c.coll.UpdateOne(ctx, bson.M{"_id": id}, updateQuery) if err != nil { - return err + return exerr.Wrap(err, "mongo-query[update-one-by-id] failed"). + Str("collection", c.Name()). + Id("id", id). + Any("updateQuery", updateQuery). + Build() } return nil @@ -34,7 +50,11 @@ func (c *Coll[TData]) UpdateOneByID(ctx context.Context, id EntityID, updateQuer func (c *Coll[TData]) UpdateMany(ctx context.Context, filterQuery bson.M, updateQuery bson.M) (*mongo.UpdateResult, error) { res, err := c.coll.UpdateMany(ctx, filterQuery, updateQuery) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "mongo-query[update-many] failed"). + Str("collection", c.Name()). + Any("filterQuery", filterQuery). + Any("updateQuery", updateQuery). + Build() } return res, nil @@ -43,7 +63,10 @@ func (c *Coll[TData]) UpdateMany(ctx context.Context, filterQuery bson.M, update func (c *Coll[TData]) ReplaceOne(ctx context.Context, filterQuery bson.M, value TData) error { _, err := c.coll.UpdateOne(ctx, filterQuery, bson.M{"$set": value}) if err != nil { - return err + return exerr.Wrap(err, "mongo-query[replace-one] failed"). + Str("collection", c.Name()). + Any("filterQuery", filterQuery). + Build() } return nil @@ -51,6 +74,12 @@ func (c *Coll[TData]) ReplaceOne(ctx context.Context, filterQuery bson.M, value func (c *Coll[TData]) FindOneAndReplace(ctx context.Context, filterQuery bson.M, value TData) (TData, error) { mongoRes := c.coll.FindOneAndUpdate(ctx, filterQuery, bson.M{"$set": value}, options.FindOneAndUpdate().SetReturnDocument(options.After)) + if err := mongoRes.Err(); err != nil { + return *new(TData), exerr.Wrap(err, "mongo-query[find-one-and-update] failed"). + Str("collection", c.Name()). + Any("filterQuery", filterQuery). + Build() + } return c.decodeSingle(ctx, mongoRes) } diff --git a/wmo/reflection.go b/wmo/reflection.go index 57be754..2997eb3 100644 --- a/wmo/reflection.go +++ b/wmo/reflection.go @@ -1,7 +1,7 @@ package wmo import ( - "errors" + "gogs.mikescher.com/BlackForestBytes/goext/exerr" "gogs.mikescher.com/BlackForestBytes/goext/langext" "gogs.mikescher.com/BlackForestBytes/goext/reflectext" "reflect" @@ -138,7 +138,7 @@ func (c *Coll[TData]) getTokenValueAsMongoType(value string, fieldName string) ( fref, err := c.getFieldType(fieldName) if err != nil { - return nil, err + return nil, exerr.Wrap(err, "failed to get-field-type").Str("fieldName", fieldName).Build() } pss := reflectext.PrimitiveStringSerializer{} @@ -151,7 +151,7 @@ func (c *Coll[TData]) getFieldValueAsTokenString(entity TData, fieldName string) realValue, err := c.getFieldValue(entity, fieldName) if err != nil { - return "", err + return "", exerr.Wrap(err, "failed to get-field-value").Str("fieldName", fieldName).Build() } pss := reflectext.PrimitiveStringSerializer{} @@ -169,14 +169,14 @@ func (c *Coll[TData]) getFieldType(fieldName string) (fullTypeRef, error) { } } - return fullTypeRef{}, errors.New("unknown field: '" + fieldName + "' (in any impl)") + return fullTypeRef{}, exerr.New(exerr.TypeMongoReflection, "unknown field: '"+fieldName+"' (in any impl)").Str("fieldName", fieldName).Build() } else { if r, ok := c.dataTypeMap[fieldName]; ok { return r, nil } else { - return fullTypeRef{}, errors.New("unknown field: '" + fieldName + "'") + return fullTypeRef{}, exerr.New(exerr.TypeMongoReflection, "unknown field: '"+fieldName+"'").Str("fieldName", fieldName).Build() } } @@ -196,10 +196,10 @@ func (c *Coll[TData]) getFieldValue(data TData, fieldName string) (any, error) { rval := reflect.ValueOf(data) return rval.FieldByIndex(fref.Index).Interface(), nil } else { - return nil, errors.New("unknown bson field '" + fieldName + "' in type '" + rval.Type().String() + "'") + return nil, exerr.New(exerr.TypeMongoReflection, "unknown bson field '"+fieldName+"' in type '"+rval.Type().String()+"'").Str("fieldName", fieldName).Type("rval", rval).Build() } } else { - return nil, errors.New("unknown TData type: '" + rval.Type().String() + "'") + return nil, exerr.New(exerr.TypeMongoReflection, "unknown TData type: '"+rval.Type().String()+"'").Type("rval", rval).Build() } } else { @@ -208,7 +208,7 @@ func (c *Coll[TData]) getFieldValue(data TData, fieldName string) (any, error) { rval := reflect.ValueOf(data) return rval.FieldByIndex(fref.Index).Interface(), nil } else { - return nil, errors.New("unknown bson field '" + fieldName + "'") + return nil, exerr.New(exerr.TypeMongoReflection, "unknown bson field '"+fieldName+"'").Str("fieldName", fieldName).Build() } }