v0.0.234

dataext/syncSet.go

@@ -7,6 +7,9 @@ type SyncSet[TData comparable] struct {
 	lock sync.Mutex
 }
 
+// Add adds `value` to the set
+// returns true  if the value was actually inserted
+// returns false if the value already existed
 func (s *SyncSet[TData]) Add(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -15,10 +18,10 @@ func (s *SyncSet[TData]) Add(value TData) bool {
 		s.data = make(map[TData]bool)
 	}
 
-	_, ok := s.data[value]
+	_, existsInPreState := s.data[value]
 	s.data[value] = true
 
-	return !ok
+	return !existsInPreState
 }
 
 func (s *SyncSet[TData]) AddAll(values []TData) {

exerr/builder.go

@@ -80,6 +80,10 @@ func New(t ErrorType, msg string) *Builder {
 }
 
 func Wrap(err error, msg string) *Builder {
+	if err == nil {
+		return &Builder{errorData: newExErr(CatSystem, TypeInternal, msg)} // prevent NPE if we call Wrap with err==nil
+	}
+
 	if !pkgconfig.RecursiveErrors {
 		v := FromError(err)
 		v.Message = msg
@@ -269,6 +273,14 @@ func (b *Builder) Any(key string, val any) *Builder {
 	return b.addMeta(key, MDTAny, newAnyWrap(val))
 }
 
+func (b *Builder) Stringer(key string, val fmt.Stringer) *Builder {
+	if val == nil {
+		return b.addMeta(key, MDTString, "(!nil)")
+	} else {
+		return b.addMeta(key, MDTString, val.String())
+	}
+}
+
 func (b *Builder) Stack() *Builder {
 	return b.addMeta("@Stack", MDTString, string(debug.Stack()))
 }

exerr/constructor.go

@@ -27,6 +27,7 @@ func FromError(err error) *ExErr {
 		StatusCode:     nil,
 		Message:        err.Error(),
 		WrappedErrType: fmt.Sprintf("%T", err),
+		WrappedErr:     err,
 		Caller:         "",
 		OriginalError:  nil,
 		Meta:           getForeignMeta(err),
@@ -43,6 +44,7 @@ func newExErr(cat ErrorCategory, errtype ErrorType, msg string) *ExErr {
 		StatusCode:     nil,
 		Message:        msg,
 		WrappedErrType: "",
+		WrappedErr:     nil,
 		Caller:         callername(2),
 		OriginalError:  nil,
 		Meta:           make(map[string]MetaValue),
@@ -59,6 +61,7 @@ func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExE
 		StatusCode:     e.StatusCode,
 		Message:        msg,
 		WrappedErrType: "",
+		WrappedErr:     nil,
 		Caller:         callername(1 + stacktraceskip),
 		OriginalError:  e,
 		Meta:           make(map[string]MetaValue),

exerr/data.go

@@ -1,6 +1,7 @@
 package exerr
 
 import (
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 )
 
@@ -37,25 +38,32 @@ type ErrorType struct {
 
 //goland:noinspection GoUnusedGlobalVariable
 var (
-	TypeInternal       = ErrorType{"INTERNAL_ERROR", langext.Ptr(500)}
+	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
-	TypePanic          = ErrorType{"PANIC", langext.Ptr(500)}
+	TypePanic          = NewType("PANIC", langext.Ptr(500))
-	TypeNotImplemented = ErrorType{"NOT_IMPLEMENTED", langext.Ptr(500)}
+	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
 
-	TypeWrap = ErrorType{"Wrap", nil}
+	TypeWrap = NewType("Wrap", nil)
 
-	TypeBindFailURI      = ErrorType{"BINDFAIL_URI", langext.Ptr(400)}
+	TypeBindFailURI      = NewType("BINDFAIL_URI", langext.Ptr(400))
-	TypeBindFailQuery    = ErrorType{"BINDFAIL_QUERY", langext.Ptr(400)}
+	TypeBindFailQuery    = NewType("BINDFAIL_QUERY", langext.Ptr(400))
-	TypeBindFailJSON     = ErrorType{"BINDFAIL_JSON", langext.Ptr(400)}
+	TypeBindFailJSON     = NewType("BINDFAIL_JSON", langext.Ptr(400))
-	TypeBindFailFormData = ErrorType{"BINDFAIL_FORMDATA", langext.Ptr(400)}
+	TypeBindFailFormData = NewType("BINDFAIL_FORMDATA", langext.Ptr(400))
-	TypeBindFailHeader   = ErrorType{"BINDFAIL_HEADER", langext.Ptr(400)}
+	TypeBindFailHeader   = NewType("BINDFAIL_HEADER", langext.Ptr(400))
 
-	TypeUnauthorized = ErrorType{"UNAUTHORIZED", langext.Ptr(401)}
+	TypeUnauthorized = NewType("UNAUTHORIZED", langext.Ptr(401))
-	TypeAuthFailed   = ErrorType{"AUTH_FAILED", langext.Ptr(401)}
+	TypeAuthFailed   = NewType("AUTH_FAILED", langext.Ptr(401))
 
 	// other values come from pkgconfig
 )
 
+var registeredTypes = dataext.SyncSet[string]{}
+
 func NewType(key string, defStatusCode *int) ErrorType {
+	insertOkay := registeredTypes.Add(key)
+	if !insertOkay {
+		panic("Cannot register same ErrType ('" + key + "') more than once")
+	}
+
 	return ErrorType{key, defStatusCode}
 }
 

exerr/errinit.go

@@ -6,32 +6,35 @@ 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(err *ExErr, json map[string]any)            // (Optionally) extend the gin output with more fields
+	IncludeMetaInGinOutput bool                                             // Log meta fields ( from e.g. `.Str(key, val).Build()` ) to gin in err.Output()
-	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any) // (Optionally) extend the gin `__data` output with more fields
+	ExtendGinOutput        func(err *ExErr, json map[string]any)            // (Optionally) extend the gin 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 {
-	ZeroLogErrTraces    bool
+	ZeroLogErrTraces       bool
-	ZeroLogAllTraces    bool
+	ZeroLogAllTraces       bool
-	RecursiveErrors     bool
+	RecursiveErrors        bool
-	ExtendedGinOutput   bool
+	ExtendedGinOutput      bool
-	ExtendGinOutput     func(err *ExErr, json map[string]any)
+	IncludeMetaInGinOutput bool
-	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any)
+	ExtendGinOutput        func(err *ExErr, json map[string]any)
+	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)
 }
 
 var initialized = false
 
 var pkgconfig = ErrorPackageConfig{
-	ZeroLogErrTraces:    true,
+	ZeroLogErrTraces:       true,
-	ZeroLogAllTraces:    false,
+	ZeroLogAllTraces:       false,
-	RecursiveErrors:     true,
+	RecursiveErrors:        true,
-	ExtendedGinOutput:   false,
+	ExtendedGinOutput:      false,
-	ExtendGinOutput:     func(err *ExErr, json map[string]any) {},
+	IncludeMetaInGinOutput: true,
-	ExtendGinDataOutput: func(err *ExErr, depth int, json map[string]any) {},
+	ExtendGinOutput:        func(err *ExErr, json map[string]any) {},
+	ExtendGinDataOutput:    func(err *ExErr, depth int, json map[string]any) {},
 }
 
 // Init initializes the exerr packages
@@ -53,12 +56,13 @@ func Init(cfg ErrorPackageConfigInit) {
 	}
 
 	pkgconfig = ErrorPackageConfig{
-		ZeroLogErrTraces:    cfg.ZeroLogErrTraces,
+		ZeroLogErrTraces:       cfg.ZeroLogErrTraces,
-		ZeroLogAllTraces:    cfg.ZeroLogAllTraces,
+		ZeroLogAllTraces:       cfg.ZeroLogAllTraces,
-		RecursiveErrors:     cfg.RecursiveErrors,
+		RecursiveErrors:        cfg.RecursiveErrors,
-		ExtendedGinOutput:   cfg.ExtendedGinOutput,
+		ExtendedGinOutput:      cfg.ExtendedGinOutput,
-		ExtendGinOutput:     ego,
+		IncludeMetaInGinOutput: cfg.IncludeMetaInGinOutput,
-		ExtendGinDataOutput: egdo,
+		ExtendGinOutput:        ego,
+		ExtendGinDataOutput:    egdo,
 	}
 
 	initialized = true

exerr/exerr.go

@@ -4,6 +4,7 @@ import (
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
 	"strings"
 	"time"
 )
@@ -20,9 +21,10 @@ type ExErr struct {
 
 	Message        string `json:"message"`
 	WrappedErrType string `json:"wrappedErrType"`
+	WrappedErr     any    `json:"-"`
 	Caller         string `json:"caller"`
 
-	OriginalError *ExErr
+	OriginalError *ExErr `json:"originalError"`
 
 	Meta MetaMap `json:"meta"`
 }
@@ -31,10 +33,49 @@ func (ee *ExErr) Error() string {
 	return ee.Message
 }
 
+// Unwrap must be implemented so that some error.XXX methods work
 func (ee *ExErr) Unwrap() error {
+	if ee.OriginalError == nil {
+		return nil // this is neccessary - otherwise we return a wrapped nil and the `x == nil` comparison fails (= panic in errors.Is and other failures)
+	}
 	return ee.OriginalError
 }
 
+// Is must be implemented so that error.Is(x) works
+func (ee *ExErr) Is(e error) bool {
+	return IsFrom(ee, e)
+}
+
+// As must be implemented so that error.As(x) works
+//
+//goland:noinspection GoTypeAssertionOnErrors
+func (ee *ExErr) As(target any) bool {
+	if dstErr, ok := target.(*ExErr); ok {
+
+		if dst0, ok := ee.contains(dstErr); ok {
+			dstErr = dst0
+			return true
+		} else {
+			return false
+		}
+
+	} else {
+
+		val := reflect.ValueOf(target)
+
+		typStr := val.Type().Elem().String()
+
+		for curr := ee; curr != nil; curr = curr.OriginalError {
+			if curr.Category == CatForeign && curr.WrappedErrType == typStr && curr.WrappedErr != nil {
+				val.Elem().Set(reflect.ValueOf(curr.WrappedErr))
+				return true
+			}
+		}
+
+		return false
+	}
+}
+
 func (ee *ExErr) Log(evt *zerolog.Event) {
 	evt.Msg(ee.FormatLog(LogPrintFull))
 }
@@ -190,6 +231,7 @@ func (ee *ExErr) RecursiveMeta(key string) *MetaValue {
 	return nil
 }
 
+// Depth returns the depth of recursively contained errors
 func (ee *ExErr) Depth() int {
 	if ee.OriginalError == nil {
 		return 1
@@ -198,6 +240,59 @@ func (ee *ExErr) Depth() int {
 	}
 }
 
+// contains test if the supplied error is contained in this error (anywhere in the chain)
+func (ee *ExErr) contains(original *ExErr) (*ExErr, bool) {
+	if original == nil {
+		return nil, false
+	}
+
+	if ee == original {
+		return ee, true
+	}
+
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.equalsDirectProperties(curr) {
+			return curr, true
+		}
+	}
+
+	return nil, false
+}
+
+// equalsDirectProperties tests if ee and other are equals, but only looks at primary properties (not `OriginalError` or `Meta`)
+func (ee *ExErr) equalsDirectProperties(other *ExErr) bool {
+
+	if ee.UniqueID != other.UniqueID {
+		return false
+	}
+	if ee.Timestamp != other.Timestamp {
+		return false
+	}
+	if ee.Category != other.Category {
+		return false
+	}
+	if ee.Severity != other.Severity {
+		return false
+	}
+	if ee.Type != other.Type {
+		return false
+	}
+	if ee.StatusCode != other.StatusCode {
+		return false
+	}
+	if ee.Message != other.Message {
+		return false
+	}
+	if ee.WrappedErrType != other.WrappedErrType {
+		return false
+	}
+	if ee.Caller != other.Caller {
+		return false
+	}
+
+	return true
+}
+
 func newID() string {
 	return xid.New().String()
 }

exerr/exerr_test.go

@@ -0,0 +1,93 @@
+package exerr
+
+import (
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"testing"
+)
+
+type golangErr struct {
+	Message string
+}
+
+func (g golangErr) Error() string {
+	return g.Message
+}
+
+type golangErr2 struct {
+	Message string
+}
+
+func (g golangErr2) Error() string {
+	return g.Message
+}
+
+type simpleError struct {
+}
+
+func (g simpleError) Error() string {
+	return "Something simple went wroong"
+}
+
+type simpleError2 struct {
+}
+
+func (g simpleError2) Error() string {
+	return "Something simple went wroong"
+}
+
+func TestExErrIs1(t *testing.T) {
+	e0 := simpleError{}
+
+	wrap := Wrap(e0, "something went wrong").Str("test", "123").Build()
+
+	tst.AssertTrue(t, errors.Is(wrap, simpleError{}))
+	tst.AssertFalse(t, errors.Is(wrap, golangErr{}))
+	tst.AssertFalse(t, errors.Is(wrap, golangErr{"error1"}))
+}
+
+func TestExErrIs2(t *testing.T) {
+	e0 := golangErr{"error1"}
+
+	wrap := Wrap(e0, "something went wrong").Str("test", "123").Build()
+
+	tst.AssertTrue(t, errors.Is(wrap, e0))
+	tst.AssertTrue(t, errors.Is(wrap, golangErr{"error1"}))
+	tst.AssertFalse(t, errors.Is(wrap, golangErr{"error2"}))
+	tst.AssertFalse(t, errors.Is(wrap, simpleError{}))
+}
+
+func TestExErrAs(t *testing.T) {
+
+	e0 := golangErr{"error1"}
+
+	w0 := Wrap(e0, "something went wrong").Str("test", "123").Build()
+
+	{
+		out := golangErr{}
+		ok := errors.As(w0, &out)
+		tst.AssertTrue(t, ok)
+		tst.AssertEqual(t, out.Message, "error1")
+	}
+
+	w1 := Wrap(w0, "outher error").Build()
+
+	{
+		out := golangErr{}
+		ok := errors.As(w1, &out)
+		tst.AssertTrue(t, ok)
+		tst.AssertEqual(t, out.Message, "error1")
+	}
+
+	{
+		out := golangErr2{}
+		ok := errors.As(w1, &out)
+		tst.AssertFalse(t, ok)
+	}
+
+	{
+		out := simpleError2{}
+		ok := errors.As(w1, &out)
+		tst.AssertFalse(t, ok)
+	}
+}

exerr/gin.go

@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-func (ee *ExErr) toJson(depth int, applyExtendListener bool) langext.H {
+func (ee *ExErr) toJson(depth int, applyExtendListener bool, outputMeta bool) langext.H {
 	ginJson := langext.H{}
 
 	if ee.UniqueID != "" {
@@ -39,7 +39,15 @@ func (ee *ExErr) toJson(depth int, applyExtendListener bool) langext.H {
 		ginJson["wrappedErrType"] = ee.WrappedErrType
 	}
 	if ee.OriginalError != nil {
-		ginJson["original"] = ee.OriginalError.toJson(depth+1, applyExtendListener)
+		ginJson["original"] = ee.OriginalError.toJson(depth+1, applyExtendListener, outputMeta)
+	}
+
+	if outputMeta {
+		metaJson := langext.H{}
+		for metaKey, metaVal := range ee.Meta {
+			metaJson[metaKey] = metaVal.rawValueForJson()
+		}
+		ginJson["meta"] = metaJson
 	}
 
 	if applyExtendListener {
@@ -55,7 +63,8 @@ func (ee *ExErr) toJson(depth int, applyExtendListener bool) langext.H {
 // Parameters:
 //   - [applyExtendListener]:  if false the pkgconfig.ExtendGinOutput / pkgconfig.ExtendGinDataOutput will not be applied
 //   - [includeWrappedErrors]: if false we do not include the recursive/wrapped errors in `__data`
-func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool) langext.H {
+//   - [includeMetaFields]:    if true  we also include meta-values (aka from `.Str(key, value).Build()`), needs includeWrappedErrors=true
+func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool, includeMetaFields bool) langext.H {
 
 	apiOutput := langext.H{
 		"errorid":   ee.UniqueID,
@@ -65,7 +74,7 @@ func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool)
 	}
 
 	if includeWrappedErrors {
-		apiOutput["__data"] = ee.toJson(0, applyExtendListener)
+		apiOutput["__data"] = ee.toJson(0, applyExtendListener, includeMetaFields)
 	}
 
 	if applyExtendListener {
@@ -97,7 +106,7 @@ func (ee *ExErr) Output(g *gin.Context) {
 		statuscode = *baseType.DefaultStatusCode
 	}
 
-	ginOutput := ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput)
+	ginOutput := ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput, pkgconfig.IncludeMetaInGinOutput)
 
 	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
 }

exerr/helper.go

@@ -24,6 +24,8 @@ func IsFrom(e error, original error) bool {
 	if e == nil {
 		return false
 	}
+
+	//goland:noinspection GoDirectComparisonOfErrors
 	if e == original {
 		return true
 	}

exerr/meta.go

@@ -585,6 +585,40 @@ func (v MetaValue) ValueString() string {
 	return "(err)"
 }
 
+// rawValueForJson returns most-of-the-time the `Value` field
+// but for some datatyes we do special processing
+// all, so we can pluck the output value in json.Marshal without any suprises
+func (v MetaValue) rawValueForJson() any {
+	if v.DataType == MDTAny {
+		if v.Value.(AnyWrap).IsNil {
+			return nil
+		}
+		return v.Value.(AnyWrap).Serialize()
+	}
+	if v.DataType == MDTID {
+		if v.Value.(IDWrap).IsNil {
+			return nil
+		}
+		return v.Value.(IDWrap).Value
+	}
+	if v.DataType == MDTBytes {
+		return hex.EncodeToString(v.Value.([]byte))
+	}
+	if v.DataType == MDTDuration {
+		return v.Value.(time.Duration).String()
+	}
+	if v.DataType == MDTTime {
+		return v.Value.(time.Time).Format(time.RFC3339Nano)
+	}
+	if v.DataType == MDTObjectID {
+		return v.Value.(primitive.ObjectID).Hex()
+	}
+	if v.DataType == MDTNil {
+		return nil
+	}
+	return v.Value
+}
+
 func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
 	r := ""
 

ginext/commonMiddlewares.go

@@ -0,0 +1,12 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+)
+
+func BodyBuffer(g *gin.Context) {
+	if g.Request.Body != nil {
+		g.Request.Body = dataext.NewBufferedReadCloser(g.Request.Body)
+	}
+}

ginext/engine.go

@@ -18,6 +18,7 @@ type GinWrapper struct {
 
 	allowCors      bool
 	ginDebug       bool
+	bufferBody     bool
 	requestTimeout time.Duration
 
 	routeSpecs []ginRouteSpec
@@ -30,7 +31,13 @@ type ginRouteSpec struct {
 	Handler     string
 }
 
-func NewEngine(allowCors bool, ginDebug bool, timeout time.Duration) *GinWrapper {
+// NewEngine creates a new (wrapped) ginEngine
+// Parameters are:
+// - [allowCors]    Add cors handler to allow all CORS requests on the default http methods
+// - [ginDebug]     Set gin.debug to true (adds more logs)
+// - [bufferBody]   Buffers the input body stream, this way the ginext error handler can later include the whole request body
+// - [timeout]      The default handler timeout
+func NewEngine(allowCors bool, ginDebug bool, bufferBody bool, timeout time.Duration) *GinWrapper {
 	engine := gin.New()
 
 	wrapper := &GinWrapper{
@@ -38,6 +45,7 @@ func NewEngine(allowCors bool, ginDebug bool, timeout time.Duration) *GinWrapper
 		SuppressGinLogs: false,
 		allowCors:       allowCors,
 		ginDebug:        ginDebug,
+		bufferBody:      bufferBody,
 		requestTimeout:  timeout,
 	}
 

ginext/response.go

@@ -113,6 +113,31 @@ func (j fileHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	return j
 }
 
+type downloadDataHTTPResponse struct {
+	statusCode int
+	mimetype   string
+	data       []byte
+	filename   *string
+	headers    []headerval
+}
+
+func (j downloadDataHTTPResponse) Write(g *gin.Context) {
+	g.Header("Content-Type", j.mimetype) // if we don't set it here gin does weird file-sniffing later...
+	if j.filename != nil {
+		g.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", *j.filename))
+
+	}
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	g.Data(j.statusCode, j.mimetype, j.data)
+}
+
+func (j downloadDataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type redirectHTTPResponse struct {
 	statusCode int
 	url        string
@@ -166,6 +191,10 @@ func Download(mimetype string, filepath string, filename string) HTTPResponse {
 	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath, filename: &filename}
 }
 
+func DownloadData(status int, mimetype string, filename string, data []byte) HTTPResponse {
+	return &downloadDataHTTPResponse{statusCode: status, mimetype: mimetype, data: data, filename: &filename}
+}
+
 func Redirect(sc int, newURL string) HTTPResponse {
 	return &redirectHTTPResponse{statusCode: sc, url: newURL}
 }

ginext/routes.go

@@ -111,6 +111,13 @@ func (w *GinRouteBuilder) Use(middleware ...gin.HandlerFunc) *GinRouteBuilder {
 
 func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {
 
+	if w.routes.wrapper.bufferBody {
+		arr := make([]gin.HandlerFunc, 0, len(w.handlers)+1)
+		arr = append(arr, BodyBuffer)
+		arr = append(arr, w.handlers...)
+		w.handlers = arr
+	}
+
 	middlewareNames := langext.ArrMap(w.handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
 	handlerName := nameOfFunction(handler)
 
@@ -136,13 +143,25 @@ func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {
 }
 
 func (w *GinWrapper) NoRoute(handler WHandlerFunc) {
-	w.engine.NoRoute(Wrap(w, handler))
+
+	handlers := make([]gin.HandlerFunc, 0)
+
+	if w.bufferBody {
+		handlers = append(handlers, BodyBuffer)
+	}
+
+	middlewareNames := langext.ArrMap(handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
+	handlerName := nameOfFunction(handler)
+
+	handlers = append(handlers, Wrap(w, handler))
+
+	w.engine.NoRoute(handlers...)
 
 	w.routeSpecs = append(w.routeSpecs, ginRouteSpec{
 		Method:      "ANY",
 		URL:         "[NO_ROUTE]",
-		Middlewares: nil,
+		Middlewares: middlewareNames,
-		Handler:     nameOfFunction(handler),
+		Handler:     handlerName,
 	})
 }
 

go.mod

@@ -6,11 +6,11 @@ require (
 	github.com/gin-gonic/gin v1.9.1
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/rs/xid v1.5.0
-	github.com/rs/zerolog v1.29.1
+	github.com/rs/zerolog v1.30.0
-	go.mongodb.org/mongo-driver v1.12.0
+	go.mongodb.org/mongo-driver v1.12.1
-	golang.org/x/crypto v0.11.0
+	golang.org/x/crypto v0.12.0
-	golang.org/x/sys v0.10.0
+	golang.org/x/sys v0.11.0
-	golang.org/x/term v0.10.0
+	golang.org/x/term v0.11.0
 )
 
 require (
@@ -21,7 +21,7 @@ require (
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.14.1 // indirect
+	github.com/go-playground/validator/v10 v10.15.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
@@ -42,9 +42,9 @@ require (
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
 	golang.org/x/arch v0.4.0 // indirect
-	golang.org/x/net v0.12.0 // indirect
+	golang.org/x/net v0.14.0 // indirect
 	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/text v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -26,6 +26,8 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
 github.com/go-playground/validator/v10 v10.14.1 h1:9c50NUPC30zyuKprjL3vNZ0m5oG+jU0zvx4AqHGnv4k=
 github.com/go-playground/validator/v10 v10.14.1/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-playground/validator/v10 v10.15.0 h1:nDU5XeOKtB3GEa+uB7GNYwhVKsgjAR7VgKoNB6ryXfw=
+github.com/go-playground/validator/v10 v10.15.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
@@ -87,6 +89,8 @@ github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w=
 github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
 github.com/rs/zerolog v1.29.1 h1:cO+d60CHkknCbvzEWxP0S9K6KqyTjrCNUy1LdQLCGPc=
 github.com/rs/zerolog v1.29.1/go.mod h1:Le6ESbR7hc+DP6Lt1THiV8CQSdkkNrd3R0XbEgp3ZBU=
+github.com/rs/zerolog v1.30.0 h1:SymVODrcRsaRaSInD9yQtKbtWqwsfoPcRff/oRXLj4c=
+github.com/rs/zerolog v1.30.0/go.mod h1:/tk+P47gFdPXq4QYjvCmT5/Gsug2nagsFWBWhAiSi1w=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -122,6 +126,8 @@ go.mongodb.org/mongo-driver v1.11.2 h1:+1v2rDQUWNcGW7/7E0Jvdz51V38XXxJfhzbV17aNH
 go.mongodb.org/mongo-driver v1.11.2/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
 go.mongodb.org/mongo-driver v1.12.0 h1:aPx33jmn/rQuJXPQLZQ8NtfPQG8CaqgLThFtqRb0PiE=
 go.mongodb.org/mongo-driver v1.12.0/go.mod h1:AZkxhPnFJUoH7kZlFkVKucV20K387miPfm7oimrSmK0=
+go.mongodb.org/mongo-driver v1.12.1 h1:nLkghSU8fQNaK7oUmDhQFsnrtcoNy7Z6LVFKsEecqgE=
+go.mongodb.org/mongo-driver v1.12.1/go.mod h1:/rGBTebI3XYboVmgz+Wv3Bcbl3aD0QF9zl6kDDw18rQ=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc=
 golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
@@ -133,6 +139,8 @@ golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
 golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
 golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
 golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -141,6 +149,10 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
 golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
+golang.org/x/net v0.13.0 h1:Nvo8UFsZ8X3BhAC9699Z1j7XQ3rsZnUUm7jfBEk1ueY=
+golang.org/x/net v0.13.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
+golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -166,6 +178,8 @@ golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
 golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0 h1:g6Z6vPFA9dYBAF7DWcH6sCcOntplXsDKcliusYijMlw=
@@ -174,6 +188,8 @@ golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
 golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
 golang.org/x/term v0.10.0 h1:3R7pNqamzBraeqj/Tj8qt1aQ2HpmlC+Cx/qL/7hn4/c=
 golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
+golang.org/x/term v0.11.0 h1:F9tnn/DA/Im8nCwm+fX+1/eBwi4qFjRT++MhtVC4ZX0=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -184,6 +200,8 @@ golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
 golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.216"
+const GoextVersion = "0.0.234"
 
-const GoextVersionTimestamp = "2023-07-27T17:00:53+0200"
+const GoextVersionTimestamp = "2023-08-09T10:39:14+0200"

sq/transaction.go

@@ -7,24 +7,40 @@ import (
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 )
 
+type TxStatus string
+
+const (
+	TxStatusInitial  TxStatus = "INITIAL"
+	TxStatusActive   TxStatus = "ACTIVE"
+	TxStatusComitted TxStatus = "COMMITTED"
+	TxStatusRollback TxStatus = "ROLLBACK"
+)
+
 type Tx interface {
 	Rollback() error
 	Commit() error
+	Status() TxStatus
 	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
 	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
 }
 
 type transaction struct {
-	tx   *sqlx.Tx
+	tx       *sqlx.Tx
-	id   uint16
+	id       uint16
-	lstr []Listener
+	lstr     []Listener
+	status   TxStatus
+	execCtr  int
+	queryCtr int
 }
 
 func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
 	return &transaction{
-		tx:   xtx,
+		tx:       xtx,
-		id:   txid,
+		id:       txid,
-		lstr: lstr,
+		lstr:     lstr,
+		status:   TxStatusInitial,
+		execCtr:  0,
+		queryCtr: 0,
 	}
 }
 
@@ -38,6 +54,10 @@ func (tx *transaction) Rollback() error {
 
 	result := tx.tx.Rollback()
 
+	if result == nil {
+		tx.status = TxStatusRollback
+	}
+
 	for _, v := range tx.lstr {
 		v.PostTxRollback(tx.id, result)
 	}
@@ -55,6 +75,10 @@ func (tx *transaction) Commit() error {
 
 	result := tx.tx.Commit()
 
+	if result == nil {
+		tx.status = TxStatusComitted
+	}
+
 	for _, v := range tx.lstr {
 		v.PostTxRollback(tx.id, result)
 	}
@@ -73,6 +97,10 @@ func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Re
 
 	res, err := tx.tx.NamedExecContext(ctx, sqlstr, prep)
 
+	if tx.status == TxStatusInitial && err == nil {
+		tx.status = TxStatusActive
+	}
+
 	for _, v := range tx.lstr {
 		v.PostExec(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
@@ -94,6 +122,10 @@ func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx
 
 	rows, err := sqlx.NamedQueryContext(ctx, tx.tx, sqlstr, prep)
 
+	if tx.status == TxStatusInitial && err == nil {
+		tx.status = TxStatusActive
+	}
+
 	for _, v := range tx.lstr {
 		v.PostQuery(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
@@ -103,3 +135,11 @@ func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx
 	}
 	return rows, nil
 }
+
+func (tx *transaction) Status() TxStatus {
+	return tx.status
+}
+
+func (tx *transaction) Traffic() (int, int) {
+	return tx.execCtr, tx.queryCtr
+}