v0.0.241 join string array

bfcodegen/enum-generate.go

@@ -209,36 +209,10 @@ func fmtOutput(cs string, enums []EnumDef, pkgname string) string {
 	str += "\n"
 
 	str += "import \"gogs.mikescher.com/BlackForestBytes/goext/langext\"" + "\n"
+	str += "import \"gogs.mikescher.com/BlackForestBytes/goext/enums\"" + "\n"
 	str += "\n"
 
-	str += "const ChecksumGenerator = \"" + cs + "\"" + "\n"
+	str += "const ChecksumGenerator = \"" + cs + "\" // GoExtVersion: " + goext.GoextVersion + "\n"
-	str += "\n"
-
-	str += "type Enum interface {" + "\n"
-	str += "    Valid() bool" + "\n"
-	str += "    ValuesAny() []any" + "\n"
-	str += "    ValuesMeta() []EnumMetaValue" + "\n"
-	str += "    VarName() string" + "\n"
-	str += "}" + "\n"
-	str += "" + "\n"
-
-	str += "type StringEnum interface {" + "\n"
-	str += "    Enum" + "\n"
-	str += "    String() string" + "\n"
-	str += "}" + "\n"
-	str += "" + "\n"
-
-	str += "type DescriptionEnum interface {" + "\n"
-	str += "    Enum" + "\n"
-	str += "    Description() string" + "\n"
-	str += "}" + "\n"
-	str += "\n"
-
-	str += "type EnumMetaValue struct {" + "\n"
-	str += "    VarName     string  `json:\"varName\"`" + "\n"
-	str += "    Value       any     `json:\"value\"`" + "\n"
-	str += "    Description *string `json:\"description\"`" + "\n"
-	str += "}" + "\n"
 	str += "\n"
 
 	for _, enumdef := range enums {
@@ -292,7 +266,7 @@ func fmtOutput(cs string, enums []EnumDef, pkgname string) string {
 		str += "}" + "\n"
 		str += "" + "\n"
 
-		str += "func (e " + enumdef.EnumTypeName + ") ValuesMeta() []EnumMetaValue {" + "\n"
+		str += "func (e " + enumdef.EnumTypeName + ") ValuesMeta() []enums.EnumMetaValue {" + "\n"
 		str += "    return " + enumdef.EnumTypeName + "ValuesMeta()"
 		str += "}" + "\n"
 		str += "" + "\n"
@@ -322,11 +296,11 @@ func fmtOutput(cs string, enums []EnumDef, pkgname string) string {
 		str += "}" + "\n"
 		str += "" + "\n"
 
-		str += "func (e " + enumdef.EnumTypeName + ") Meta() EnumMetaValue {" + "\n"
+		str += "func (e " + enumdef.EnumTypeName + ") Meta() enums.EnumMetaValue {" + "\n"
 		if hasDescr {
-			str += "    return EnumMetaValue{VarName: e.VarName(), Value: e, Description: langext.Ptr(e.Description())}"
+			str += "    return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: langext.Ptr(e.Description())}"
 		} else {
-			str += "    return EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil}"
+			str += "    return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil}"
 		}
 		str += "}" + "\n"
 		str += "" + "\n"
@@ -346,8 +320,8 @@ func fmtOutput(cs string, enums []EnumDef, pkgname string) string {
 		str += "}" + "\n"
 		str += "" + "\n"
 
-		str += "func " + enumdef.EnumTypeName + "ValuesMeta() []EnumMetaValue {" + "\n"
+		str += "func " + enumdef.EnumTypeName + "ValuesMeta() []enums.EnumMetaValue {" + "\n"
-		str += "    return []EnumMetaValue{" + "\n"
+		str += "    return []enums.EnumMetaValue{" + "\n"
 		for _, v := range enumdef.Values {
 			str += "        " + v.VarName + ".Meta(),\n"
 		}

cmdext/builder.go

@@ -14,6 +14,7 @@ type CommandRunner struct {
 	listener         []CommandListener
 	enforceExitCodes *[]int
 	enforceNoTimeout bool
+	enforceNoStderr  bool
 }
 
 func Runner(program string) *CommandRunner {
@@ -25,6 +26,7 @@ func Runner(program string) *CommandRunner {
 		listener:         make([]CommandListener, 0),
 		enforceExitCodes: nil,
 		enforceNoTimeout: false,
+		enforceNoStderr:  false,
 	}
 }
 
@@ -73,6 +75,11 @@ func (r *CommandRunner) FailOnTimeout() *CommandRunner {
 	return r
 }
 
+func (r *CommandRunner) FailOnStderr() *CommandRunner {
+	r.enforceNoStderr = true
+	return r
+}
+
 func (r *CommandRunner) Listen(lstr CommandListener) *CommandRunner {
 	r.listener = append(r.listener, lstr)
 	return r

cmdext/cmdrunner.go

@@ -11,6 +11,7 @@ import (
 
 var ErrExitCode = errors.New("process exited with an unexpected exitcode")
 var ErrTimeout = errors.New("process did not exit after the specified timeout")
+var ErrStderrPrint = errors.New("process did print to stderr stream")
 
 type CommandResult struct {
 	StdOut          string
@@ -53,12 +54,27 @@ func run(opt CommandRunner) (CommandResult, error) {
 		err         error
 	}
 
+	stderrFailChan := make(chan bool)
+
 	outputChan := make(chan resultObj)
 	go func() {
 		// we need to first fully read the pipes and then call Wait
 		// see https://pkg.go.dev/os/exec#Cmd.StdoutPipe
 
-		stdout, stderr, stdcombined, err := preader.Read(opt.listener)
+		listener := make([]CommandListener, 0)
+		listener = append(listener, opt.listener...)
+
+		if opt.enforceNoStderr {
+			listener = append(listener, genericCommandListener{
+				_readRawStderr: langext.Ptr(func(v []byte) {
+					if len(v) > 0 {
+						stderrFailChan <- true
+					}
+				}),
+			})
+		}
+
+		stdout, stderr, stdcombined, err := preader.Read(listener)
 		if err != nil {
 			outputChan <- resultObj{stdout, stderr, stdcombined, err}
 			_ = cmd.Process.Kill()
@@ -115,6 +131,34 @@ func run(opt CommandRunner) (CommandResult, error) {
 			return res, nil
 		}
 
+	case <-stderrFailChan:
+		_ = cmd.Process.Kill()
+		for _, lstr := range opt.listener {
+			lstr.Timeout()
+		}
+
+		if fallback, ok := syncext.ReadChannelWithTimeout(outputChan, 32*time.Millisecond); ok {
+			// most of the time the cmd.Process.Kill() should also have finished the pipereader
+			// and we can at least return the already collected stdout, stderr, etc
+			res := CommandResult{
+				StdOut:          fallback.stdout,
+				StdErr:          fallback.stderr,
+				StdCombined:     fallback.stdcombined,
+				ExitCode:        -1,
+				CommandTimedOut: false,
+			}
+			return res, ErrStderrPrint
+		} else {
+			res := CommandResult{
+				StdOut:          "",
+				StdErr:          "",
+				StdCombined:     "",
+				ExitCode:        -1,
+				CommandTimedOut: false,
+			}
+			return res, ErrStderrPrint
+		}
+
 	case outobj := <-outputChan:
 		if exiterr, ok := outobj.err.(*exec.ExitError); ok {
 			excode := exiterr.ExitCode()

cmdext/cmdrunner_test.go

@@ -1,6 +1,7 @@
 package cmdext
 
 import (
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -289,16 +290,40 @@ func TestLongStdout(t *testing.T) {
 func TestFailOnTimeout(t *testing.T) {
 
 	_, err := Runner("sleep").Arg("2").Timeout(200 * time.Millisecond).FailOnTimeout().Run()
-	if err != ErrTimeout {
+	if !errors.Is(err, ErrTimeout) {
 		t.Errorf("wrong err := %v", err)
 	}
 
 }
 
+func TestFailOnStderr(t *testing.T) {
+
+	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").FailOnStderr().Run()
+	if err == nil {
+		t.Errorf("no err")
+	}
+	if res1.CommandTimedOut {
+		t.Errorf("Timeout")
+	}
+	if res1.ExitCode != -1 {
+		t.Errorf("res1.ExitCode == %v", res1.ExitCode)
+	}
+	if res1.StdErr != "error" {
+		t.Errorf("res1.StdErr == '%v'", res1.StdErr)
+	}
+	if res1.StdOut != "" {
+		t.Errorf("res1.StdOut == '%v'", res1.StdOut)
+	}
+	if res1.StdCombined != "error\n" {
+		t.Errorf("res1.StdCombined == '%v'", res1.StdCombined)
+	}
+
+}
+
 func TestFailOnExitcode(t *testing.T) {
 
 	_, err := Runner("false").Timeout(200 * time.Millisecond).FailOnExitCode().Run()
-	if err != ErrExitCode {
+	if !errors.Is(err, ErrExitCode) {
 		t.Errorf("wrong err := %v", err)
 	}
 

enums/enum.go

@@ -0,0 +1,24 @@
+package enums
+
+type Enum interface {
+	Valid() bool
+	ValuesAny() []any
+	ValuesMeta() []EnumMetaValue
+	VarName() string
+}
+
+type StringEnum interface {
+	Enum
+	String() string
+}
+
+type DescriptionEnum interface {
+	Enum
+	Description() string
+}
+
+type EnumMetaValue struct {
+	VarName     string  `json:"varName"`
+	Value       any     `json:"value"`
+	Description *string `json:"description"`
+}

exerr/builder.go

@@ -9,6 +9,7 @@ import (
 	"github.com/rs/zerolog"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"gogs.mikescher.com/BlackForestBytes/goext/enums"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"net/http"
 	"os"
@@ -80,6 +81,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
@@ -277,6 +282,10 @@ func (b *Builder) Stringer(key string, val fmt.Stringer) *Builder {
 	}
 }
 
+func (b *Builder) Enum(key string, val enums.Enum) *Builder {
+	return b.addMeta(key, MDTEnum, newEnumWrap(val))
+}
+
 func (b *Builder) Stack() *Builder {
 	return b.addMeta("@Stack", MDTString, string(debug.Stack()))
 }
@@ -297,7 +306,7 @@ func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request)
 	}
 	b.Str("gin.method", req.Method)
 	b.Str("gin.path", g.FullPath())
-	b.Str("gin.header", formatHeader(g.Request.Header))
+	b.Strs("gin.header", extractHeader(g.Request.Header))
 	if req.URL != nil {
 		b.Str("gin.url", req.URL.String())
 	}
@@ -313,22 +322,38 @@ func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request)
 	if ctxVal := g.GetString("reqid"); ctxVal != "" {
 		b.Str("gin.context.reqid", ctxVal)
 	}
-	if req.Method != "GET" && req.Body != nil && req.Header.Get("Content-Type") == "application/json" {
+	if req.Method != "GET" && req.Body != nil {
-		if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
+
-			if bin, err := brc.BufferedAll(); err == nil {
+		if req.Header.Get("Content-Type") == "application/json" {
-				if len(bin) < 16*1024 {
+			if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
-					var prettyJSON bytes.Buffer
+				if bin, err := brc.BufferedAll(); err == nil {
-					err = json.Indent(&prettyJSON, bin, "", "  ")
+					if len(bin) < 16*1024 {
-					if err == nil {
+						var prettyJSON bytes.Buffer
-						b.Str("gin.body", string(prettyJSON.Bytes()))
+						err = json.Indent(&prettyJSON, bin, "", "  ")
+						if err == nil {
+							b.Str("gin.body", string(prettyJSON.Bytes()))
+						} else {
+							b.Bytes("gin.body", bin)
+						}
 					} else {
-						b.Bytes("gin.body", bin)
+						b.Str("gin.body", fmt.Sprintf("[[%v bytes | %s]]", len(bin), req.Header.Get("Content-Type")))
 					}
-				} else {
-					b.Str("gin.body", fmt.Sprintf("[[%v bytes]]", len(bin)))
 				}
 			}
 		}
+
+		if req.Header.Get("Content-Type") == "multipart/form-data" || req.Header.Get("Content-Type") == "x-www-form-urlencoded" {
+			if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
+				if bin, err := brc.BufferedAll(); err == nil {
+					if len(bin) < 16*1024 {
+						b.Bytes("gin.body", bin)
+					} else {
+						b.Str("gin.body", fmt.Sprintf("[[%v bytes | %s]]", len(bin), req.Header.Get("Content-Type")))
+					}
+				}
+			}
+		}
+
 	}
 
 	b.containsGinData = true
@@ -358,6 +383,20 @@ func formatHeader(header map[string][]string) string {
 	return r
 }
 
+func extractHeader(header map[string][]string) []string {
+	r := make([]string, 0, len(header))
+	for k, v := range header {
+		for _, hval := range v {
+			value := hval
+			value = strings.ReplaceAll(value, "\n", "\\n")
+			value = strings.ReplaceAll(value, "\r", "\\r")
+			value = strings.ReplaceAll(value, "\t", "\\t")
+			r = append(r, k+": "+value)
+		}
+	}
+	return r
+}
+
 // ----------------------------------------------------------------------------
 
 // Build creates a new error, ready to pass up the stack

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/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/meta.go

@@ -43,6 +43,7 @@ const (
 	MDTID          metaDataType = "ID"
 	MDTAny         metaDataType = "Interface"
 	MDTNil         metaDataType = "Nil"
+	MDTEnum        metaDataType = "Enum"
 )
 
 type MetaValue struct {
@@ -131,6 +132,8 @@ func (v MetaValue) SerializeValue() (string, error) {
 		return string(r), nil
 	case MDTNil:
 		return "", nil
+	case MDTEnum:
+		return v.Value.(EnumWrap).Serialize(), nil
 	}
 	return "", errors.New("Unknown type: " + string(v.DataType))
 }
@@ -208,6 +211,8 @@ func (v MetaValue) ShortString(lim int) string {
 		return langext.StrLimit(string(r), lim, "...")
 	case MDTNil:
 		return "<<null>>"
+	case MDTEnum:
+		return v.Value.(EnumWrap).String()
 	}
 	return "(err)"
 }
@@ -270,6 +275,14 @@ func (v MetaValue) Apply(key string, evt *zerolog.Event) *zerolog.Event {
 		return evt.Ints32(key, v.Value.([]int32))
 	case MDTNil:
 		return evt.Str(key, "<<null>>")
+	case MDTEnum:
+		if v.Value.(EnumWrap).IsNil {
+			return evt.Any(key, nil)
+		} else if v.Value.(EnumWrap).ValueRaw != nil {
+			return evt.Any(key, v.Value.(EnumWrap).ValueRaw)
+		} else {
+			return evt.Str(key, v.Value.(EnumWrap).ValueString)
+		}
 	}
 	return evt.Str(key, "(err)")
 }
@@ -511,6 +524,10 @@ func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
 		v.Value = nil
 		v.DataType = datatype
 		return nil
+	case MDTEnum:
+		v.Value = deserializeEnumWrap(value)
+		v.DataType = datatype
+		return nil
 	}
 	return errors.New("Unknown type: " + string(datatype))
 }
@@ -581,10 +598,55 @@ func (v MetaValue) ValueString() string {
 		return string(r)
 	case MDTNil:
 		return "<<null>>"
+	case MDTEnum:
+		return v.Value.(EnumWrap).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
+	}
+	if v.DataType == MDTEnum {
+		if v.Value.(EnumWrap).IsNil {
+			return nil
+		}
+		if v.Value.(EnumWrap).ValueRaw != nil {
+			return v.Value.(EnumWrap).ValueRaw
+		}
+		return v.Value.(EnumWrap).ValueString
+	}
+	return v.Value
+}
+
 func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
 	r := ""
 

exerr/typeWrapper.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/rs/zerolog/log"
+	"gogs.mikescher.com/BlackForestBytes/goext/enums"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"strings"
 )
@@ -131,3 +132,58 @@ func deserializeAnyWrap(v string) AnyWrap {
 		}
 	}
 }
+
+type EnumWrap struct {
+	Type        string
+	ValueString string
+	ValueRaw    enums.Enum // `ValueRaw` is lost during serialization roundtrip
+	IsNil       bool
+}
+
+func newEnumWrap(val enums.Enum) EnumWrap {
+	t := fmt.Sprintf("%T", val)
+	arr := strings.Split(t, ".")
+	if len(arr) > 0 {
+		t = arr[len(arr)-1]
+	}
+
+	if langext.IsNil(val) {
+		return EnumWrap{Type: t, ValueString: "", ValueRaw: val, IsNil: true}
+	}
+
+	if enumstr, ok := val.(enums.StringEnum); ok {
+		return EnumWrap{Type: t, ValueString: enumstr.String(), ValueRaw: val, IsNil: false}
+	}
+
+	return EnumWrap{Type: t, ValueString: fmt.Sprintf("%v", val), ValueRaw: val, IsNil: false}
+}
+
+func (w EnumWrap) Serialize() string {
+	if w.IsNil {
+		return "!nil" + ":" + w.Type
+	}
+	return w.Type + ":" + w.ValueString
+}
+
+func (w EnumWrap) String() string {
+	if w.IsNil {
+		return w.Type + "<<nil>>"
+	}
+	return "[" + w.Type + "] " + w.ValueString
+}
+
+func deserializeEnumWrap(v string) EnumWrap {
+	r := strings.SplitN(v, ":", 2)
+
+	if len(r) == 2 && r[0] == "!nil" {
+		return EnumWrap{Type: r[1], ValueString: v, ValueRaw: nil, IsNil: true}
+	}
+
+	if len(r) == 0 {
+		return EnumWrap{}
+	} else if len(r) == 1 {
+		return EnumWrap{Type: "", ValueString: v, ValueRaw: nil, IsNil: false}
+	} else {
+		return EnumWrap{Type: r[0], ValueString: r[1], ValueRaw: nil, IsNil: false}
+	}
+}

ginext/preContext.go

@@ -8,6 +8,7 @@ import (
 	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"runtime/debug"
+	"time"
 )
 
 type PreContext struct {
@@ -18,6 +19,7 @@ type PreContext struct {
 	body    any
 	form    any
 	header  any
+	timeout *time.Duration
 }
 
 func (pctx *PreContext) URI(uri any) *PreContext {
@@ -45,6 +47,11 @@ func (pctx *PreContext) Header(header any) *PreContext {
 	return pctx
 }
 
+func (pctx *PreContext) WithTimeout(to time.Duration) *PreContext {
+	pctx.timeout = &to
+	return pctx
+}
+
 func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	if pctx.uri != nil {
 		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
@@ -92,6 +99,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					Build()
 				return nil, nil, langext.Ptr(Error(err))
 			}
+		} else if pctx.ginCtx.ContentType() == "application/x-www-form-urlencoded" {
+			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
+				err = exerr.Wrap(err, "Failed to read urlencoded-form").
+					WithType(exerr.TypeBindFailFormData).
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+					Build()
+				return nil, nil, langext.Ptr(Error(err))
+			}
 		} else {
 			err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
 				Str("struct_type", fmt.Sprintf("%T", pctx.form)).
@@ -110,7 +125,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		}
 	}
 
-	ictx, cancel := context.WithTimeout(context.Background(), pctx.wrapper.requestTimeout)
+	ictx, cancel := context.WithTimeout(context.Background(), langext.Coalesce(pctx.timeout, pctx.wrapper.requestTimeout))
 	actx := CreateAppContext(pctx.ginCtx, ictx, cancel)
 
 	return actx, pctx.ginCtx, nil

ginext/routes.go

@@ -149,11 +149,12 @@ func (w *GinWrapper) NoRoute(handler WHandlerFunc) {
 	if w.bufferBody {
 		handlers = append(handlers, BodyBuffer)
 	}
-	handlers = append(handlers, Wrap(w, handler))
 
 	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{

go.mod

@@ -14,7 +14,7 @@ require (
 )
 
 require (
-	github.com/bytedance/sonic v1.10.0-rc3 // indirect
+	github.com/bytedance/sonic v1.10.0 // 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

@@ -4,6 +4,8 @@ github.com/bytedance/sonic v1.10.0-rc2 h1:oDfRZ+4m6AYCOC0GFeOCeYqvBmucy1isvouS2K
 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/bytedance/sonic v1.10.0 h1:qtNZduETEIWJVIyDl01BeNxur2rW9OwTQ/yBqFRkKEk=
+github.com/bytedance/sonic v1.10.0/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=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.230"
+const GoextVersion = "0.0.241"
 
-const GoextVersionTimestamp = "2023-08-08T16:09:02+0200"
+const GoextVersionTimestamp = "2023-08-14T15:54:50+0200"

langext/array.go

@@ -467,3 +467,13 @@ func ArrayToInterface[T any](t []T) []interface{} {
 	}
 	return res
 }
+
+func JoinString(arr []string, delimiter string) string {
+	str := ""
+	for i, v := range arr {
+		str += v
+		if i < len(arr)-1 {
+			str += delimiter
+		}
+	}
+}