v0.0.217

bfcodegen/enum-generate.go

@@ -31,13 +31,13 @@ type EnumDef struct {
 	Values       []EnumDefVal
 }
 
-var rexPackage = rext.W(regexp.MustCompile("^package\\s+(?P<name>[A-Za-z0-9_]+)\\s*$"))
+var rexPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
 
-var rexEnumDef = rext.W(regexp.MustCompile("^\\s*type\\s+(?P<name>[A-Za-z0-9_]+)\\s+(?P<type>[A-Za-z0-9_]+)\\s*//\\s*(@enum:type).*$"))
+var rexEnumDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*//\s*(@enum:type).*$`))
 
-var rexValueDef = rext.W(regexp.MustCompile("^\\s*(?P<name>[A-Za-z0-9_]+)\\s+(?P<type>[A-Za-z0-9_]+)\\s*=\\s*(?P<value>(\"[A-Za-z0-9_:]+\"|[0-9]+))\\s*(//(?P<descr>.*))?.*$"))
+var rexValueDef = rext.W(regexp.MustCompile(`^\s*(?P<name>[A-Za-z0-9_]+)\s+(?P<type>[A-Za-z0-9_]+)\s*=\s*(?P<value>("[A-Za-z0-9_:]+"|[0-9]+))\s*(//(?P<descr>.*))?.*$`))
 
-var rexChecksumConst = rext.W(regexp.MustCompile("const ChecksumGenerator = \"(?P<cs>[A-Za-z0-9_]*)\""))
+var rexChecksumConst = rext.W(regexp.MustCompile(`const ChecksumGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
 
 func GenerateEnumSpecs(sourceDir string, destFile string) error {
 

exerr/builder.go

@@ -2,10 +2,13 @@ package exerr
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"os"
@@ -17,21 +20,21 @@ import (
 //
 // ==== USAGE =====
 //
-// If some method returns an error _always wrap it into an bmerror:
+// If some method returns an error _always wrap it into an exerror:
 //     value, err := do_something(..)
 //     if err != nil {
-//         return nil, bmerror.Wrap(err, "do something failed").Build()
+//         return nil, exerror.Wrap(err, "do something failed").Build()
 //     }
 //
 // If possible add metadata to the error (eg the id that was not found, ...), the methods are the same as in zerolog
-//     return nil, bmerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
+//     return nil, exerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
 //
 // You can change the errortype with `.User()` and `.System()` (User-errors are 400 and System-errors 500)
 // You can also manually set the statuscode with `.WithStatuscode(http.NotFound)`
 // You can set the type with `WithType(..)`
 //
 // New Errors (that don't wrap an existing err object) are created with New
-//     return nil, bmerror.New(bmerror.ErrInternal, "womethign wen horrible wrong").Build()
+//     return nil, exerror.New(exerror.TypeInternal, "womethign wen horrible wrong").Build()
 // You can eitehr use an existing ErrorType, the "catch-all" ErrInternal, or add you own ErrType in consts.go
 //
 // All errors should be handled one of the following four ways:
@@ -64,37 +67,41 @@ func init() {
 }
 
 type Builder struct {
-	bmerror *bringmanError
+	errorData       *ExErr
-
 	containsGinData bool
 }
 
 func Get(err error) *Builder {
-	return &Builder{bmerror: fromError(err)}
+	return &Builder{errorData: FromError(err)}
 }
 
 func New(t ErrorType, msg string) *Builder {
-	return &Builder{bmerror: newBringmanErr(CatSystem, t, msg)}
+	return &Builder{errorData: newExErr(CatSystem, t, msg)}
 }
 
 func Wrap(err error, msg string) *Builder {
-	return &Builder{bmerror: fromError(err).wrap(msg, CatWrap, 1)}
+	if !pkgconfig.RecursiveErrors {
+		v := FromError(err)
+		v.Message = msg
+		return &Builder{errorData: v}
+	}
+	return &Builder{errorData: wrapExErr(FromError(err), msg, CatWrap, 1)}
 }
 
 // ----------------------------------------------------------------------------
 
 func (b *Builder) WithType(t ErrorType) *Builder {
-	b.bmerror.Type = t
+	b.errorData.Type = t
 	return b
 }
 
 func (b *Builder) WithStatuscode(status int) *Builder {
-	b.bmerror.StatusCode = status
+	b.errorData.StatusCode = &status
 	return b
 }
 
 func (b *Builder) WithMessage(msg string) *Builder {
-	b.bmerror.Message = msg
+	b.errorData.Message = msg
 	return b
 }
 
@@ -119,7 +126,7 @@ func (b *Builder) WithMessage(msg string) *Builder {
 //
 //   - Send to the error-service
 func (b *Builder) Err() *Builder {
-	b.bmerror.Severity = SevErr
+	b.errorData.Severity = SevErr
 	return b
 }
 
@@ -138,7 +145,7 @@ func (b *Builder) Err() *Builder {
 //
 //   - Logged as Warn
 func (b *Builder) Warn() *Builder {
-	b.bmerror.Severity = SevWarn
+	b.errorData.Severity = SevWarn
 	return b
 }
 
@@ -157,7 +164,7 @@ func (b *Builder) Warn() *Builder {
 //
 //   - -(nothing)-
 func (b *Builder) Info() *Builder {
-	b.bmerror.Severity = SevInfo
+	b.errorData.Severity = SevInfo
 	return b
 }
 
@@ -167,12 +174,12 @@ func (b *Builder) Info() *Builder {
 //
 // Errors with category
 func (b *Builder) User() *Builder {
-	b.bmerror.Category = CatUser
+	b.errorData.Category = CatUser
 	return b
 }
 
 func (b *Builder) System() *Builder {
-	b.bmerror.Category = CatSystem
+	b.errorData.Category = CatSystem
 	return b
 }
 
@@ -268,7 +275,7 @@ func (b *Builder) Stack() *Builder {
 
 func (b *Builder) Errs(key string, val []error) *Builder {
 	for i, valerr := range val {
-		b.addMeta(fmt.Sprintf("%v[%v]", key, i), MDTString, Get(valerr).toBMError().FormatLog(LogPrintFull))
+		b.addMeta(fmt.Sprintf("%v[%v]", key, i), MDTString, Get(valerr).errorData.FormatLog(LogPrintFull))
 	}
 	return b
 }
@@ -299,7 +306,7 @@ func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request)
 		b.Str("gin.context.reqid", ctxVal)
 	}
 	if req.Method != "GET" && req.Body != nil && req.Header.Get("Content-Type") == "application/json" {
-		if brc, ok := req.Body.(langext.BufferedReadCloser); ok {
+		if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
 			if bin, err := brc.BufferedAll(); err == nil {
 				if len(bin) < 16*1024 {
 					var prettyJSON bytes.Buffer
@@ -348,13 +355,17 @@ func formatHeader(header map[string][]string) string {
 // Build creates a new error, ready to pass up the stack
 // If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
 func (b *Builder) Build() error {
-	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+	warnOnPkgConfigNotInitialized()
-		b.bmerror.ShortLog(stackSkipLogger.Error())
+
+	if pkgconfig.ZeroLogErrTraces && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
+		b.errorData.ShortLog(stackSkipLogger.Error())
+	} else if pkgconfig.ZeroLogAllTraces {
+		b.errorData.ShortLog(stackSkipLogger.Error())
 	}
 
 	b.CallListener(MethodBuild)
 
-	return b.bmerror.ToGrpcError()
+	return b.errorData
 }
 
 // Output prints the error onto the gin stdout.
@@ -366,12 +377,12 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 		b.GinReq(ctx, g, g.Request)
 	}
 
-	b.bmerror.Output(ctx, g)
+	b.errorData.Output(g)
 
-	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+	if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
-		b.bmerror.Log(stackSkipLogger.Error())
+		b.errorData.Log(stackSkipLogger.Error())
-	} else if b.bmerror.Severity == SevWarn {
+	} else if b.errorData.Severity == SevWarn {
-		b.bmerror.Log(stackSkipLogger.Warn())
+		b.errorData.Log(stackSkipLogger.Warn())
 	}
 
 	b.CallListener(MethodOutput)
@@ -380,24 +391,24 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 // Print prints the error
 // If the error is SevErr we also send it to the error-service
 func (b *Builder) Print() {
-	if b.bmerror.Severity == SevErr || b.bmerror.Severity == SevFatal {
+	if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
-		b.bmerror.Log(stackSkipLogger.Error())
+		b.errorData.Log(stackSkipLogger.Error())
-	} else if b.bmerror.Severity == SevWarn {
+	} else if b.errorData.Severity == SevWarn {
-		b.bmerror.ShortLog(stackSkipLogger.Warn())
+		b.errorData.ShortLog(stackSkipLogger.Warn())
 	}
 
 	b.CallListener(MethodPrint)
 }
 
 func (b *Builder) Format(level LogPrintLevel) string {
-	return b.bmerror.FormatLog(level)
+	return b.errorData.FormatLog(level)
 }
 
 // Fatal prints the error and terminates the program
 // If the error is SevErr we also send it to the error-service
 func (b *Builder) Fatal() {
-	b.bmerror.Severity = SevFatal
+	b.errorData.Severity = SevFatal
-	b.bmerror.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
+	b.errorData.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
 
 	b.CallListener(MethodFatal)
 
@@ -407,10 +418,6 @@ func (b *Builder) Fatal() {
 // ----------------------------------------------------------------------------
 
 func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {
-	b.bmerror.Meta.add(key, mdtype, val)
+	b.errorData.Meta.add(key, mdtype, val)
 	return b
 }
-
-func (b *Builder) toBMError() BMError {
-	return b.bmerror.ToBMError()
-}

exerr/constructor.go

@@ -0,0 +1,201 @@
+package exerr
+
+import (
+	"encoding/json"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"time"
+)
+
+var reflectTypeStr = reflect.TypeOf("")
+
+func FromError(err error) *ExErr {
+	if verr, ok := err.(*ExErr); ok {
+		// A simple ExErr
+		return verr
+	}
+
+	// A foreign error (eg a MongoDB exception)
+	return &ExErr{
+		UniqueID:       newID(),
+		Category:       CatForeign,
+		Type:           TypeInternal,
+		Severity:       SevErr,
+		Timestamp:      time.Time{},
+		StatusCode:     nil,
+		Message:        err.Error(),
+		WrappedErrType: fmt.Sprintf("%T", err),
+		Caller:         "",
+		OriginalError:  nil,
+		Meta:           getForeignMeta(err),
+	}
+}
+
+func newExErr(cat ErrorCategory, errtype ErrorType, msg string) *ExErr {
+	return &ExErr{
+		UniqueID:       newID(),
+		Category:       cat,
+		Type:           errtype,
+		Severity:       SevErr,
+		Timestamp:      time.Now(),
+		StatusCode:     nil,
+		Message:        msg,
+		WrappedErrType: "",
+		Caller:         callername(2),
+		OriginalError:  nil,
+		Meta:           make(map[string]MetaValue),
+	}
+}
+
+func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExErr {
+	return &ExErr{
+		UniqueID:       newID(),
+		Category:       cat,
+		Type:           TypeWrap,
+		Severity:       SevErr,
+		Timestamp:      time.Now(),
+		StatusCode:     e.StatusCode,
+		Message:        msg,
+		WrappedErrType: "",
+		Caller:         callername(1 + stacktraceskip),
+		OriginalError:  e,
+		Meta:           make(map[string]MetaValue),
+	}
+}
+
+func getForeignMeta(err error) (mm MetaMap) {
+	mm = make(map[string]MetaValue)
+
+	defer func() {
+		if panicerr := recover(); panicerr != nil {
+			New(TypePanic, "Panic while trying to get foreign meta").
+				Str("source", err.Error()).
+				Interface("panic-object", panicerr).
+				Stack().
+				Print()
+		}
+	}()
+
+	rval := reflect.ValueOf(err)
+	if rval.Kind() == reflect.Interface || rval.Kind() == reflect.Ptr {
+		rval = reflect.ValueOf(err).Elem()
+	}
+
+	mm.add("foreign.errortype", MDTString, rval.Type().String())
+
+	for k, v := range addMetaPrefix("foreign", getReflectedMetaValues(err, 8)) {
+		mm[k] = v
+	}
+
+	return mm
+}
+
+func getReflectedMetaValues(value interface{}, remainingDepth int) map[string]MetaValue {
+
+	if remainingDepth <= 0 {
+		return map[string]MetaValue{}
+	}
+
+	if langext.IsNil(value) {
+		return map[string]MetaValue{"": {DataType: MDTNil, Value: nil}}
+	}
+
+	rval := reflect.ValueOf(value)
+
+	if rval.Type().Kind() == reflect.Ptr {
+
+		if rval.IsNil() {
+			return map[string]MetaValue{"*": {DataType: MDTNil, Value: nil}}
+		}
+
+		elem := rval.Elem()
+
+		return addMetaPrefix("*", getReflectedMetaValues(elem.Interface(), remainingDepth-1))
+	}
+
+	if !rval.CanInterface() {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: "<<no-interface>>"}}
+	}
+
+	raw := rval.Interface()
+
+	switch ifraw := raw.(type) {
+	case time.Time:
+		return map[string]MetaValue{"": {DataType: MDTTime, Value: ifraw}}
+	case time.Duration:
+		return map[string]MetaValue{"": {DataType: MDTDuration, Value: ifraw}}
+	case int:
+		return map[string]MetaValue{"": {DataType: MDTInt, Value: ifraw}}
+	case int8:
+		return map[string]MetaValue{"": {DataType: MDTInt8, Value: ifraw}}
+	case int16:
+		return map[string]MetaValue{"": {DataType: MDTInt16, Value: ifraw}}
+	case int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32, Value: ifraw}}
+	case int64:
+		return map[string]MetaValue{"": {DataType: MDTInt64, Value: ifraw}}
+	case string:
+		return map[string]MetaValue{"": {DataType: MDTString, Value: ifraw}}
+	case bool:
+		return map[string]MetaValue{"": {DataType: MDTBool, Value: ifraw}}
+	case []byte:
+		return map[string]MetaValue{"": {DataType: MDTBytes, Value: ifraw}}
+	case float32:
+		return map[string]MetaValue{"": {DataType: MDTFloat32, Value: ifraw}}
+	case float64:
+		return map[string]MetaValue{"": {DataType: MDTFloat64, Value: ifraw}}
+	case []int:
+		return map[string]MetaValue{"": {DataType: MDTIntArray, Value: ifraw}}
+	case []int32:
+		return map[string]MetaValue{"": {DataType: MDTInt32Array, Value: ifraw}}
+	case primitive.ObjectID:
+		return map[string]MetaValue{"": {DataType: MDTObjectID, Value: ifraw}}
+	case []string:
+		return map[string]MetaValue{"": {DataType: MDTStringArray, Value: ifraw}}
+	}
+
+	if rval.Type().Kind() == reflect.Struct {
+		m := make(map[string]MetaValue)
+		for i := 0; i < rval.NumField(); i++ {
+			fieldtype := rval.Type().Field(i)
+
+			fieldname := fieldtype.Name
+
+			if fieldtype.IsExported() {
+				for k, v := range addMetaPrefix(fieldname, getReflectedMetaValues(rval.Field(i).Interface(), remainingDepth-1)) {
+					m[k] = v
+				}
+			}
+		}
+		return m
+	}
+
+	if rval.Type().ConvertibleTo(reflectTypeStr) {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: rval.Convert(reflectTypeStr).String()}}
+	}
+
+	jsonval, err := json.Marshal(value)
+	if err != nil {
+		panic(err) // gets recovered later up
+	}
+
+	return map[string]MetaValue{"": {DataType: MDTString, Value: string(jsonval)}}
+}
+
+func addMetaPrefix(prefix string, m map[string]MetaValue) map[string]MetaValue {
+	if len(m) == 1 {
+		for k, v := range m {
+			if k == "" {
+				return map[string]MetaValue{prefix: v}
+			}
+		}
+	}
+
+	r := make(map[string]MetaValue, len(m))
+	for k, v := range m {
+		r[prefix+"."+k] = v
+	}
+	return r
+}

exerr/data.go

@@ -1,5 +1,9 @@
 package exerr
 
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
+
 type ErrorCategory struct{ Category string }
 
 var (
@@ -9,6 +13,7 @@ var (
 	CatForeign = ErrorCategory{"Foreign"} // A foreign error that some component threw (e.g. an unknown mongodb error), happens if we call Wrap(..) on an non-bmerror value
 )
 
+//goland:noinspection GoUnusedGlobalVariable
 var AllCategories = []ErrorCategory{CatWrap, CatSystem, CatUser, CatForeign}
 
 type ErrorSeverity struct{ Severity string }
@@ -22,11 +27,42 @@ var (
 	SevFatal = ErrorSeverity{"Fatal"}
 )
 
+//goland:noinspection GoUnusedGlobalVariable
 var AllSeverities = []ErrorSeverity{SevTrace, SevDebug, SevInfo, SevWarn, SevErr, SevFatal}
 
-type ErrorType struct{ Key string }
+type ErrorType struct {
+	Key               string
+	DefaultStatusCode *int
+}
 
+//goland:noinspection GoUnusedGlobalVariable
 var (
-	TypeInternal = ErrorType{"Internal"}
+	TypeInternal       = ErrorType{"INTERNAL_ERROR", langext.Ptr(500)}
+	TypePanic          = ErrorType{"PANIC", langext.Ptr(500)}
+	TypeNotImplemented = ErrorType{"NOT_IMPLEMENTED", langext.Ptr(500)}
+
+	TypeWrap = ErrorType{"Wrap", nil}
+
+	TypeBindFailURI      = ErrorType{"BINDFAIL_URI", langext.Ptr(400)}
+	TypeBindFailQuery    = ErrorType{"BINDFAIL_QUERY", langext.Ptr(400)}
+	TypeBindFailJSON     = ErrorType{"BINDFAIL_JSON", langext.Ptr(400)}
+	TypeBindFailFormData = ErrorType{"BINDFAIL_FORMDATA", langext.Ptr(400)}
+	TypeBindFailHeader   = ErrorType{"BINDFAIL_HEADER", langext.Ptr(400)}
+
+	TypeUnauthorized = ErrorType{"UNAUTHORIZED", langext.Ptr(401)}
+	TypeAuthFailed   = ErrorType{"AUTH_FAILED", langext.Ptr(401)}
+
 	// other values come from pkgconfig
 )
+
+func NewType(key string, defStatusCode *int) ErrorType {
+	return ErrorType{key, defStatusCode}
+}
+
+type LogPrintLevel string
+
+const (
+	LogPrintFull     LogPrintLevel = "Full"
+	LogPrintOverview LogPrintLevel = "Overview"
+	LogPrintShort    LogPrintLevel = "Short"
+)

exerr/errinit.go

@@ -1,23 +1,37 @@
 package exerr
 
+import (
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
+
 type ErrorPackageConfig struct {
-	ZeroLogTraces   bool        // autom print zerolog logs on CreateError
+	ZeroLogErrTraces    bool                                             // autom print zerolog logs on .Build()  (for SevErr and SevFatal)
+	ZeroLogAllTraces    bool                                             // autom print zerolog logs on .Build()  (for all Severities)
 	RecursiveErrors     bool                                             // errors contains their Origin-Error
-	Types           []ErrorType // all available error-types
+	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
+	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any) // (Optionally) extend the gin `__data` output with more fields
 }
 
 type ErrorPackageConfigInit struct {
-	LogTraces       bool
+	ZeroLogErrTraces    bool
+	ZeroLogAllTraces    bool
 	RecursiveErrors     bool
-	InitTypes       func(_ func(_ string) ErrorType)
+	ExtendedGinOutput   bool
+	ExtendGinOutput     func(err *ExErr, json map[string]any)
+	ExtendGinDataOutput func(err *ExErr, depth int, json map[string]any)
 }
 
 var initialized = false
 
 var pkgconfig = ErrorPackageConfig{
-	ZeroLogTraces:   true,
+	ZeroLogErrTraces:    true,
+	ZeroLogAllTraces:    false,
 	RecursiveErrors:     true,
-	Types:           []ErrorType{TypeInternal},
+	ExtendedGinOutput:   false,
+	ExtendGinOutput:     func(err *ExErr, json map[string]any) {},
+	ExtendGinDataOutput: func(err *ExErr, depth int, json map[string]any) {},
 }
 
 // Init initializes the exerr packages
@@ -28,23 +42,35 @@ func Init(cfg ErrorPackageConfigInit) {
 		panic("Cannot re-init error package")
 	}
 
-	types := pkgconfig.Types
+	ego := func(err *ExErr, json map[string]any) {}
+	egdo := func(err *ExErr, depth int, json map[string]any) {}
 
-	fnAddType := func(v string) ErrorType {
+	if cfg.ExtendGinOutput != nil {
-		et := ErrorType{v}
+		ego = cfg.ExtendGinOutput
-		types = append(types, et)
-		return et
 	}
-
+	if cfg.ExtendGinDataOutput != nil {
-	if cfg.InitTypes != nil {
+		egdo = cfg.ExtendGinDataOutput
-		cfg.InitTypes(fnAddType)
 	}
 
 	pkgconfig = ErrorPackageConfig{
-		ZeroLogTraces:   cfg.LogTraces,
+		ZeroLogErrTraces:    cfg.ZeroLogErrTraces,
+		ZeroLogAllTraces:    cfg.ZeroLogAllTraces,
 		RecursiveErrors:     cfg.RecursiveErrors,
-		Types:           types,
+		ExtendedGinOutput:   cfg.ExtendedGinOutput,
+		ExtendGinOutput:     ego,
+		ExtendGinDataOutput: egdo,
 	}
 
 	initialized = true
 }
+
+func warnOnPkgConfigNotInitialized() {
+	if !initialized {
+		fmt.Printf("\n")
+		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
+		fmt.Printf("%s\n", "[WARNING] exerr package used without initializiation")
+		fmt.Printf("%s\n", "          call exerr.Init() in your main() function")
+		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
+		fmt.Printf("\n")
+	}
+}

exerr/exerr.go

@@ -1,6 +1,10 @@
 package exerr
 
 import (
+	"github.com/rs/xid"
+	"github.com/rs/zerolog"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"strings"
 	"time"
 )
 
@@ -12,7 +16,10 @@ type ExErr struct {
 	Severity  ErrorSeverity `json:"severity"`
 	Type      ErrorType     `json:"type"`
 
+	StatusCode *int `json:"statusCode"`
+
 	Message        string `json:"message"`
+	WrappedErrType string `json:"wrappedErrType"`
 	Caller         string `json:"caller"`
 
 	OriginalError *ExErr
@@ -20,14 +27,177 @@ type ExErr struct {
 	Meta MetaMap `json:"meta"`
 }
 
-func (ee ExErr) Error() string {
+func (ee *ExErr) Error() string {
-
+	return ee.Message
 }
 
-func (ee ExErr) Unwrap() error {
+func (ee *ExErr) Unwrap() error {
-
+	return ee.OriginalError
 }
 
-func (ee ExErr) Is(err error) bool {
+func (ee *ExErr) Log(evt *zerolog.Event) {
-
+	evt.Msg(ee.FormatLog(LogPrintFull))
+}
+
+func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
+	if lvl == LogPrintShort {
+
+		msg := ee.Message
+		if ee.OriginalError != nil && ee.OriginalError.Category == CatForeign {
+			msg = msg + " (" + strings.ReplaceAll(ee.OriginalError.Message, "\n", " ") + ")"
+		}
+
+		if ee.Type != TypeWrap {
+			return "[" + ee.Type.Key + "] " + msg
+		} else {
+			return msg
+		}
+
+	} else if lvl == LogPrintOverview {
+
+		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
+
+		indent := ""
+		for curr := ee; curr != nil; curr = curr.OriginalError {
+			indent += "  "
+
+			str += indent
+			str += "-> "
+			strmsg := strings.Trim(curr.Message, " \r\n\t")
+			if lbidx := strings.Index(curr.Message, "\n"); lbidx >= 0 {
+				strmsg = strmsg[0:lbidx]
+			}
+			strmsg = langext.StrLimit(strmsg, 61, "...")
+			str += strmsg
+			str += "\n"
+
+		}
+		return str
+
+	} else if lvl == LogPrintFull {
+
+		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
+
+		indent := ""
+		for curr := ee; curr != nil; curr = curr.OriginalError {
+			indent += "  "
+
+			etype := ee.Type.Key
+			if ee.Type == TypeWrap {
+				etype = "~"
+			}
+
+			str += indent
+			str += "-> ["
+			str += etype
+			if curr.Category == CatForeign {
+				str += "|Foreign"
+			}
+			str += "] "
+			str += strings.ReplaceAll(curr.Message, "\n", " ")
+			if curr.Caller != "" {
+				str += " (@ "
+				str += curr.Caller
+				str += ")"
+			}
+			str += "\n"
+
+			if curr.Meta.Any() {
+				meta := indent + "   {" + curr.Meta.FormatOneLine(240) + "}"
+				if len(meta) < 200 {
+					str += meta
+					str += "\n"
+				} else {
+					str += curr.Meta.FormatMultiLine(indent+"   ", "  ", 1024)
+					str += "\n"
+				}
+			}
+		}
+		return str
+
+	} else {
+
+		return "[?[" + ee.UniqueID + "]?]"
+
+	}
+}
+
+func (ee *ExErr) ShortLog(evt *zerolog.Event) {
+	ee.Meta.Apply(evt).Msg(ee.FormatLog(LogPrintShort))
+}
+
+// RecursiveMessage returns the message to show
+// = first error (top-down) that is not wrapping/foreign/empty
+func (ee *ExErr) RecursiveMessage() string {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.Message != "" && curr.Category != CatWrap && curr.Category != CatForeign {
+			return curr.Message
+		}
+	}
+
+	// fallback to self
+	return ee.Message
+}
+
+// RecursiveType returns the statuscode to use
+// = first error (top-down) that is not wrapping/empty
+func (ee *ExErr) RecursiveType() ErrorType {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.Type != TypeWrap {
+			return curr.Type
+		}
+
+	}
+
+	// fallback to self
+	return ee.Type
+}
+
+// RecursiveStatuscode returns the HTTP Statuscode to use
+// = first error (top-down) that has a statuscode set
+func (ee *ExErr) RecursiveStatuscode() *int {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.StatusCode != nil {
+			return langext.Ptr(*curr.StatusCode)
+		}
+	}
+
+	return nil
+}
+
+// RecursiveCategory returns the ErrorCategory to use
+// = first error (top-down) that has a statuscode set
+func (ee *ExErr) RecursiveCategory() ErrorCategory {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.Category != CatWrap {
+			return curr.Category
+		}
+	}
+
+	// fallback to <empty>
+	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
+	} else {
+		return ee.OriginalError.Depth() + 1
+	}
+}
+
+func newID() string {
+	return xid.New().String()
 }

exerr/gin.go

@@ -0,0 +1,103 @@
+package exerr
+
+import (
+	"github.com/gin-gonic/gin"
+	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"net/http"
+	"time"
+)
+
+func (ee *ExErr) toJson(depth int, applyExtendListener bool) langext.H {
+	ginJson := langext.H{}
+
+	if ee.UniqueID != "" {
+		ginJson["id"] = ee.UniqueID
+	}
+	if ee.Category != CatWrap {
+		ginJson["category"] = ee.Category
+	}
+	if ee.Type != TypeWrap {
+		ginJson["type"] = ee.Type
+	}
+	if ee.StatusCode != nil {
+		ginJson["statuscode"] = ee.StatusCode
+	}
+	if ee.Message != "" {
+		ginJson["message"] = ee.Message
+	}
+	if ee.Caller != "" {
+		ginJson["caller"] = ee.Caller
+	}
+	if ee.Severity != SevErr {
+		ginJson["severity"] = ee.Severity
+	}
+	if ee.Timestamp != (time.Time{}) {
+		ginJson["time"] = ee.Timestamp.Format(time.RFC3339)
+	}
+	if ee.WrappedErrType != "" {
+		ginJson["wrappedErrType"] = ee.WrappedErrType
+	}
+	if ee.OriginalError != nil {
+		ginJson["original"] = ee.OriginalError.toJson(depth+1, applyExtendListener)
+	}
+
+	if applyExtendListener {
+		pkgconfig.ExtendGinDataOutput(ee, depth, ginJson)
+	}
+
+	return ginJson
+}
+
+// ToAPIJson converts the ExError to a json object
+// (the same object as used in the Output(gin) method)
+//
+// 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 {
+
+	apiOutput := langext.H{
+		"errorid":   ee.UniqueID,
+		"message":   ee.RecursiveMessage(),
+		"errorcode": ee.RecursiveType().Key,
+		"category":  ee.RecursiveCategory().Category,
+	}
+
+	if includeWrappedErrors {
+		apiOutput["__data"] = ee.toJson(0, applyExtendListener)
+	}
+
+	if applyExtendListener {
+		pkgconfig.ExtendGinOutput(ee, apiOutput)
+	}
+
+	return apiOutput
+}
+
+func (ee *ExErr) Output(g *gin.Context) {
+
+	warnOnPkgConfigNotInitialized()
+
+	var statuscode = http.StatusInternalServerError
+
+	var baseCat = ee.RecursiveCategory()
+	var baseType = ee.RecursiveType()
+	var baseStatuscode = ee.RecursiveStatuscode()
+
+	if baseCat == CatUser {
+		statuscode = http.StatusBadRequest
+	} else if baseCat == CatSystem {
+		statuscode = http.StatusInternalServerError
+	}
+
+	if baseStatuscode != nil {
+		statuscode = *ee.StatusCode
+	} else if baseType.DefaultStatusCode != nil {
+		statuscode = *baseType.DefaultStatusCode
+	}
+
+	ginOutput := ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput)
+
+	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
+}

exerr/helper.go

@@ -0,0 +1,86 @@
+package exerr
+
+import "fmt"
+
+// IsType test if the supplied error is of the specified ErrorType.
+func IsType(err error, errType ErrorType) bool {
+	if err == nil {
+		return false
+	}
+
+	bmerr := FromError(err)
+	for bmerr != nil {
+		if bmerr.Type == errType {
+			return true
+		}
+		bmerr = bmerr.OriginalError
+	}
+
+	return false
+}
+
+// IsFrom test if the supplied error stems originally from original
+func IsFrom(e error, original error) bool {
+	if e == nil {
+		return false
+	}
+	if e == original {
+		return true
+	}
+
+	bmerr := FromError(e)
+	for bmerr == nil {
+		return false
+	}
+
+	for curr := bmerr; curr != nil; curr = curr.OriginalError {
+		if curr.Category == CatForeign && curr.Message == original.Error() && curr.WrappedErrType == fmt.Sprintf("%T", original) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// HasSourceMessage tests if the supplied error stems originally from an error with the message msg
+func HasSourceMessage(e error, msg string) bool {
+	if e == nil {
+		return false
+	}
+
+	bmerr := FromError(e)
+	for bmerr == nil {
+		return false
+	}
+
+	for curr := bmerr; curr != nil; curr = curr.OriginalError {
+		if curr.OriginalError == nil && curr.Message == msg {
+			return true
+		}
+	}
+
+	return false
+}
+
+func MessageMatch(e error, matcher func(string) bool) bool {
+	if e == nil {
+		return false
+	}
+
+	if matcher(e.Error()) {
+		return true
+	}
+
+	bmerr := FromError(e)
+	for bmerr == nil {
+		return false
+	}
+
+	for curr := bmerr; curr != nil; curr = curr.OriginalError {
+		if matcher(curr.Message) {
+			return true
+		}
+	}
+
+	return false
+}

exerr/listener.go

@@ -13,7 +13,7 @@ const (
 	MethodFatal  Method = "FATAL"
 )
 
-type Listener = func(method Method, v ExErr)
+type Listener = func(method Method, v *ExErr)
 
 var listenerLock = sync.Mutex{}
 var listener = make([]Listener, 0)
@@ -26,7 +26,7 @@ func RegisterListener(l Listener) {
 }
 
 func (b *Builder) CallListener(m Method) {
-	valErr := b.toBMError()
+	valErr := b.errorData
 
 	listenerLock.Lock()
 	defer listenerLock.Unlock()

exerr/meta.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
@@ -15,6 +14,10 @@ import (
 	"time"
 )
 
+// This is a buffed up map[string]any
+// we also save type information of the map-values
+// which allows us to deserialize them back into te correct types later
+
 type MetaMap map[string]MetaValue
 
 type metaDataType string
@@ -350,11 +353,7 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 			v.DataType = datatype
 			return nil
 		} else {
-			r, err := valueFromProto(value[1:], MDTString)
+			v.Value = langext.Ptr(value[1:])
-			if err != nil {
-				return err
-			}
-			v.Value = langext.Ptr(r.Value.(string))
 			v.DataType = datatype
 			return nil
 		}
@@ -586,51 +585,6 @@ func (v MetaValue) ValueString() string {
 	return "(err)"
 }
 
-func valueFromProto(value string, datatype metaDataType) (MetaValue, error) {
-	obj := MetaValue{}
-	err := obj.Deserialize(value, datatype)
-	if err != nil {
-		return MetaValue{}, err
-	}
-	return obj, nil
-}
-
-func metaFromProto(proto []*spbmodels.CustomError_MetaValue) MetaMap {
-	r := make(MetaMap)
-
-	for _, v := range proto {
-		mval, err := valueFromProto(v.Value, metaDataType(v.Type))
-		if err != nil {
-			log.Warn().Err(err).Msg("metaFromProto failed for " + v.Key)
-			continue
-		}
-		r[v.Key] = mval
-	}
-
-	return r
-}
-
-func (mm MetaMap) ToProto() []*spbmodels.CustomError_MetaValue {
-	if mm == nil {
-		return make([]*spbmodels.CustomError_MetaValue, 0)
-	}
-	r := make([]*spbmodels.CustomError_MetaValue, 0, len(mm))
-	for k, v := range mm {
-		strval, err := v.SerializeValue()
-		if err != nil {
-			log.Warn().Err(err).Msg("MetaMap.ToProto failed for " + k)
-			continue
-		}
-
-		r = append(r, &spbmodels.CustomError_MetaValue{
-			Key:   k,
-			Type:  string(v.DataType),
-			Value: strval,
-		})
-	}
-	return r
-}
-
 func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
 	r := ""
 

exerr/stacktrace.go

@@ -0,0 +1,14 @@
+package exerr
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func callername(skip int) string {
+	pc := make([]uintptr, 15)
+	n := runtime.Callers(skip+2, pc)
+	frames := runtime.CallersFrames(pc[:n])
+	frame, _ := frames.Next()
+	return fmt.Sprintf("%s:%d %s", frame.File, frame.Line, frame.Function)
+}

ginext/apiError.go

@@ -1,16 +0,0 @@
-package ginext
-
-type apiError struct {
-	ErrorCode        string  `json:"errorcode"`
-	Message          string  `json:"message"`
-	FAPIErrorMessage *string `json:"fapiMessage,omitempty"`
-}
-
-type extAPIError struct {
-	ErrorCode        string  `json:"errorcode"`
-	Message          string  `json:"message"`
-	FAPIErrorMessage *string `json:"fapiMessage,omitempty"`
-
-	RawError *string  `json:"__error"`
-	Trace    []string `json:"__trace"`
-}

ginext/appContext.go

@@ -14,6 +14,9 @@ type AppContext struct {
 }
 
 func CreateAppContext(g *gin.Context, innerCtx context.Context, cancelFn context.CancelFunc) *AppContext {
+	for key, value := range g.Keys {
+		innerCtx = context.WithValue(innerCtx, key, value)
+	}
 	return &AppContext{
 		inner:      innerCtx,
 		cancelFunc: cancelFn,
@@ -38,6 +41,10 @@ func (ac *AppContext) Value(key any) any {
 	return ac.inner.Value(key)
 }
 
+func (ac *AppContext) Set(key, value any) {
+	ac.inner = context.WithValue(ac.inner, key, value)
+}
+
 func (ac *AppContext) Cancel() {
 	ac.cancelled = true
 	ac.cancelFunc()
@@ -50,10 +57,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/commonApiErr/enums.go

@@ -1,21 +0,0 @@
-package commonApiErr
-
-type APIErrorCode struct {
-	HTTPStatusCode int
-	Key            string
-}
-
-//goland:noinspection GoSnakeCaseUsage
-var (
-	NotImplemented = APIErrorCode{500, "NOT_IMPLEMENTED"}
-	InternalError  = APIErrorCode{500, "INTERNAL_ERROR"}
-	Panic          = APIErrorCode{500, "PANIC"}
-
-	BindFailURI      = APIErrorCode{400, "BINDFAIL_URI"}
-	BindFailQuery    = APIErrorCode{400, "BINDFAIL_QUERY"}
-	BindFailJSON     = APIErrorCode{400, "BINDFAIL_JSON"}
-	BindFailFormData = APIErrorCode{400, "BINDFAIL_FORMDATA"}
-
-	Unauthorized = APIErrorCode{401, "UNAUTHORIZED"}
-	AuthFailed   = APIErrorCode{401, "AUTH_FAILED"}
-)

ginext/engine.go

@@ -1,8 +1,14 @@
 package ginext
 
 import (
+	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog/log"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"net"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -12,11 +18,19 @@ type GinWrapper struct {
 
 	allowCors      bool
 	ginDebug       bool
-	returnRawErrors bool
 	requestTimeout time.Duration
+
+	routeSpecs []ginRouteSpec
 }
 
-func NewEngine(allowCors bool, ginDebug bool, returnRawErrors bool, timeout time.Duration) *GinWrapper {
+type ginRouteSpec struct {
+	Method      string
+	URL         string
+	Middlewares []string
+	Handler     string
+}
+
+func NewEngine(allowCors bool, ginDebug bool, timeout time.Duration) *GinWrapper {
 	engine := gin.New()
 
 	wrapper := &GinWrapper{
@@ -24,7 +38,6 @@ func NewEngine(allowCors bool, ginDebug bool, returnRawErrors bool, timeout time
 		SuppressGinLogs: false,
 		allowCors:       allowCors,
 		ginDebug:        ginDebug,
-		returnRawErrors: returnRawErrors,
 		requestTimeout:  timeout,
 	}
 
@@ -35,18 +48,94 @@ func NewEngine(allowCors bool, ginDebug bool, returnRawErrors bool, timeout time
 		engine.Use(CorsMiddleware())
 	}
 
+	// do not debug-print routes
+	gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
+
 	if ginDebug {
+		gin.SetMode(gin.ReleaseMode)
+
 		ginlogger := gin.Logger()
 		engine.Use(func(context *gin.Context) {
 			if !wrapper.SuppressGinLogs {
 				ginlogger(context)
 			}
 		})
+	} else {
+		gin.SetMode(gin.DebugMode)
 	}
 
 	return wrapper
 }
 
-func (w *GinWrapper) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
+func (w *GinWrapper) ListenAndServeHTTP(addr string, postInit func(port string)) (chan error, *http.Server) {
-	w.engine.ServeHTTP(writer, request)
+
+	w.DebugPrintRoutes()
+
+	httpserver := &http.Server{
+		Addr:    addr,
+		Handler: w.engine,
+	}
+
+	errChan := make(chan error)
+
+	go func() {
+
+		ln, err := net.Listen("tcp", httpserver.Addr)
+		if err != nil {
+			errChan <- err
+			return
+		}
+
+		_, port, err := net.SplitHostPort(ln.Addr().String())
+		if err != nil {
+			errChan <- err
+			return
+		}
+
+		log.Info().Str("address", httpserver.Addr).Msg("HTTP-Server started on http://localhost:" + port)
+
+		if postInit != nil {
+			postInit(port) // the net.Listener a few lines above is at this point actually already buffering requests
+		}
+
+		errChan <- httpserver.Serve(ln)
+	}()
+
+	return errChan, httpserver
+}
+
+func (w *GinWrapper) DebugPrintRoutes() {
+	if !w.ginDebug {
+		return
+	}
+
+	lines := make([][4]string, 0)
+
+	pad := [4]int{0, 0, 0, 0}
+
+	for _, spec := range w.routeSpecs {
+
+		line := [4]string{
+			spec.Method,
+			spec.URL,
+			strings.Join(spec.Middlewares, " -> "),
+			spec.Handler,
+		}
+
+		lines = append(lines, line)
+
+		pad[0] = mathext.Max(pad[0], len(line[0]))
+		pad[1] = mathext.Max(pad[1], len(line[1]))
+		pad[2] = mathext.Max(pad[2], len(line[2]))
+		pad[3] = mathext.Max(pad[3], len(line[3]))
+	}
+
+	for _, line := range lines {
+
+		fmt.Printf("Gin-Route: %s  %s  -->  %s  -->  %s\n",
+			langext.StrPadRight("["+line[0]+"]", " ", pad[0]+2),
+			langext.StrPadRight(line[1], " ", pad[1]),
+			langext.StrPadRight(line[2], " ", pad[2]),
+			langext.StrPadRight(line[3], " ", pad[3]))
+	}
 }

ginext/funcWrapper.go

@@ -1,10 +1,9 @@
 package ginext
 
 import (
-	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"github.com/rs/zerolog/log"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 )
 
 type WHandlerFunc func(PreContext) HTTPResponse
@@ -13,18 +12,20 @@ func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
 
 	return func(g *gin.Context) {
 
-		g.Set("__returnRawErrors", w.returnRawErrors)
-
 		reqctx := g.Request.Context()
 
 		wrap, stackTrace, panicObj := callPanicSafe(fn, PreContext{wrapper: w, ginCtx: g})
 		if panicObj != nil {
+
 			fmt.Printf("\n======== ======== STACKTRACE ======== ========\n%s\n======== ======== ======== ========\n\n", stackTrace)
-			log.Error().
+
-				Interface("panicObj", panicObj).
+			err := exerr.
+				New(exerr.TypePanic, "Panic occured (in gin handler)").
+				Any("panicObj", panicObj).
 				Str("trace", stackTrace).
-				Msg("Panic occured (in gin handler)")
+				Build()
-			wrap = APIError(g, commonApiErr.Panic, "A panic occured in the HTTP handler", errors.New(fmt.Sprintf("%+v", panicObj)))
+
+			wrap = Error(err)
 		}
 
 		if g.Writer.Written() {

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"
 )
@@ -15,6 +17,7 @@ type PreContext struct {
 	query   any
 	body    any
 	form    any
+	header  any
 }
 
 func (pctx *PreContext) URI(uri any) *PreContext {
@@ -37,36 +40,73 @@ func (pctx *PreContext) Form(form any) *PreContext {
 	return pctx
 }
 
+func (pctx *PreContext) Header(header any) *PreContext {
+	pctx.header = header
+	return pctx
+}
+
 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(Error(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(Error(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(Error(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(Error(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(Error(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(Error(err))
+		}
+	}
+
+	if pctx.header != nil {
+		if err := pctx.ginCtx.ShouldBindHeader(pctx.query); err != nil {
+			err = exerr.Wrap(err, "Failed to read header").
+				WithType(exerr.TypeBindFailHeader).
+				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
+				Build()
+			return nil, nil, langext.Ptr(Error(err))
 		}
 	}
 

ginext/response.go

@@ -3,57 +3,97 @@ package ginext
 import (
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"github.com/rs/zerolog/log"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"runtime/debug"
-	"strings"
 )
 
+type headerval struct {
+	Key string
+	Val string
+}
+
 type HTTPResponse interface {
 	Write(g *gin.Context)
+	WithHeader(k string, v string) HTTPResponse
 }
 
 type jsonHTTPResponse struct {
 	statusCode int
 	data       any
+	headers    []headerval
 }
 
 func (j jsonHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
 	g.Render(j.statusCode, json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true})
 }
 
+func (j jsonHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type emptyHTTPResponse struct {
 	statusCode int
+	headers    []headerval
 }
 
 func (j emptyHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
 	g.Status(j.statusCode)
 }
 
+func (j emptyHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type textHTTPResponse struct {
 	statusCode int
 	data       string
+	headers    []headerval
 }
 
 func (j textHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
 	g.String(j.statusCode, "%s", j.data)
 }
 
+func (j textHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type dataHTTPResponse struct {
 	statusCode  int
 	data        []byte
 	contentType string
+	headers     []headerval
 }
 
 func (j dataHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
 	g.Data(j.statusCode, j.contentType, j.data)
 }
 
+func (j dataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type fileHTTPResponse struct {
 	mimetype string
 	filepath string
 	filename *string
+	headers  []headerval
 }
 
 func (j fileHTTPResponse) Write(g *gin.Context) {
@@ -62,18 +102,46 @@ func (j fileHTTPResponse) Write(g *gin.Context) {
 		g.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", *j.filename))
 
 	}
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
 	g.File(j.filepath)
 }
 
+func (j fileHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 type redirectHTTPResponse struct {
 	statusCode int
 	url        string
+	headers    []headerval
 }
 
 func (j redirectHTTPResponse) Write(g *gin.Context) {
 	g.Redirect(j.statusCode, j.url)
 }
 
+func (j redirectHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+type jsonAPIErrResponse struct {
+	err     *exerr.ExErr
+	headers []headerval
+}
+
+func (j jsonAPIErrResponse) Write(g *gin.Context) {
+	j.err.Output(g)
+}
+
+func (j jsonAPIErrResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
 func Status(sc int) HTTPResponse {
 	return &emptyHTTPResponse{statusCode: sc}
 }
@@ -102,52 +170,18 @@ func Redirect(sc int, newURL string) HTTPResponse {
 	return &redirectHTTPResponse{statusCode: sc, url: newURL}
 }
 
-func APIError(g *gin.Context, errcode commonApiErr.APIErrorCode, msg string, e error) HTTPResponse {
+func Error(e error) HTTPResponse {
-	return createApiError(g, errcode, msg, e)
+	return &jsonAPIErrResponse{
-}
+		err: exerr.FromError(e),
-
-func NotImplemented(g *gin.Context) HTTPResponse {
-	return createApiError(g, commonApiErr.NotImplemented, "", nil)
-}
-
-func createApiError(g *gin.Context, errcode commonApiErr.APIErrorCode, msg string, e error) HTTPResponse {
-	reqUri := ""
-	if g != nil && g.Request != nil {
-		reqUri = g.Request.Method + " :: " + g.Request.RequestURI
-	}
-
-	log.Error().
-		Str("errorcode.key", errcode.Key).
-		Int("errcode.status", errcode.HTTPStatusCode).
-		Str("uri", reqUri).
-		AnErr("err", e).
-		Stack().
-		Msg(msg)
-
-	var fapiMessage *string = nil
-	if v, ok := e.(interface{ FAPIMessage() string }); ok {
-		fapiMessage = langext.Ptr(v.FAPIMessage())
-	}
-
-	if g.GetBool("__returnRawErrors") {
-		return &jsonHTTPResponse{
-			statusCode: errcode.HTTPStatusCode,
-			data: extAPIError{
-				ErrorCode:        errcode.Key,
-				Message:          msg,
-				RawError:         langext.Ptr(langext.Conditional(e == nil, "", fmt.Sprintf("%+v", e))),
-				FAPIErrorMessage: fapiMessage,
-				Trace:            strings.Split(string(debug.Stack()), "\n"),
-			},
-		}
-	} else {
-		return &jsonHTTPResponse{
-			statusCode: errcode.HTTPStatusCode,
-			data: apiError{
-				ErrorCode:        errcode.Key,
-				Message:          msg,
-				FAPIErrorMessage: fapiMessage,
-			},
-		}
 	}
 }
+
+func ErrWrap(e error, errorType exerr.ErrorType, msg string) HTTPResponse {
+	return &jsonAPIErrResponse{
+		err: exerr.FromError(exerr.Wrap(e, msg).WithType(errorType).Build()),
+	}
+}
+
+func NotImplemented() HTTPResponse {
+	return Error(exerr.New(exerr.TypeNotImplemented, "").Build())
+}

ginext/routes.go

@@ -2,7 +2,14 @@ package ginext
 
 import (
 	"github.com/gin-gonic/gin"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/rext"
 	"net/http"
+	"path"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
 )
 
 var anyMethods = []string{
@@ -14,58 +21,87 @@ var anyMethods = []string{
 type GinRoutesWrapper struct {
 	wrapper        *GinWrapper
 	routes         gin.IRouter
+	absPath        string
+	defaultHandler []gin.HandlerFunc
 }
 
 type GinRouteBuilder struct {
 	routes *GinRoutesWrapper
 
-	methods  []string
+	method   string
 	relPath  string
+	absPath  string
 	handlers []gin.HandlerFunc
 }
 
 func (w *GinWrapper) Routes() *GinRoutesWrapper {
-	return &GinRoutesWrapper{wrapper: w, routes: w.engine}
+	return &GinRoutesWrapper{
+		wrapper:        w,
+		routes:         w.engine,
+		absPath:        "",
+		defaultHandler: make([]gin.HandlerFunc, 0),
+	}
 }
 
 func (w *GinRoutesWrapper) Group(relativePath string) *GinRoutesWrapper {
-	return &GinRoutesWrapper{wrapper: w.wrapper, routes: w.routes.Group(relativePath)}
+	return &GinRoutesWrapper{
+		wrapper:        w.wrapper,
+		routes:         w.routes.Group(relativePath),
+		defaultHandler: langext.ArrCopy(w.defaultHandler),
+		absPath:        joinPaths(w.absPath, relativePath),
+	}
+}
+
+func (w *GinRoutesWrapper) Use(middleware ...gin.HandlerFunc) *GinRoutesWrapper {
+	defHandler := langext.ArrCopy(w.defaultHandler)
+	defHandler = append(defHandler, middleware...)
+	return &GinRoutesWrapper{wrapper: w.wrapper, routes: w.routes, defaultHandler: defHandler}
 }
 
 func (w *GinRoutesWrapper) GET(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodGet}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodGet, relativePath)
 }
 
 func (w *GinRoutesWrapper) POST(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodPost}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodPost, relativePath)
 }
 
 func (w *GinRoutesWrapper) DELETE(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodDelete}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodDelete, relativePath)
 }
 
 func (w *GinRoutesWrapper) PATCH(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodPatch}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodPatch, relativePath)
 }
 
 func (w *GinRoutesWrapper) PUT(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodPut}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodPut, relativePath)
 }
 
 func (w *GinRoutesWrapper) OPTIONS(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodOptions}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodOptions, relativePath)
 }
 
 func (w *GinRoutesWrapper) HEAD(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{http.MethodHead}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route(http.MethodHead, relativePath)
 }
 
 func (w *GinRoutesWrapper) COUNT(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: []string{"COUNT"}, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route("COUNT", relativePath)
 }
 
 func (w *GinRoutesWrapper) Any(relativePath string) *GinRouteBuilder {
-	return &GinRouteBuilder{routes: w, methods: anyMethods, relPath: relativePath, handlers: make([]gin.HandlerFunc, 0)}
+	return w._route("*", relativePath)
+}
+
+func (w *GinRoutesWrapper) _route(method string, relativePath string) *GinRouteBuilder {
+	return &GinRouteBuilder{
+		routes:   w,
+		method:   method,
+		relPath:  relativePath,
+		absPath:  joinPaths(w.absPath, relativePath),
+		handlers: langext.ArrCopy(w.defaultHandler),
+	}
 }
 
 func (w *GinRouteBuilder) Use(middleware ...gin.HandlerFunc) *GinRouteBuilder {
@@ -74,12 +110,83 @@ func (w *GinRouteBuilder) Use(middleware ...gin.HandlerFunc) *GinRouteBuilder {
 }
 
 func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {
+
+	middlewareNames := langext.ArrMap(w.handlers, func(v gin.HandlerFunc) string { return nameOfFunction(v) })
+	handlerName := nameOfFunction(handler)
+
 	w.handlers = append(w.handlers, Wrap(w.routes.wrapper, handler))
-	for _, m := range w.methods {
+
-		w.routes.routes.Handle(m, w.relPath, w.handlers...)
+	methodName := w.method
+
+	if w.method == "*" {
+		methodName = "ANY"
+		for _, method := range anyMethods {
+			w.routes.routes.Handle(method, w.relPath, w.handlers...)
 		}
+	} else {
+		w.routes.routes.Handle(w.method, w.relPath, w.handlers...)
+	}
+
+	w.routes.wrapper.routeSpecs = append(w.routes.wrapper.routeSpecs, ginRouteSpec{
+		Method:      methodName,
+		URL:         w.absPath,
+		Middlewares: middlewareNames,
+		Handler:     handlerName,
+	})
 }
 
 func (w *GinWrapper) NoRoute(handler WHandlerFunc) {
 	w.engine.NoRoute(Wrap(w, handler))
+
+	w.routeSpecs = append(w.routeSpecs, ginRouteSpec{
+		Method:      "ANY",
+		URL:         "[NO_ROUTE]",
+		Middlewares: nil,
+		Handler:     nameOfFunction(handler),
+	})
+}
+
+func nameOfFunction(f any) string {
+
+	fname := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
+
+	split := strings.Split(fname, "/")
+	if len(split) == 0 {
+		return ""
+	}
+
+	fname = split[len(split)-1]
+
+	// https://stackoverflow.com/a/32925345/1761622
+	if strings.HasSuffix(fname, "-fm") {
+		fname = fname[:len(fname)-len("-fm")]
+	}
+
+	suffix := rext.W(regexp.MustCompile(`\.func[0-9]+(?:\.[0-9]+)*$`))
+
+	if match, ok := suffix.MatchFirst(fname); ok {
+		fname = fname[:len(fname)-match.FullMatch().Length()]
+	}
+
+	return fname
+}
+
+// joinPaths is copied verbatim from gin@v1.9.1/gin.go
+func joinPaths(absolutePath, relativePath string) string {
+	if relativePath == "" {
+		return absolutePath
+	}
+
+	finalPath := path.Join(absolutePath, relativePath)
+	if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
+		return finalPath + "/"
+	}
+	return finalPath
+}
+
+func lastChar(str string) uint8 {
+	if str == "" {
+		panic("The length of the string can't be 0")
+	}
+	return str[len(str)-1]
 }

go.mod

@@ -5,6 +5,7 @@ go 1.19
 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
 	go.mongodb.org/mongo-driver v1.12.0
 	golang.org/x/crypto v0.11.0
@@ -13,7 +14,7 @@ require (
 )
 
 require (
-	github.com/bytedance/sonic v1.10.0-rc2 // indirect
+	github.com/bytedance/sonic v1.10.0-rc3 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect

go.sum

@@ -2,6 +2,8 @@ github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1
 github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
 github.com/bytedance/sonic v1.10.0-rc2 h1:oDfRZ+4m6AYCOC0GFeOCeYqvBmucy1isvouS2K0cPzo=
 github.com/bytedance/sonic v1.10.0-rc2/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
+github.com/bytedance/sonic v1.10.0-rc3 h1:uNSnscRapXTwUgTyOF0GVljYD08p9X/Lbr9MweSV3V0=
+github.com/bytedance/sonic v1.10.0-rc3/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
@@ -79,6 +81,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 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=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.187"
+const GoextVersion = "0.0.217"
 
-const GoextVersionTimestamp = "2023-07-24T09:16:37+0200"
+const GoextVersionTimestamp = "2023-07-27T17:12:41+0200"

rext/wrapper_test.go

@@ -8,7 +8,7 @@ import (
 
 func TestGroupByNameOrEmpty1(t *testing.T) {
 
-	regex1 := W(regexp.MustCompile("0(?P<group1>A+)B(?P<group2>C+)0"))
+	regex1 := W(regexp.MustCompile(`0(?P<group1>A+)B(?P<group2>C+)0`))
 
 	match1, ok1 := regex1.MatchFirst("Hello 0AAAABCCC0 Bye.")
 
@@ -26,7 +26,7 @@ func TestGroupByNameOrEmpty1(t *testing.T) {
 
 func TestGroupByNameOrEmpty2(t *testing.T) {
 
-	regex1 := W(regexp.MustCompile("0(?P<group1>A+)B(?P<group2>C+)(?P<group3>C+)?0"))
+	regex1 := W(regexp.MustCompile(`0(?P<group1>A+)B(?P<group2>C+)(?P<group3>C+)?0`))
 
 	match1, ok1 := regex1.MatchFirst("Hello 0AAAABCCC0 Bye.")
 

sq/hasher.go

@@ -39,7 +39,7 @@ func HashSqliteSchema(ctx context.Context, schemaStr string) (string, error) {
 	return HashSqliteDatabase(ctx, db)
 }
 
-func HashSqliteDatabase(ctx context.Context, db DB) (string, error) {
+func HashSqliteDatabase(ctx context.Context, db Queryable) (string, error) {
 	ss, err := CreateSqliteDatabaseSchemaString(ctx, db)
 	if err != nil {
 		return "", err
@@ -50,7 +50,7 @@ func HashSqliteDatabase(ctx context.Context, db DB) (string, error) {
 	return hex.EncodeToString(cs[:]), nil
 }
 
-func CreateSqliteDatabaseSchemaString(ctx context.Context, db DB) (string, error) {
+func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string, error) {
 
 	type colInfo struct {
 		Name       string  `db:"name"`

sq/transaction.go

@@ -7,9 +7,19 @@ 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)
 }
@@ -18,6 +28,9 @@ type transaction struct {
 	tx       *sqlx.Tx
 	id       uint16
 	lstr     []Listener
+	status   TxStatus
+	execCtr  int
+	queryCtr int
 }
 
 func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
@@ -25,6 +38,9 @@ func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
 		tx:       xtx,
 		id:       txid,
 		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
+}

termext/termcolor.go

@@ -71,12 +71,12 @@ func SupportsColors() bool {
 		}
 	}
 
-	var term256Regex = regexp.MustCompile("(?i)-256(color)?$")
+	var term256Regex = regexp.MustCompile(`(?i)-256(color)?$`)
 	if term256Regex.MatchString(termenv) {
 		return true
 	}
 
-	var termBasicRegex = regexp.MustCompile("(?i)^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux")
+	var termBasicRegex = regexp.MustCompile(`(?i)^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux`)
 
 	if termBasicRegex.MatchString(termenv) {
 		return true