v0.0.197

exerr/errinit.go

@@ -6,12 +6,12 @@ import (
 )
 
 type ErrorPackageConfig struct {
-	ZeroLogErrTraces    bool                      // autom print zerolog logs on .Build()  (for SevErr and SevFatal)
+	ZeroLogErrTraces    bool                                             // autom print zerolog logs on .Build()  (for SevErr and SevFatal)
-	ZeroLogAllTraces    bool                      // autom print zerolog logs on .Build()  (for all Severities)
+	ZeroLogAllTraces    bool                                             // autom print zerolog logs on .Build()  (for all Severities)
-	RecursiveErrors     bool                      // errors contains their Origin-Error
+	RecursiveErrors     bool                                             // errors contains their Origin-Error
-	ExtendedGinOutput   bool                      // Log extended data (trace, meta, ...) to gin in err.Output()
+	ExtendedGinOutput   bool                                             // Log extended data (trace, meta, ...) to gin in err.Output()
-	ExtendGinOutput     func(json map[string]any) // (Optionally) extend the gin output with more fields
+	ExtendGinOutput     func(err *ExErr, json map[string]any)            // (Optionally) extend the gin output with more fields
-	ExtendGinDataOutput func(json map[string]any) // (Optionally) extend the gin `__data` output with more fields
+	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any) // (Optionally) extend the gin `__data` output with more fields
 }
 
 type ErrorPackageConfigInit struct {
@@ -19,8 +19,8 @@ type ErrorPackageConfigInit struct {
 	ZeroLogAllTraces    bool
 	RecursiveErrors     bool
 	ExtendedGinOutput   bool
-	ExtendGinOutput     *func(json map[string]any)
+	ExtendGinOutput     func(err *ExErr, json map[string]any)
-	ExtendGinDataOutput *func(json map[string]any)
+	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any)
 }
 
 var initialized = false
@@ -30,8 +30,8 @@ var pkgconfig = ErrorPackageConfig{
 	ZeroLogAllTraces:    false,
 	RecursiveErrors:     true,
 	ExtendedGinOutput:   false,
-	ExtendGinOutput:     func(json map[string]any) {},
+	ExtendGinOutput:     func(err *ExErr, json map[string]any) {},
-	ExtendGinDataOutput: func(json map[string]any) {},
+	ExtendGinDataOutput: func(err *ExErr, depth int, json map[string]any) {},
 }
 
 // Init initializes the exerr packages
@@ -42,13 +42,23 @@ func Init(cfg ErrorPackageConfigInit) {
 		panic("Cannot re-init error package")
 	}
 
+	ego := func(err *ExErr, json map[string]any) {}
+	egdo := func(err *ExErr, depth int, json map[string]any) {}
+
+	if cfg.ExtendGinOutput != nil {
+		ego = cfg.ExtendGinOutput
+	}
+	if cfg.ExtendGinDataOutput != nil {
+		egdo = cfg.ExtendGinDataOutput
+	}
+
 	pkgconfig = ErrorPackageConfig{
 		ZeroLogErrTraces:    cfg.ZeroLogErrTraces,
 		ZeroLogAllTraces:    cfg.ZeroLogAllTraces,
 		RecursiveErrors:     cfg.RecursiveErrors,
 		ExtendedGinOutput:   cfg.ExtendedGinOutput,
-		ExtendGinOutput:     langext.Coalesce(cfg.ExtendGinOutput, func(json map[string]any) {}),
+		ExtendGinOutput:     ego,
-		ExtendGinDataOutput: langext.Coalesce(cfg.ExtendGinDataOutput, func(json map[string]any) {}),
+		ExtendGinDataOutput: egdo,
 	}
 
 	initialized = true

exerr/exerr.go

@@ -162,7 +162,6 @@ func (ee *ExErr) RecursiveStatuscode() *int {
 		}
 	}
 
-	// fallback to <empty>
 	return nil
 }
 
@@ -179,6 +178,18 @@ func (ee *ExErr) RecursiveCategory() ErrorCategory {
 	return ee.Category
 }
 
+// RecursiveMeta searches (top-down) for teh first error that has a meta value with teh specified key
+// and returns its value (or nil)
+func (ee *ExErr) RecursiveMeta(key string) *MetaValue {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if metaval, ok := curr.Meta[key]; ok {
+			return langext.Ptr(metaval)
+		}
+	}
+
+	return nil
+}
+
 func (ee *ExErr) Depth() int {
 	if ee.OriginalError == nil {
 		return 1

exerr/gin.go

@@ -7,43 +7,43 @@ import (
 	"time"
 )
 
-func (ee *ExErr) toJson() gin.H {
+func (ee *ExErr) toJson(depth int) gin.H {
-	json := gin.H{}
+	ginJson := gin.H{}
 
 	if ee.UniqueID != "" {
-		json["id"] = ee.UniqueID
+		ginJson["id"] = ee.UniqueID
 	}
 	if ee.Category != CatWrap {
-		json["category"] = ee.Category
+		ginJson["category"] = ee.Category
 	}
 	if ee.Type != TypeWrap {
-		json["type"] = ee.Type
+		ginJson["type"] = ee.Type
 	}
 	if ee.StatusCode != nil {
-		json["statuscode"] = ee.StatusCode
+		ginJson["statuscode"] = ee.StatusCode
 	}
 	if ee.Message != "" {
-		json["message"] = ee.Message
+		ginJson["message"] = ee.Message
 	}
 	if ee.Caller != "" {
-		json["caller"] = ee.Caller
+		ginJson["caller"] = ee.Caller
 	}
 	if ee.Severity != SevErr {
-		json["severity"] = ee.Severity
+		ginJson["severity"] = ee.Severity
 	}
 	if ee.Timestamp != (time.Time{}) {
-		json["time"] = ee.Timestamp.Format(time.RFC3339)
+		ginJson["time"] = ee.Timestamp.Format(time.RFC3339)
 	}
 	if ee.WrappedErrType != "" {
-		json["wrappedErrType"] = ee.WrappedErrType
+		ginJson["wrappedErrType"] = ee.WrappedErrType
 	}
 	if ee.OriginalError != nil {
-		json["original"] = ee.OriginalError.toJson()
+		ginJson["original"] = ee.OriginalError.toJson(depth + 1)
 	}
 
-	pkgconfig.ExtendGinDataOutput(json)
+	pkgconfig.ExtendGinDataOutput(ee, depth, ginJson)
 
-	return json
+	return ginJson
 }
 
 func (ee *ExErr) Output(g *gin.Context) {
@@ -52,6 +52,7 @@ func (ee *ExErr) Output(g *gin.Context) {
 	var baseCat = ee.RecursiveCategory()
 	var baseType = ee.RecursiveType()
 	var baseStatuscode = ee.RecursiveStatuscode()
+	var baseMessage = ee.RecursiveMessage()
 
 	if baseCat == CatUser {
 		statuscode = http.StatusBadRequest
@@ -69,16 +70,16 @@ func (ee *ExErr) Output(g *gin.Context) {
 
 	ginOutput := gin.H{
 		"errorid":   ee.UniqueID,
-		"message":   ee.RecursiveMessage(),
+		"message":   baseMessage,
-		"errorcode": ee.RecursiveType(),
+		"errorcode": baseType.Key,
-		"category":  ee.RecursiveCategory(),
+		"category":  baseCat.Category,
 	}
 
 	if pkgconfig.ExtendedGinOutput {
-		ginOutput["__data"] = ee.toJson()
+		ginOutput["__data"] = ee.toJson(0)
 	}
 
-	pkgconfig.ExtendGinOutput(ginOutput)
+	pkgconfig.ExtendGinOutput(ee, ginOutput)
 
 	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
 }

ginext/appContext.go

@@ -50,10 +50,3 @@ func (ac *AppContext) RequestURI() string {
 		return ""
 	}
 }
-
-func (ac *AppContext) FinishSuccess(res HTTPResponse) HTTPResponse {
-	if ac.cancelled {
-		panic("Cannot finish a cancelled request")
-	}
-	return res
-}

ginext/preContext.go

@@ -2,8 +2,10 @@ package ginext
 
 import (
 	"context"
+	"fmt"
 	"github.com/gin-gonic/gin"
 	"github.com/gin-gonic/gin/binding"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"runtime/debug"
 )
@@ -40,33 +42,55 @@ func (pctx *PreContext) Form(form any) *PreContext {
 func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	if pctx.uri != nil {
 		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
-			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailURI, "Failed to read uri", err))
+			err = exerr.Wrap(err, "Failed to read uri").
+				WithType(exerr.TypeBindFailURI).
+				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
+				Build()
+			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 		}
 	}
 
 	if pctx.query != nil {
 		if err := pctx.ginCtx.ShouldBindQuery(pctx.query); err != nil {
-			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailQuery, "Failed to read query", err))
+			err = exerr.Wrap(err, "Failed to read query").
+				WithType(exerr.TypeBindFailQuery).
+				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
+				Build()
+			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 		}
 	}
 
 	if pctx.body != nil {
 		if pctx.ginCtx.ContentType() == "application/json" {
 			if err := pctx.ginCtx.ShouldBindJSON(pctx.body); err != nil {
-				return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailJSON, "Failed to read body", err))
+				err = exerr.Wrap(err, "Failed to read json-body").
+					WithType(exerr.TypeBindFailJSON).
+					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+					Build()
+				return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 			}
 		} else {
-			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailJSON, "missing JSON body", nil))
+			err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
+				Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+				Build()
+			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 		}
 	}
 
 	if pctx.form != nil {
 		if pctx.ginCtx.ContentType() == "multipart/form-data" {
 			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
-				return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailFormData, "Failed to read multipart-form", err))
+				err = exerr.Wrap(err, "Failed to read multipart-form").
+					WithType(exerr.TypeBindFailFormData).
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+					Build()
+				return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 			}
 		} else {
-			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, commonApiErr.BindFailJSON, "missing form body", nil))
+			err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
+				Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+				Build()
+			return nil, nil, langext.Ptr(APIError(pctx.ginCtx, err))
 		}
 	}
 

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.191"
+const GoextVersion = "0.0.197"
 
-const GoextVersionTimestamp = "2023-07-24T11:18:25+0200"
+const GoextVersionTimestamp = "2023-07-24T12:27:06+0200"