v0.0.585

(cherry picked from commit c0443af63b)

.gitea/workflows/tests.yml

@@ -0,0 +1,55 @@
+
+# https://docs.gitea.com/next/usage/actions/quickstart
+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions
+# https://docs.github.com/en/actions/learn-github-actions/contexts#github-context
+
+name: Build Docker and Deploy
+run-name: Build & Deploy ${{ gitea.ref }} on ${{ gitea.actor }}
+
+on:
+  push:
+    branches:
+      - '*'
+      - '**'
+
+
+jobs:
+  run_tests:
+    name: Run goext test-suite  
+    runs-on: bfb-cicd-latest
+    steps:
+
+      - name: Check out code
+        uses: actions/checkout@v3
+
+      - name: Setup go
+        uses: actions/setup-go@v4
+        with:
+          go-version-file: '${{ gitea.workspace }}/go.mod'
+
+      - name: Setup packages
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: curl python3
+          version: 1.0
+
+      - name: go version
+        run: go version
+
+      - name: Run tests
+        run: cd "${{ gitea.workspace }}" && make test
+
+      - name: Send failure mail
+        if: failure()
+        uses: dawidd6/action-send-mail@v3
+        with:
+          server_address: smtp.fastmail.com
+          server_port: 465
+          secure: true
+          username: ${{secrets.MAIL_USERNAME}}
+          password: ${{secrets.MAIL_PASSWORD}}
+          subject: Pipeline on '${{ gitea.repository }}' failed
+          to: ${{ steps.commiter_info.outputs.MAIL }}
+          from: Gitea Actions <gitea_actions@blackforestbytes.de>
+          body: "Go to https://gogs.blackforestbytes.com/${{ gitea.repository }}/actions"
+

.idea/.gitignore

@@ -6,3 +6,5 @@
 # Datasource local storage ignored files
 /dataSources/
 /dataSources.local.xml
+# GitHub Copilot persisted chat sessions
+/copilot/chatSessions

.idea/golinter.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GoLinterSettings">
+    <option name="checkGoLinterExe" value="false" />
+  </component>
+</project>

.idea/sqldialects.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="SqlDialectMappings">
+    <file url="file://$PROJECT_DIR$/sq/sq_test.go" dialect="SQLite" />
+  </component>
+</project>

Makefile

@@ -5,7 +5,13 @@ run:
 test:
 	# go test ./...
 	which gotestsum || go install gotest.tools/gotestsum@latest
-	gotestsum --format "testname" -- -tags="timetzdata sqlite_fts5 sqlite_foreign_keys" "./test"
+	gotestsum --format "testname" -- -tags="timetzdata sqlite_fts5 sqlite_foreign_keys" "./..."
+
+test-in-docker:
+	tag="goext_temp_test_image:$(shell uuidgen | tr -d '-')";        \
+	docker build --tag $$tag . -f .gitea/workflows/Dockerfile_tests; \
+	docker run --rm $$tag;                                           \
+	docker rmi $$tag
 
 version:
 	_data/version.sh

README.md

@@ -5,30 +5,33 @@ A collection of general & useful library methods
 
 This should not have any heavy dependencies (gin, mongo, etc) and add missing basic language features...
 
-Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
+Potentially needs `export GOPRIVATE="git.blackforestbytes.com"`
 
 
-### Packages:
+## Packages:
 
 | Name        | Maintainer | Description                                                                                                   |
-|--------------|------------|---------------------------------------------------------------------------------------------------------------|
+|-------------|------------|---------------------------------------------------------------------------------------------------------------|
 | langext     | Mike       | General uttility/helper functions, (everything thats missing from go standard library)                        |
 | mathext     | Mike       | Utility/Helper functions for math                                                                             |
 | cryptext    | Mike       | Utility/Helper functions for encryption                                                                       |
 | syncext     | Mike       | Utility/Helper funtions for multi-threading / mutex / channels                                                |
 | dataext     | Mike       | Various useful data structures                                                                                |
 | zipext      | Mike       | Utility for zip/gzip/tar etc                                                                                  |
-| reflectext   | Mike       | Utility for golagn reflection                                                                                 |
+| reflectext  | Mike       | Utility for golang reflection                                                                                 |
+| fsext       | Mike       | Utility for filesytem access                                                                                  |
+| ctxext      | Mike       | Utility for context.Context                                                                                   |
 |             |            |                                                                                                               |
-| mongoext     | Mike       | Utility/Helper functions for mongodb                                                                          |
+| mongoext    | Mike       | Utility/Helper functions for mongodb (kinda abandoned)                                                        |
 | cursortoken | Mike       | MongoDB cursortoken implementation                                                                            |
+| pagination  | Mike       | Pagination implementation                                                                                     |
 |             |            |                                                                                                               |
 | totpext     | Mike       | Implementation of TOTP (2-Factor-Auth)                                                                        |
 | termext     | Mike       | Utilities for terminals (mostly color output)                                                                 |
 | confext     | Mike       | Parses environment configuration into structs                                                                 |
 | cmdext      | Mike       | Runner for external commands/processes                                                                        |
 |             |            |                                                                                                               |
-| sq           | Mike       | Utility functions for sql based databases                                                                     |
+| sq          | Mike       | Utility functions for sql based databases (primarily sqlite)                                                  |
 | tst         | Mike       | Utility functions for unit tests                                                                              |
 |             |            |                                                                                                               |
 | rfctime     | Mike       | Classes for time seriallization, with different marshallign method for mongo and json                         |
@@ -39,3 +42,70 @@ Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 | rext        | Mike       | Regex Wrapper, wraps regexp with a better interface                                                           |
 | wmo         | Mike       | Mongo Wrapper, wraps mongodb with a better interface                                                          |
 |             |            |                                                                                                               |
+| scn         | Mike       | SimpleCloudNotifier                                                                                           |
+|             |            |                                                                                                               |
+
+
+
+## Usage:
+
+### exerr
+
+ - see **mongoext/builder.go** for full info
+
+Short summary:
+ - An better error package with metadata, listener, api-output and error-traces
+ - Initialize with `exerr.Init()`
+ - *Never* return `err` direct, always use exerr.Wrap(err, "...") - add metadata where applicable
+ - at the end either Print(), Fatal() or Output() your error (print = stdout, fatal = panic, output = json API response)
+ - You can add listeners with exerr.RegisterListener(), and save the full errors to a db or smth
+
+### wmo
+
+ - A typed wrapper around the official mongo-go-driver
+ - Use `wmo.W[...](...)` to wrap the collections and type-ify them
+ - The new collections have all the usual methods, but types
+ - Also they have List() and Paginate() methods for paginated listings (witehr with a cursortoken or page/limit)
+ - Register additional hooks with `WithDecodeFunc`, `WithUnmarshalHook`, `WithMarshalHook`, `WithModifyingPipeline`, `WithModifyingPipelineFunc`
+ - List(), Paginate(), etc support filter interfaces
+   - Rule(s) of thumb: 
+     - filter the results in the filter interface
+     - sort the results in the sort function of the filter interface
+     - add joins ($lookup's) in the `WithModifyingPipelineFunc`/`WithModifyingPipeline`
+
+#### ginext
+
+ - A wrapper around gin-gonic/gin
+ - create the gin engine with `ginext.NewEngine`
+ - Add routes with `engine.Routes()...`
+   - `.Use(..)` adds a middleware
+   - `.Group(..)` adds a group
+   - `.Get().Handle(..)` adds a handler
+ - Handler return values (in contract to ginext) - values implement the `ginext.HTTPResponse` interface
+ - Every handler starts with something like:
+```go 
+func (handler Handler) CommunityMetricsValues(pctx ginext.PreContext) ginext.HTTPResponse {
+    type communityURI struct {
+        Version     string             `uri:"version"`
+        CommunityID models.CommunityID `uri:"cid"`
+    }
+    type body struct {
+        UserID  models.UserID  `json:"userID"`
+        EventID models.EventID `json:"eventID"`
+    }
+
+    var u uri
+    var b body
+    ctx, gctx, httpErr := pctx.URI(&u).Body(&b).Start() // can have more unmarshaller, like header, form, etc
+    if httpErr != nil {
+    	return *httpErr
+    }
+    defer ctx.Cancel()
+
+    // do stuff
+}
+```
+
+#### sq
+
+ - TODO (like mongoext for sqlite/sql databases)

TODO.md

@@ -2,12 +2,8 @@
 
  - cronext
 
- - cursortoken
+ - rfctime.HMSTimeOnly
+ - rfctime.NanoTimeOnly
 
- - typed/geenric mongo wrapper
+ - remove sqlx dependency from sq  (unmaintained, and mostly superseeded by our own stuff?)
-
+ - Move DBLogger and DBPreprocessor to sq
- - error package
-
-- rfctime.DateOnly
-- rfctime.HMSTimeOnly
-- rfctime.NanoTimeOnly

_data/version.sh

@@ -21,6 +21,11 @@ if [ "$( git rev-parse --abbrev-ref HEAD )" != "master" ]; then
   exit 1
 fi
 
+echo ""
+echo -n "Insert optional commit message: "
+read commitMessage
+echo ""
+
 git pull --ff
 
 go get -u ./...
@@ -40,6 +45,11 @@ git add --verbose .
 
 msg="v${next_ver}"
 
+if [[ "$commitMessage" != "" ]]; then
+  msg="${msg} ${commitMessage}"
+fi
+
+
 if [ $# -gt 0 ]; then
   msg="$1"
 fi

bfcodegen/csid-generate.go

@@ -0,0 +1,197 @@
+package bfcodegen
+
+import (
+	"bytes"
+	_ "embed"
+	"errors"
+	"fmt"
+	"go/format"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"text/template"
+)
+
+type CSIDDef struct {
+	File         string
+	FileRelative string
+	Name         string
+	Prefix       string
+}
+
+type CSIDGenOptions struct {
+	DebugOutput *bool
+}
+
+var rexCSIDPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
+
+var rexCSIDDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+string\s*//\s*(@csid:type)\s+\[(?P<prefix>[A-Z0-9]{3})].*$`))
+
+var rexCSIDChecksumConst = rext.W(regexp.MustCompile(`const ChecksumCharsetIDGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
+
+//go:embed csid-generate.template
+var templateCSIDGenerateText string
+
+func GenerateCharsetIDSpecs(sourceDir string, destFile string, opt CSIDGenOptions) error {
+
+	debugOutput := langext.Coalesce(opt.DebugOutput, false)
+
+	files, err := os.ReadDir(sourceDir)
+	if err != nil {
+		return err
+	}
+
+	oldChecksum := "N/A"
+	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
+		content, err := os.ReadFile(destFile)
+		if err != nil {
+			return err
+		}
+		if m, ok := rexCSIDChecksumConst.MatchFirst(string(content)); ok {
+			oldChecksum = m.GroupByName("cs").Value()
+		}
+	}
+
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
+	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
+
+	newChecksumStr := goext.GoextVersion
+	for _, f := range files {
+		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
+		if err != nil {
+			return err
+		}
+		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
+	}
+
+	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
+
+	if newChecksum != oldChecksum {
+		fmt.Printf("[CSIDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
+	} else {
+		fmt.Printf("[CSIDGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
+		return nil
+	}
+
+	allIDs := make([]CSIDDef, 0)
+
+	pkgname := ""
+
+	for _, f := range files {
+		if debugOutput {
+			fmt.Printf("========= %s =========\n\n", f.Name())
+		}
+
+		fileIDs, pn, err := processCSIDFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
+		if err != nil {
+			return err
+		}
+
+		if debugOutput {
+			fmt.Printf("\n")
+		}
+
+		allIDs = append(allIDs, fileIDs...)
+
+		if pn != "" {
+			pkgname = pn
+		}
+	}
+
+	if pkgname == "" {
+		return errors.New("no package name found in any file")
+	}
+
+	fdata, err := format.Source([]byte(fmtCSIDOutput(newChecksum, allIDs, pkgname)))
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(destFile, fdata, 0o755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func processCSIDFile(basedir string, fn string, debugOutput bool) ([]CSIDDef, string, error) {
+	file, err := os.Open(fn)
+	if err != nil {
+		return nil, "", err
+	}
+
+	defer func() { _ = file.Close() }()
+
+	bin, err := io.ReadAll(file)
+	if err != nil {
+		return nil, "", err
+	}
+
+	lines := strings.Split(string(bin), "\n")
+
+	ids := make([]CSIDDef, 0)
+
+	pkgname := ""
+
+	for i, line := range lines {
+		if i == 0 && strings.HasPrefix(line, "// Code generated by") {
+			break
+		}
+
+		if match, ok := rexCSIDPackage.MatchFirst(line); i == 0 && ok {
+			pkgname = match.GroupByName("name").Value()
+			continue
+		}
+
+		if match, ok := rexCSIDDef.MatchFirst(line); ok {
+
+			rfp, err := filepath.Rel(basedir, fn)
+			if err != nil {
+				return nil, "", err
+			}
+
+			def := CSIDDef{
+				File:         fn,
+				FileRelative: rfp,
+				Name:         match.GroupByName("name").Value(),
+				Prefix:       match.GroupByName("prefix").Value(),
+			}
+
+			if debugOutput {
+				fmt.Printf("Found ID definition { '%s' }\n", def.Name)
+			}
+
+			ids = append(ids, def)
+		}
+	}
+
+	return ids, pkgname, nil
+}
+
+func fmtCSIDOutput(cs string, ids []CSIDDef, pkgname string) string {
+	templ := template.Must(template.New("csid-generate").Parse(templateCSIDGenerateText))
+
+	buffer := bytes.Buffer{}
+
+	err := templ.Execute(&buffer, langext.H{
+		"PkgName":      pkgname,
+		"Checksum":     cs,
+		"GoextVersion": goext.GoextVersion,
+		"IDs":          ids,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	return buffer.String()
+}

bfcodegen/csid-generate.template

@@ -0,0 +1,194 @@
+// Code generated by csid-generate.go DO NOT EDIT.
+
+package {{.PkgName}}
+
+import "crypto/rand"
+import "crypto/sha256"
+import "fmt"
+import "github.com/go-playground/validator/v10"
+import "github.com/rs/zerolog/log"
+import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/rext"
+import "math/big"
+import "reflect"
+import "regexp"
+import "strings"
+
+const ChecksumCharsetIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
+
+const idlen = 24
+
+const checklen = 1
+
+const idCharset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+const idCharsetLen = len(idCharset)
+
+var charSetReverseMap = generateCharsetMap()
+
+const ({{range .IDs}}
+	prefix{{.Name}} = "{{.Prefix}}" {{end}}
+)
+
+var ({{range .IDs}}
+	regex{{.Name}} = generateRegex(prefix{{.Name}}) {{end}}
+)
+
+func generateRegex(prefix string) rext.Regex {
+	return rext.W(regexp.MustCompile(fmt.Sprintf("^%s[%s]{%d}[%s]{%d}$", prefix, idCharset, idlen-len(prefix)-checklen, idCharset, checklen)))
+}
+
+func generateCharsetMap() []int {
+	result := make([]int, 128)
+	for i := 0; i < len(result); i++ {
+		result[i] = -1
+	}
+	for idx, chr := range idCharset {
+		result[int(chr)] = idx
+	}
+	return result
+}
+
+func generateID(prefix string) string {
+	k := ""
+	csMax := big.NewInt(int64(idCharsetLen))
+	checksum := 0
+	for i := 0; i < idlen-len(prefix)-checklen; i++ {
+		v, err := rand.Int(rand.Reader, csMax)
+		if err != nil {
+			panic(err)
+		}
+		v64 := v.Int64()
+		k += string(idCharset[v64])
+		checksum = (checksum + int(v64)) % (idCharsetLen)
+	}
+	checkstr := string(idCharset[checksum%idCharsetLen])
+	return prefix + k + checkstr
+}
+
+func generateIDFromSeed(prefix string, seed string) string {
+	h := sha256.New()
+
+	iddata := ""
+	for len(iddata) < idlen-len(prefix)-checklen {
+		h.Write([]byte(seed))
+		bs := h.Sum(nil)
+		iddata += langext.NewAnyBaseConverter(idCharset).Encode(bs)
+	}
+
+	checksum := 0
+	for i := 0; i < idlen-len(prefix)-checklen; i++ {
+		ichr := int(iddata[i])
+		checksum = (checksum + charSetReverseMap[ichr]) % (idCharsetLen)
+	}
+
+	checkstr := string(idCharset[checksum%idCharsetLen])
+
+	return prefix + iddata[:(idlen-len(prefix)-checklen)] + checkstr
+}
+
+func validateID(prefix string, value string) error {
+	if len(value) != idlen {
+		return exerr.New(exerr.TypeInvalidCSID, "id has the wrong length").Str("value", value).Build()
+	}
+
+	if !strings.HasPrefix(value, prefix) {
+		return exerr.New(exerr.TypeInvalidCSID, "id is missing the correct prefix").Str("value", value).Str("prefix", prefix).Build()
+	}
+
+	checksum := 0
+	for i := len(prefix); i < len(value)-checklen; i++ {
+		ichr := int(value[i])
+		if ichr < 0 || ichr >= len(charSetReverseMap) || charSetReverseMap[ichr] == -1 {
+			return exerr.New(exerr.TypeInvalidCSID, "id contains invalid characters").Str("value", value).Build()
+		}
+		checksum = (checksum + charSetReverseMap[ichr]) % (idCharsetLen)
+	}
+
+	checkstr := string(idCharset[checksum%idCharsetLen])
+
+	if !strings.HasSuffix(value, checkstr) {
+		return exerr.New(exerr.TypeInvalidCSID, "id checkstring is invalid").Str("value", value).Str("checkstr", checkstr).Build()
+	}
+
+	return nil
+}
+
+func getRawData(prefix string, value string) string {
+	if len(value) != idlen {
+		return ""
+	}
+	return value[len(prefix) : idlen-checklen]
+}
+
+func getCheckString(prefix string, value string) string {
+	if len(value) != idlen {
+		return ""
+	}
+	return value[idlen-checklen:]
+}
+
+func ValidateEntityID(vfl validator.FieldLevel) bool {
+	if !vfl.Field().CanInterface() {
+		log.Error().Msgf("Failed to validate EntityID (cannot interface ?!?)")
+		return false
+	}
+
+	ifvalue := vfl.Field().Interface()
+
+	if value1, ok := ifvalue.(EntityID); ok {
+
+		if vfl.Field().Type().Kind() == reflect.Pointer && langext.IsNil(value1) {
+			return true
+		}
+
+		if err := value1.Valid(); err != nil {
+			log.Debug().Msgf("Failed to validate EntityID '%s' (%s)", value1.String(), err.Error())
+			return false
+		} else {
+			return true
+		}
+
+	} else {
+		log.Error().Msgf("Failed to validate EntityID (wrong type: %T)", ifvalue)
+		return false
+	}
+}
+
+{{range .IDs}}
+
+// ================================ {{.Name}} ({{.FileRelative}}) ================================
+
+func New{{.Name}}() {{.Name}} {
+	return {{.Name}}(generateID(prefix{{.Name}}))
+}
+
+func (id {{.Name}}) Valid() error {
+	return validateID(prefix{{.Name}}, string(id))
+}
+
+func (i {{.Name}}) String() string {
+	return string(i)
+}
+
+func (i {{.Name}}) Prefix() string {
+	return prefix{{.Name}}
+}
+
+func (id {{.Name}}) Raw() string {
+	return getRawData(prefix{{.Name}}, string(id))
+}
+
+func (id {{.Name}}) CheckString() string {
+	return getCheckString(prefix{{.Name}}, string(id))
+}
+
+func (id {{.Name}}) IsZero() bool {
+	return id == ""
+}
+
+func (id {{.Name}}) Regex() rext.Regex {
+	return regex{{.Name}}
+}
+
+{{end}}

bfcodegen/csid-generate_test.go

@@ -0,0 +1,52 @@
+package bfcodegen
+
+import (
+	_ "embed"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+//go:embed _test_example_1.tgz
+var CSIDExampleModels1 []byte
+
+func TestGenerateCSIDSpecs(t *testing.T) {
+
+	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
+
+	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
+
+	err := os.WriteFile(tmpFile, CSIDExampleModels1, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.Remove(tmpFile) })
+
+	err = os.Mkdir(tmpDir, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
+
+	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
+	tst.AssertNoErr(t, err)
+
+	err = GenerateCharsetIDSpecs(tmpDir, tmpDir+"/csid_gen.go", CSIDGenOptions{DebugOutput: langext.PTrue})
+	tst.AssertNoErr(t, err)
+
+	err = GenerateCharsetIDSpecs(tmpDir, tmpDir+"/csid_gen.go", CSIDGenOptions{DebugOutput: langext.PTrue})
+	tst.AssertNoErr(t, err)
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+	fmt.Println("=====================================================================================================")
+	fmt.Println(string(tst.Must(os.ReadFile(tmpDir + "/csid_gen.go"))(t)))
+	fmt.Println("=====================================================================================================")
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+}

bfcodegen/enum-generate.go

@@ -1,26 +1,32 @@
 package bfcodegen
 
 import (
+	"bytes"
+	_ "embed"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
-	"gogs.mikescher.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
+	"go/format"
 	"io"
 	"os"
 	"path"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
-	"time"
+	"text/template"
 )
 
 type EnumDefVal struct {
 	VarName     string
 	Value       string
 	Description *string
+	Data        *map[string]any
+	RawComment  *string
 }
 
 type EnumDef struct {
@@ -31,20 +37,23 @@ type EnumDef struct {
 	Values       []EnumDefVal
 }
 
-var rexPackage = rext.W(regexp.MustCompile("^package\\s+(?P<name>[A-Za-z0-9_]+)\\s*$"))
+type EnumGenOptions struct {
+	DebugOutput *bool
+	GoFormat    *bool
+}
 
-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 rexEnumPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
 
-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 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 rexChecksumConst = rext.W(regexp.MustCompile("const ChecksumGenerator = \"(?P<cs>[A-Za-z0-9_]*)\""))
+var rexEnumValueDef = 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_:\s\-.]*"|[0-9]+))\s*(//(?P<comm>.*))?.*$`))
 
-func GenerateEnumSpecs(sourceDir string, destFile string) error {
+var rexEnumChecksumConst = rext.W(regexp.MustCompile(`const ChecksumEnumGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
 
-	files, err := os.ReadDir(sourceDir)
+//go:embed enum-generate.template
-	if err != nil {
+var templateEnumGenerateText string
-		return err
+
-	}
+func GenerateEnumSpecs(sourceDir string, destFile string, opt EnumGenOptions) error {
 
 	oldChecksum := "N/A"
 	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
@@ -52,20 +61,45 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 		if err != nil {
 			return err
 		}
-		if m, ok := rexChecksumConst.MatchFirst(string(content)); ok {
+		if m, ok := rexEnumChecksumConst.MatchFirst(string(content)); ok {
 			oldChecksum = m.GroupByName("cs").Value()
 		}
 	}
 
+	gocode, _, changed, err := _generateEnumSpecs(sourceDir, destFile, oldChecksum, langext.Coalesce(opt.GoFormat, true), langext.Coalesce(opt.DebugOutput, false))
+	if err != nil {
+		return err
+	}
+
+	if !changed {
+		return nil
+	}
+
+	err = os.WriteFile(destFile, []byte(gocode), 0o755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func _generateEnumSpecs(sourceDir string, destFile string, oldChecksum string, gofmt bool, debugOutput bool) (string, string, bool, error) {
+
+	files, err := os.ReadDir(sourceDir)
+	if err != nil {
+		return "", "", false, err
+	}
+
 	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
 	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
 	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
 
 	newChecksumStr := goext.GoextVersion
 	for _, f := range files {
 		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
 		if err != nil {
-			return err
+			return "", "", false, err
 		}
 		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
 	}
@@ -76,7 +110,7 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 		fmt.Printf("[EnumGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
 	} else {
 		fmt.Printf("[EnumGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
-		return nil
+		return "", oldChecksum, false, nil
 	}
 
 	allEnums := make([]EnumDef, 0)
@@ -84,13 +118,18 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 	pkgname := ""
 
 	for _, f := range files {
+		if debugOutput {
 			fmt.Printf("========= %s =========\n\n", f.Name())
-		fileEnums, pn, err := processFile(sourceDir, path.Join(sourceDir, f.Name()))
-		if err != nil {
-			return err
 		}
 
+		fileEnums, pn, err := processEnumFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
+		if err != nil {
+			return "", "", false, err
+		}
+
+		if debugOutput {
 			fmt.Printf("\n")
+		}
 
 		allEnums = append(allEnums, fileEnums...)
 
@@ -100,32 +139,24 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 	}
 
 	if pkgname == "" {
-		return errors.New("no package name found in any file")
+		return "", "", false, errors.New("no package name found in any file")
 	}
 
-	err = os.WriteFile(destFile, []byte(fmtOutput(newChecksum, allEnums, pkgname)), 0o755)
+	rdata := fmtEnumOutput(newChecksum, allEnums, pkgname)
+
+	if !gofmt {
+		return rdata, newChecksum, true, nil
+	}
+
+	fdata, err := format.Source([]byte(rdata))
 	if err != nil {
-		return err
+		return "", "", false, err
 	}
 
-	res, err := cmdext.RunCommand("go", []string{"fmt", destFile}, langext.Ptr(2*time.Second))
+	return string(fdata), newChecksum, true, nil
-	if err != nil {
-		return err
-	}
-
-	if res.CommandTimedOut {
-		fmt.Println(res.StdCombined)
-		return errors.New("go fmt timed out")
-	}
-	if res.ExitCode != 0 {
-		fmt.Println(res.StdCombined)
-		return errors.New("go fmt did not succeed")
-	}
-
-	return nil
 }
 
-func processFile(basedir string, fn string) ([]EnumDef, string, error) {
+func processEnumFile(basedir string, fn string, debugOutput bool) ([]EnumDef, string, error) {
 	file, err := os.Open(fn)
 	if err != nil {
 		return nil, "", err
@@ -149,7 +180,7 @@ func processFile(basedir string, fn string) ([]EnumDef, string, error) {
 			break
 		}
 
-		if match, ok := rexPackage.MatchFirst(line); i == 0 && ok {
+		if match, ok := rexEnumPackage.MatchFirst(line); i == 0 && ok {
 			pkgname = match.GroupByName("name").Value()
 			continue
 		}
@@ -169,15 +200,42 @@ func processFile(basedir string, fn string) ([]EnumDef, string, error) {
 				Values:       make([]EnumDefVal, 0),
 			}
 			enums = append(enums, def)
+
+			if debugOutput {
 				fmt.Printf("Found enum definition { '%s' -> '%s' }\n", def.EnumTypeName, def.Type)
 			}
+		}
 
-		if match, ok := rexValueDef.MatchFirst(line); ok {
+		if match, ok := rexEnumValueDef.MatchFirst(line); ok {
 			typename := match.GroupByName("type").Value()
+
+			comment := match.GroupByNameOrEmpty("comm").ValueOrNil()
+			var descr *string = nil
+			var data *map[string]any = nil
+			if comment != nil {
+				comment = langext.Ptr(strings.TrimSpace(*comment))
+				if strings.HasPrefix(*comment, "{") {
+					if v, ok := tryParseDataComment(*comment); ok {
+						data = &v
+						if anyDataDescr, ok := v["description"]; ok {
+							if dataDescr, ok := anyDataDescr.(string); ok {
+								descr = &dataDescr
+							}
+						}
+					} else {
+						descr = comment
+					}
+				} else {
+					descr = comment
+				}
+			}
+
 			def := EnumDefVal{
 				VarName:     match.GroupByName("name").Value(),
 				Value:       match.GroupByName("value").Value(),
-				Description: match.GroupByNameOrEmpty("descr").ValueOrNil(),
+				RawComment:  comment,
+				Description: descr,
+				Data:        data,
 			}
 
 			found := false
@@ -185,180 +243,131 @@ func processFile(basedir string, fn string) ([]EnumDef, string, error) {
 				if v.EnumTypeName == typename {
 					enums[i].Values = append(enums[i].Values, def)
 					found = true
+
+					if debugOutput {
 						if def.Description != nil {
 							fmt.Printf("Found enum value [%s] for '%s'  ('%s')\n", def.Value, def.VarName, *def.Description)
 						} else {
 							fmt.Printf("Found enum value [%s] for '%s'\n", def.Value, def.VarName)
 						}
+					}
 					break
 				}
 			}
 			if !found {
+				if debugOutput {
 					fmt.Printf("Found non-enum value [%s] for '%s' ( looks like enum value, but no matching @enum:type )\n", def.Value, def.VarName)
 				}
 			}
 		}
+	}
 
 	return enums, pkgname, nil
 }
 
-func fmtOutput(cs string, enums []EnumDef, pkgname string) string {
+func tryParseDataComment(s string) (map[string]any, bool) {
-	str := "// Code generated by enum-generate.go DO NOT EDIT.\n"
-	str += "\n"
-	str += "package " + pkgname + "\n"
-	str += "\n"
 
-	str += "import \"gogs.mikescher.com/BlackForestBytes/goext/langext\"" + "\n"
+	r := make(map[string]any)
-	str += "\n"
 
-	str += "const ChecksumGenerator = \"" + cs + "\"" + "\n"
+	err := json.Unmarshal([]byte(s), &r)
-	str += "\n"
+	if err != nil {
-
+		return nil, false
-	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 {
-
-		hasDescr := langext.ArrAll(enumdef.Values, func(val EnumDefVal) bool { return val.Description != nil })
-		hasStr := enumdef.Type == "string"
-
-		str += "// ================================ " + enumdef.EnumTypeName + " ================================" + "\n"
-		str += "//" + "\n"
-		str += "// File:       " + enumdef.FileRelative + "\n"
-		str += "// StringEnum: " + langext.Conditional(hasStr, "true", "false") + "\n"
-		str += "// DescrEnum:  " + langext.Conditional(hasDescr, "true", "false") + "\n"
-		str += "//" + "\n"
-		str += "" + "\n"
-
-		str += "var __" + enumdef.EnumTypeName + "Values = []" + enumdef.EnumTypeName + "{" + "\n"
-		for _, v := range enumdef.Values {
-			str += "    " + v.VarName + "," + "\n"
-		}
-		str += "}" + "\n"
-		str += "" + "\n"
-
-		if hasDescr {
-			str += "var __" + enumdef.EnumTypeName + "Descriptions = map[" + enumdef.EnumTypeName + "]string{" + "\n"
-			for _, v := range enumdef.Values {
-				str += "    " + v.VarName + ": \"" + strings.TrimSpace(*v.Description) + "\"," + "\n"
-			}
-			str += "}" + "\n"
-			str += "" + "\n"
 	}
 
-		str += "var __" + enumdef.EnumTypeName + "Varnames = map[" + enumdef.EnumTypeName + "]string{" + "\n"
+	for _, v := range r {
-		for _, v := range enumdef.Values {
+
-			str += "    " + v.VarName + ": \"" + v.VarName + "\"," + "\n"
+		rv := reflect.ValueOf(v)
+
+		if rv.Kind() == reflect.Ptr && rv.IsNil() {
+			continue
 		}
-		str += "}" + "\n"
+		if rv.Kind() == reflect.Bool {
-		str += "" + "\n"
+			continue
-
-		str += "func (e " + enumdef.EnumTypeName + ") Valid() bool {" + "\n"
-		str += "    return langext.InArray(e, __" + enumdef.EnumTypeName + "Values)" + "\n"
-		str += "}" + "\n"
-		str += "" + "\n"
-
-		str += "func (e " + enumdef.EnumTypeName + ") Values() []" + enumdef.EnumTypeName + " {" + "\n"
-		str += "    return __" + enumdef.EnumTypeName + "Values" + "\n"
-		str += "}" + "\n"
-		str += "" + "\n"
-
-		str += "func (e " + enumdef.EnumTypeName + ") ValuesAny() []any {" + "\n"
-		str += "    return langext.ArrCastToAny(__" + enumdef.EnumTypeName + "Values)" + "\n"
-		str += "}" + "\n"
-		str += "" + "\n"
-
-		str += "func (e " + enumdef.EnumTypeName + ") ValuesMeta() []EnumMetaValue {" + "\n"
-		str += "    return []EnumMetaValue{" + "\n"
-		for _, v := range enumdef.Values {
-			if hasDescr {
-				str += "        " + fmt.Sprintf("EnumMetaValue{VarName: \"%s\", Value: %s, Description: langext.Ptr(\"%s\")},", v.VarName, v.VarName, strings.TrimSpace(*v.Description)) + "\n"
-			} else {
-				str += "        " + fmt.Sprintf("EnumMetaValue{VarName: \"%s\", Value: %s, Description: nil},", v.VarName, v.VarName) + "\n"
 		}
+		if rv.Kind() == reflect.String {
+			continue
 		}
-		str += "    }" + "\n"
+		if rv.Kind() == reflect.Int64 {
-		str += "}" + "\n"
+			continue
-		str += "" + "\n"
+		}
-
+		if rv.Kind() == reflect.Float64 {
-		if hasStr {
+			continue
-			str += "func (e " + enumdef.EnumTypeName + ") String() string {" + "\n"
-			str += "    return string(e)" + "\n"
-			str += "}" + "\n"
-			str += "" + "\n"
 		}
 
-		if hasDescr {
+		return nil, false
-			str += "func (e " + enumdef.EnumTypeName + ") Description() string {" + "\n"
-			str += "    if d, ok := __" + enumdef.EnumTypeName + "Descriptions[e]; ok {" + "\n"
-			str += "        return d" + "\n"
-			str += "    }" + "\n"
-			str += "    return \"\"" + "\n"
-			str += "}" + "\n"
-			str += "" + "\n"
 	}
 
-		str += "func (e " + enumdef.EnumTypeName + ") VarName() string {" + "\n"
+	return r, true
-		str += "    if d, ok := __" + enumdef.EnumTypeName + "Varnames[e]; ok {" + "\n"
+}
-		str += "        return d" + "\n"
+
-		str += "    }" + "\n"
+func fmtEnumOutput(cs string, enums []EnumDef, pkgname string) string {
-		str += "    return \"\"" + "\n"
+
-		str += "}" + "\n"
+	templ := template.New("enum-generate")
-		str += "" + "\n"
+
-
+	templ = templ.Funcs(template.FuncMap{
-		str += "func Parse" + enumdef.EnumTypeName + "(vv string) (" + enumdef.EnumTypeName + ", bool) {" + "\n"
+		"boolToStr": func(b bool) string { return langext.Conditional(b, "true", "false") },
-		str += "    for _, ev := range __" + enumdef.EnumTypeName + "Values {" + "\n"
+		"deref":     func(v *string) string { return *v },
-		str += "        if string(ev) == vv {" + "\n"
+		"trimSpace": func(str string) string { return strings.TrimSpace(str) },
-		str += "            return ev, true" + "\n"
+		"hasStr":    func(v EnumDef) bool { return v.Type == "string" },
-		str += "        }" + "\n"
+		"hasDescr": func(v EnumDef) bool {
-		str += "    }" + "\n"
+			return langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Description != nil })
-		str += "    return \"\", false" + "\n"
+		},
-		str += "}" + "\n"
+		"hasData": func(v EnumDef) bool {
-		str += "" + "\n"
+			return len(v.Values) > 0 && langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Data != nil })
-
+		},
-		str += "func " + enumdef.EnumTypeName + "Values() []" + enumdef.EnumTypeName + " {" + "\n"
+		"gostr": func(v any) string {
-		str += "    return __" + enumdef.EnumTypeName + "Values" + "\n"
+			return fmt.Sprintf("%#+v", v)
-		str += "}" + "\n"
+		},
-		str += "" + "\n"
+		"goobj": func(name string, v any) string {
-
+			return fmt.Sprintf("%#+v", v)
-		str += "func " + enumdef.EnumTypeName + "ValuesMeta() []EnumMetaValue {" + "\n"
+		},
-		str += "    return []EnumMetaValue{" + "\n"
+		"godatakey": func(v string) string {
-		for _, v := range enumdef.Values {
+			return strings.ToUpper(v[0:1]) + v[1:]
-			if hasDescr {
+		},
-				str += "        " + fmt.Sprintf("EnumMetaValue{VarName: \"%s\", Value: %s, Description: langext.Ptr(\"%s\")},", v.VarName, v.VarName, strings.TrimSpace(*v.Description)) + "\n"
+		"godatavalue": func(v any) string {
-			} else {
+			return fmt.Sprintf("%#+v", v)
-				str += "        " + fmt.Sprintf("EnumMetaValue{VarName: \"%s\", Value: %s, Description: nil},", v.VarName, v.VarName) + "\n"
+		},
-			}
+		"godatatype": func(v any) string {
-		}
+			return fmt.Sprintf("%T", v)
-		str += "    }" + "\n"
+		},
-		str += "}" + "\n"
+		"mapindex": func(v map[string]any, k string) any {
-		str += "" + "\n"
+			return v[k]
-
+		},
-	}
+		"generalDataKeys": func(v EnumDef) map[string]string {
-
+			r0 := make(map[string]int)
-	return str
+
+			for _, eval := range v.Values {
+				for k := range *eval.Data {
+					if ctr, ok := r0[k]; ok {
+						r0[k] = ctr + 1
+					} else {
+						r0[k] = 1
+					}
+				}
+			}
+
+			r1 := langext.MapToArr(r0)
+			r2 := langext.ArrFilter(r1, func(p langext.MapEntry[string, int]) bool { return p.Value == len(v.Values) })
+			r3 := langext.ArrMap(r2, func(p langext.MapEntry[string, int]) string { return p.Key })
+			r4 := langext.ArrToKVMap(r3, func(p string) string { return p }, func(p string) string { return fmt.Sprintf("%T", (*v.Values[0].Data)[p]) })
+
+			return r4
+		},
+	})
+
+	templ = template.Must(templ.Parse(templateEnumGenerateText))
+
+	buffer := bytes.Buffer{}
+
+	err := templ.Execute(&buffer, langext.H{
+		"PkgName":      pkgname,
+		"Checksum":     cs,
+		"GoextVersion": goext.GoextVersion,
+		"Enums":        enums,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	return buffer.String()
 }

bfcodegen/enum-generate.template

@@ -0,0 +1,155 @@
+// Code generated by enum-generate.go DO NOT EDIT.
+
+package {{.PkgName}}
+
+import "git.blackforestbytes.com/BlackForestBytes/goext/langext"
+import "git.blackforestbytes.com/BlackForestBytes/goext/enums"
+
+const ChecksumEnumGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
+
+{{ $pkgname  := .PkgName }}
+
+{{range .Enums}}
+
+{{ $hasStr   := ( . | hasStr   ) }}
+{{ $hasDescr := ( . | hasDescr ) }}
+{{ $hasData  := ( . | hasData  ) }}
+
+// ================================ {{.EnumTypeName}} ================================
+//
+// File:       {{.FileRelative}}
+// StringEnum: {{$hasStr   | boolToStr}}
+// DescrEnum:  {{$hasDescr | boolToStr}}
+// DataEnum:   {{$hasData  | boolToStr}}
+//
+
+{{ $typename := .EnumTypeName }}
+{{ $enumdef  := . }}
+
+var __{{.EnumTypeName}}Values = []{{.EnumTypeName}}{ {{range .Values}}
+	{{.VarName}}, {{end}}
+}
+
+{{if $hasDescr}}
+var __{{.EnumTypeName}}Descriptions = map[{{.EnumTypeName}}]string{ {{range .Values}}
+	{{.VarName}}: {{.Description | deref | trimSpace | gostr}}, {{end}}
+}
+{{end}}
+
+{{if $hasData}}
+type {{ .EnumTypeName }}Data struct { {{ range $datakey, $datatype := ($enumdef | generalDataKeys)  }}
+    {{ $datakey | godatakey }} {{ $datatype }} `json:"{{ $datakey }}"` {{ end }}
+}
+
+var __{{.EnumTypeName}}Data = map[{{.EnumTypeName}}]{{.EnumTypeName}}Data{ {{range .Values}} {{ $enumvalue := . }}
+	{{.VarName}}: {{ $typename }}Data{ {{ range $datakey, $datatype := $enumdef | generalDataKeys  }}
+	    {{ $datakey | godatakey }}: {{ (mapindex $enumvalue.Data $datakey) | godatavalue }}, {{ end }}
+	}, {{end}}
+}
+{{end}}
+
+var __{{.EnumTypeName}}Varnames = map[{{.EnumTypeName}}]string{ {{range .Values}}
+	{{.VarName}}: "{{.VarName}}", {{end}}
+}
+
+func (e {{.EnumTypeName}}) Valid() bool {
+	return langext.InArray(e, __{{.EnumTypeName}}Values)
+}
+
+func (e {{.EnumTypeName}}) Values() []{{.EnumTypeName}} {
+	return __{{.EnumTypeName}}Values
+}
+
+func (e {{.EnumTypeName}}) ValuesAny() []any {
+	return langext.ArrCastToAny(__{{.EnumTypeName}}Values)
+}
+
+func (e {{.EnumTypeName}}) ValuesMeta() []enums.EnumMetaValue {
+	return {{.EnumTypeName}}ValuesMeta()
+}
+
+{{if $hasStr}}
+func (e {{.EnumTypeName}}) String() string {
+	return string(e)
+}
+{{end}}
+
+{{if $hasDescr}}
+func (e {{.EnumTypeName}}) Description() string {
+	if d, ok := __{{.EnumTypeName}}Descriptions[e]; ok {
+		return d
+	}
+	return ""
+}
+{{end}}
+
+{{if $hasData}}
+func (e {{.EnumTypeName}}) Data() {{.EnumTypeName}}Data {
+	if d, ok := __{{.EnumTypeName}}Data[e]; ok {
+		return d
+	}
+	return {{.EnumTypeName}}Data{}
+}
+{{end}}
+
+func (e {{.EnumTypeName}}) VarName() string {
+	if d, ok := __{{.EnumTypeName}}Varnames[e]; ok {
+		return d
+	}
+	return ""
+}
+
+func (e {{.EnumTypeName}}) TypeName() string {
+	return "{{$typename}}"
+}
+
+func (e {{.EnumTypeName}}) PackageName() string {
+	return "{{$pkgname }}"
+}
+
+func (e {{.EnumTypeName}}) Meta() enums.EnumMetaValue {
+    {{if $hasDescr}} return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: langext.Ptr(e.Description())} {{else}} return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil} {{end}}
+}
+
+{{if $hasDescr}}
+func (e {{.EnumTypeName}}) DescriptionMeta() enums.EnumDescriptionMetaValue {
+    return enums.EnumDescriptionMetaValue{VarName: e.VarName(), Value: e, Description: e.Description()}
+}
+{{end}}
+
+func Parse{{.EnumTypeName}}(vv string) ({{.EnumTypeName}}, bool) {
+	for _, ev := range __{{.EnumTypeName}}Values {
+		if string(ev) == vv {
+			return ev, true
+		}
+	}
+	return "", false
+}
+
+func {{.EnumTypeName}}Values() []{{.EnumTypeName}} {
+	return __{{.EnumTypeName}}Values
+}
+
+func {{.EnumTypeName}}ValuesMeta() []enums.EnumMetaValue {
+	return []enums.EnumMetaValue{ {{range .Values}}
+            {{.VarName}}.Meta(), {{end}}
+	}
+}
+
+{{if $hasDescr}}
+func {{.EnumTypeName}}ValuesDescriptionMeta() []enums.EnumDescriptionMetaValue {
+	return []enums.EnumDescriptionMetaValue{ {{range .Values}}
+            {{.VarName}}.DescriptionMeta(), {{end}}
+	}
+}
+{{end}}
+
+{{end}}
+
+// ================================ ================= ================================
+
+func AllPackageEnums() []enums.Enum {
+    return []enums.Enum{ {{range .Enums}}
+        {{ if gt (len .Values) 0 }} {{  $v := index .Values 0 }} {{ $v.VarName}}, {{end}} // {{ .EnumTypeName }} {{end}}
+    }
+}

bfcodegen/enum-generate_test.go

@@ -1,15 +1,91 @@
 package bfcodegen
 
 import (
+	_ "embed"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"os"
+	"path/filepath"
 	"testing"
+	"time"
 )
 
-func TestApplyEnvOverridesSimple(t *testing.T) {
+//go:embed _test_example_1.tgz
+var EnumExampleModels1 []byte
 
-	err := GenerateEnumSpecs("/home/mike/Code/reiff/badennet/bnet-backend/models", "/home/mike/Code/reiff/badennet/bnet-backend/models/enums_gen.go")
+//go:embed _test_example_2.tgz
-	if err != nil {
+var EnumExampleModels2 []byte
-		t.Error(err)
-		t.Fail()
-	}
 
+func TestGenerateEnumSpecs(t *testing.T) {
+
+	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
+
+	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
+
+	err := os.WriteFile(tmpFile, EnumExampleModels1, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.Remove(tmpFile) })
+
+	err = os.Mkdir(tmpDir, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
+
+	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
+	tst.AssertNoErr(t, err)
+
+	s1, cs1, _, err := _generateEnumSpecs(tmpDir, "", "N/A", true, true)
+	tst.AssertNoErr(t, err)
+
+	s2, cs2, _, err := _generateEnumSpecs(tmpDir, "", "N/A", true, true)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertEqual(t, cs1, cs2)
+	tst.AssertEqual(t, s1, s2)
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+	fmt.Println("=====================================================================================================")
+	fmt.Println(s1)
+	fmt.Println("=====================================================================================================")
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+}
+
+func TestGenerateEnumSpecsData(t *testing.T) {
+
+	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
+
+	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
+
+	err := os.WriteFile(tmpFile, EnumExampleModels2, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.Remove(tmpFile) })
+
+	err = os.Mkdir(tmpDir, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
+
+	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
+	tst.AssertNoErr(t, err)
+
+	s1, _, _, err := _generateEnumSpecs(tmpDir, "", "", true, true)
+	tst.AssertNoErr(t, err)
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+	fmt.Println("=====================================================================================================")
+	fmt.Println(s1)
+	fmt.Println("=====================================================================================================")
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
 }

bfcodegen/id-generate.go

@@ -0,0 +1,198 @@
+package bfcodegen
+
+import (
+	"bytes"
+	_ "embed"
+	"errors"
+	"fmt"
+	"go/format"
+	"git.blackforestbytes.com/BlackForestBytes/goext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cryptext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"text/template"
+)
+
+type IDDef struct {
+	File         string
+	FileRelative string
+	Name         string
+}
+
+type IDGenOptions struct {
+	DebugOutput *bool
+}
+
+var rexIDPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]+)\s*$`))
+
+var rexIDDef = rext.W(regexp.MustCompile(`^\s*type\s+(?P<name>[A-Za-z0-9_]+)\s+string\s*//\s*(@id:type).*$`))
+
+var rexIDChecksumConst = rext.W(regexp.MustCompile(`const ChecksumIDGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
+
+//go:embed id-generate.template
+var templateIDGenerateText string
+
+func GenerateIDSpecs(sourceDir string, destFile string, opt IDGenOptions) error {
+
+	debugOutput := langext.Coalesce(opt.DebugOutput, false)
+
+	files, err := os.ReadDir(sourceDir)
+	if err != nil {
+		return err
+	}
+
+	oldChecksum := "N/A"
+	if _, err := os.Stat(destFile); !os.IsNotExist(err) {
+		content, err := os.ReadFile(destFile)
+		if err != nil {
+			return err
+		}
+		if m, ok := rexIDChecksumConst.MatchFirst(string(content)); ok {
+			oldChecksum = m.GroupByName("cs").Value()
+		}
+	}
+
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return v.Name() != path.Base(destFile) })
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return strings.HasSuffix(v.Name(), ".go") })
+	files = langext.ArrFilter(files, func(v os.DirEntry) bool { return !strings.HasSuffix(v.Name(), "_gen.go") })
+	langext.SortBy(files, func(v os.DirEntry) string { return v.Name() })
+
+	newChecksumStr := goext.GoextVersion
+	for _, f := range files {
+		content, err := os.ReadFile(path.Join(sourceDir, f.Name()))
+		if err != nil {
+			return err
+		}
+		newChecksumStr += "\n" + f.Name() + "\t" + cryptext.BytesSha256(content)
+	}
+
+	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
+
+	if newChecksum != oldChecksum {
+		fmt.Printf("[IDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
+	} else {
+		fmt.Printf("[IDGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
+		return nil
+	}
+
+	allIDs := make([]IDDef, 0)
+
+	pkgname := ""
+
+	for _, f := range files {
+		if debugOutput {
+			fmt.Printf("========= %s =========\n\n", f.Name())
+		}
+
+		fileIDs, pn, err := processIDFile(sourceDir, path.Join(sourceDir, f.Name()), debugOutput)
+		if err != nil {
+			return err
+		}
+
+		if debugOutput {
+			fmt.Printf("\n")
+		}
+
+		allIDs = append(allIDs, fileIDs...)
+
+		if pn != "" {
+			pkgname = pn
+		}
+	}
+
+	if pkgname == "" {
+		return errors.New("no package name found in any file")
+	}
+
+	fdata, err := format.Source([]byte(fmtIDOutput(newChecksum, allIDs, pkgname)))
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(destFile, fdata, 0o755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func processIDFile(basedir string, fn string, debugOutput bool) ([]IDDef, string, error) {
+	file, err := os.Open(fn)
+	if err != nil {
+		return nil, "", err
+	}
+
+	defer func() { _ = file.Close() }()
+
+	bin, err := io.ReadAll(file)
+	if err != nil {
+		return nil, "", err
+	}
+
+	lines := strings.Split(string(bin), "\n")
+
+	ids := make([]IDDef, 0)
+
+	pkgname := ""
+
+	for i, line := range lines {
+		if i == 0 && strings.HasPrefix(line, "// Code generated by") {
+			break
+		}
+
+		if match, ok := rexIDPackage.MatchFirst(line); i == 0 && ok {
+			pkgname = match.GroupByName("name").Value()
+			continue
+		}
+
+		if match, ok := rexIDDef.MatchFirst(line); ok {
+
+			rfp, err := filepath.Rel(basedir, fn)
+			if err != nil {
+				return nil, "", err
+			}
+
+			def := IDDef{
+				File:         fn,
+				FileRelative: rfp,
+				Name:         match.GroupByName("name").Value(),
+			}
+
+			if debugOutput {
+				fmt.Printf("Found ID definition { '%s' }\n", def.Name)
+			}
+
+			ids = append(ids, def)
+		}
+	}
+
+	return ids, pkgname, nil
+}
+
+func fmtIDOutput(cs string, ids []IDDef, pkgname string) string {
+	templ := template.Must(template.New("id-generate").Parse(templateIDGenerateText))
+
+	buffer := bytes.Buffer{}
+
+	anyDef := langext.ArrFirstOrNil(ids, func(def IDDef) bool { return def.Name == "AnyID" || def.Name == "AnyId" })
+
+	err := templ.Execute(&buffer, langext.H{
+		"PkgName":      pkgname,
+		"Checksum":     cs,
+		"GoextVersion": goext.GoextVersion,
+		"IDs":          ids,
+		"AnyDef":       anyDef,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	return buffer.String()
+}

bfcodegen/id-generate.template

@@ -0,0 +1,56 @@
+// Code generated by id-generate.go DO NOT EDIT.
+
+package {{.PkgName}}
+
+import "go.mongodb.org/mongo-driver/bson"
+import "go.mongodb.org/mongo-driver/bson/bsontype"
+import "go.mongodb.org/mongo-driver/bson/primitive"
+import "git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+
+const ChecksumIDGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
+
+{{range .IDs}}
+
+// ================================ {{.Name}} ({{.FileRelative}}) ================================
+
+func (i {{.Name}}) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	if objId, err := primitive.ObjectIDFromHex(string(i)); err == nil {
+		return bson.MarshalValue(objId)
+	} else {
+		return 0, nil, exerr.New(exerr.TypeMarshalEntityID, "Failed to marshal {{.Name}}("+i.String()+") to ObjectId").Str("value", string(i)).Type("type", i).Build()
+	}
+}
+
+func (i {{.Name}}) String() string {
+	return string(i)
+}
+
+func (i {{.Name}}) ObjID() (primitive.ObjectID, error) {
+	return primitive.ObjectIDFromHex(string(i))
+}
+
+func (i {{.Name}}) Valid() bool {
+	_, err := primitive.ObjectIDFromHex(string(i))
+	return err == nil
+}
+
+{{if ne $.AnyDef nil}}
+func (i {{.Name}}) AsAny() {{$.AnyDef.Name}} {
+	return {{$.AnyDef.Name}}(i)
+}
+
+func (i {{.Name}}) AsAnyPtr() *{{$.AnyDef.Name}} {
+    v := {{$.AnyDef.Name}}(i)
+	return &v
+}
+{{end}}
+
+func (i {{.Name}}) IsZero() bool {
+	return i == ""
+}
+
+func New{{.Name}}() {{.Name}} {
+	return {{.Name}}(primitive.NewObjectID().Hex())
+}
+
+{{end}}

bfcodegen/id-generate_test.go

@@ -0,0 +1,52 @@
+package bfcodegen
+
+import (
+	_ "embed"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/cmdext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+//go:embed _test_example_1.tgz
+var IDExampleModels1 []byte
+
+func TestGenerateIDSpecs(t *testing.T) {
+
+	tmpFile := filepath.Join(t.TempDir(), langext.MustHexUUID()+".tgz")
+
+	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
+
+	err := os.WriteFile(tmpFile, IDExampleModels1, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.Remove(tmpFile) })
+
+	err = os.Mkdir(tmpDir, 0o777)
+	tst.AssertNoErr(t, err)
+
+	t.Cleanup(func() { _ = os.RemoveAll(tmpFile) })
+
+	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
+	tst.AssertNoErr(t, err)
+
+	err = GenerateIDSpecs(tmpDir, tmpDir+"/id_gen.go", IDGenOptions{DebugOutput: langext.PTrue})
+	tst.AssertNoErr(t, err)
+
+	err = GenerateIDSpecs(tmpDir, tmpDir+"/id_gen.go", IDGenOptions{DebugOutput: langext.PTrue})
+	tst.AssertNoErr(t, err)
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+	fmt.Println("=====================================================================================================")
+	fmt.Println(string(tst.Must(os.ReadFile(tmpDir + "/id_gen.go"))(t)))
+	fmt.Println("=====================================================================================================")
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+}

cmdext/builder.go

@@ -2,7 +2,7 @@ package cmdext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"time"
 )
 
@@ -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

@@ -2,15 +2,16 @@ package cmdext
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/mathext"
-	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
 	"os/exec"
 	"time"
 )
 
 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,8 +131,34 @@ func run(opt CommandRunner) (CommandResult, error) {
 			return res, nil
 		}
 
+	case <-stderrFailChan:
+		_ = cmd.Process.Kill()
+
+		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 {
+		var exiterr *exec.ExitError
+		if errors.As(outobj.err, &exiterr) {
 			excode := exiterr.ExitCode()
 			for _, lstr := range opt.listener {
 				lstr.Finished(excode)

cmdext/cmdrunner_test.go

@@ -1,6 +1,7 @@
 package cmdext
 
 import (
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -32,7 +33,7 @@ func TestStdout(t *testing.T) {
 
 func TestStderr(t *testing.T) {
 
-	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").Run()
+	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"error\", file=sys.stderr, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
@@ -55,7 +56,7 @@ func TestStderr(t *testing.T) {
 }
 
 func TestStdcombined(t *testing.T) {
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"1\", file=sys.stderr, flush=True); time.sleep(0.1); print(\"2\", file=sys.stdout, flush=True); time.sleep(0.1); print(\"3\", file=sys.stderr, flush=True)").
 		Run()
@@ -81,7 +82,7 @@ func TestStdcombined(t *testing.T) {
 }
 
 func TestPartialRead(t *testing.T) {
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", flush=True); time.sleep(5); print(\"cant see me\", flush=True);").
 		Timeout(100 * time.Millisecond).
@@ -105,7 +106,7 @@ func TestPartialRead(t *testing.T) {
 }
 
 func TestPartialReadStderr(t *testing.T) {
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", file=sys.stderr, flush=True); time.sleep(5); print(\"cant see me\", file=sys.stderr, flush=True);").
 		Timeout(100 * time.Millisecond).
@@ -130,7 +131,7 @@ func TestPartialReadStderr(t *testing.T) {
 
 func TestReadUnflushedStdout(t *testing.T) {
 
-	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stdout, end='')").Run()
+	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stdout, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
@@ -154,7 +155,7 @@ func TestReadUnflushedStdout(t *testing.T) {
 
 func TestReadUnflushedStderr(t *testing.T) {
 
-	res1, err := Runner("python").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stderr, end='')").Run()
+	res1, err := Runner("python3").Arg("-c").Arg("import sys; print(\"message101\", file=sys.stderr, end='')").Run()
 	if err != nil {
 		t.Errorf("%v", err)
 	}
@@ -179,7 +180,7 @@ func TestReadUnflushedStderr(t *testing.T) {
 func TestPartialReadUnflushed(t *testing.T) {
 	t.SkipNow()
 
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", end=''); time.sleep(5); print(\"cant see me\", end='');").
 		Timeout(100 * time.Millisecond).
@@ -205,7 +206,7 @@ func TestPartialReadUnflushed(t *testing.T) {
 func TestPartialReadUnflushedStderr(t *testing.T) {
 	t.SkipNow()
 
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"first message\", file=sys.stderr, end=''); time.sleep(5); print(\"cant see me\", file=sys.stderr, end='');").
 		Timeout(100 * time.Millisecond).
@@ -230,7 +231,7 @@ func TestPartialReadUnflushedStderr(t *testing.T) {
 
 func TestListener(t *testing.T) {
 
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys;" +
 			"import time;" +
@@ -263,7 +264,7 @@ func TestListener(t *testing.T) {
 
 func TestLongStdout(t *testing.T) {
 
-	res1, err := Runner("python").
+	res1, err := Runner("python3").
 		Arg("-c").
 		Arg("import sys; import time; print(\"X\" * 125001 + \"\\n\"); print(\"Y\" * 125001 + \"\\n\"); print(\"Z\" * 125001 + \"\\n\");").
 		Timeout(5000 * time.Millisecond).
@@ -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("python3").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)
 	}
 

cmdext/pipereader.go

@@ -2,7 +2,7 @@ package cmdext
 
 import (
 	"bufio"
-	"gogs.mikescher.com/BlackForestBytes/goext/syncext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
 	"io"
 	"sync"
 )
@@ -32,8 +32,8 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	stdout := ""
 	go func() {
 		buf := make([]byte, 128)
-		for true {
+		for {
-			n, out := pr.stdout.Read(buf)
+			n, err := pr.stdout.Read(buf)
 			if n > 0 {
 				txt := string(buf[:n])
 				stdout += txt
@@ -42,11 +42,11 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 					lstr.ReadRawStdout(buf[:n])
 				}
 			}
-			if out == io.EOF {
+			if err == io.EOF {
 				break
 			}
-			if out != nil {
+			if err != nil {
-				errch <- out
+				errch <- err
 				break
 			}
 		}
@@ -61,7 +61,7 @@ func (pr *pipeReader) Read(listener []CommandListener) (string, string, string,
 	stderr := ""
 	go func() {
 		buf := make([]byte, 128)
-		for true {
+		for {
 			n, err := pr.stderr.Read(buf)
 
 			if n > 0 {

confext/confParser.go

@@ -3,7 +3,7 @@ package confext
 import (
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
 	"math/bits"
 	"os"
 	"reflect"
@@ -41,13 +41,13 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			continue
 		}
 
-		if rvfield.Kind() == reflect.Struct {
-
 		envkey, found := rsfield.Tag.Lookup("env")
 		if !found || envkey == "-" {
 			continue
 		}
 
+		if rvfield.Kind() == reflect.Struct && rvfield.Type() != reflect.TypeOf(time.UnixMilli(0)) {
+
 			subPrefix := prefix
 			if envkey != "" {
 				subPrefix = subPrefix + envkey + delim
@@ -57,10 +57,7 @@ func processEnvOverrides(rval reflect.Value, delim string, prefix string) error
 			if err != nil {
 				return err
 			}
-		}
 
-		envkey := rsfield.Tag.Get("env")
-		if envkey == "" || envkey == "-" {
 			continue
 		}
 
@@ -178,9 +175,9 @@ func parseEnvToValue(envval string, fullEnvKey string, rvtype reflect.Type) (ref
 		if strings.TrimSpace(strings.ToLower(envval)) == "true" {
 			return reflect.ValueOf(true).Convert(rvtype), nil
 		} else if strings.TrimSpace(strings.ToLower(envval)) == "false" {
-			return reflect.ValueOf(true).Convert(rvtype), nil
-		} else if strings.TrimSpace(strings.ToLower(envval)) == "1" {
 			return reflect.ValueOf(false).Convert(rvtype), nil
+		} else if strings.TrimSpace(strings.ToLower(envval)) == "1" {
+			return reflect.ValueOf(true).Convert(rvtype), nil
 		} else if strings.TrimSpace(strings.ToLower(envval)) == "0" {
 			return reflect.ValueOf(false).Convert(rvtype), nil
 		} else {

confext/confParser_test.go

@@ -1,8 +1,8 @@
 package confext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/timeext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 	"time"
 )

cryptext/aes_test.go

@@ -2,7 +2,7 @@ package cryptext
 
 import (
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

cryptext/hash_test.go

@@ -1,7 +1,7 @@
 package cryptext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

cryptext/passHash.go

@@ -3,25 +3,27 @@ package cryptext
 import (
 	"crypto/rand"
 	"crypto/sha256"
+	"crypto/sha512"
 	"encoding/base64"
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/totpext"
 	"golang.org/x/crypto/bcrypt"
 	"strconv"
 	"strings"
 )
 
-const LatestPassHashVersion = 4
+const LatestPassHashVersion = 5
 
 // PassHash
-// - [v0]: plaintext password ( `0|...` )
+// - [v0]: plaintext password ( `0|...` )                  // simple, used to write PW's directly in DB
-// - [v1]: sha256(plaintext)
+// - [v1]: sha256(plaintext)                               // simple hashing
-// - [v2]: seed | sha256<seed>(plaintext)
+// - [v2]: seed | sha256<seed>(plaintext)                  // add seed
-// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]
+// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]    // add TOTP support
-// - [v4]: bcrypt(plaintext) | [hex(totp)]
+// - [v4]: bcrypt(plaintext) | [hex(totp)]                 // use proper bcrypt
+// - [v5]: bcrypt(sha512(plaintext)) | [hex(totp)]         // hash pw before bcrypt (otherwise max pw-len = 72)
 type PassHash string
 
 func (ph PassHash) Valid() bool {
@@ -64,7 +66,6 @@ func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bo
 		return int(version), nil, payload, false, nil, true
 	}
 
-	//
 	if version == 2 {
 		if len(split) != 3 {
 			return -1, nil, nil, false, nil, false
@@ -109,7 +110,21 @@ func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bo
 		totp := false
 		totpsecret := make([]byte, 0)
 		if split[2] != "0" {
-			totpsecret, err = hex.DecodeString(split[3])
+			totpsecret, err = hex.DecodeString(split[2])
+			totp = true
+		}
+		return int(version), nil, payload, totp, totpsecret, true
+	}
+
+	if version == 5 {
+		if len(split) != 3 {
+			return -1, nil, nil, false, nil, false
+		}
+		payload := []byte(split[1])
+		totp := false
+		totpsecret := make([]byte, 0)
+		if split[2] != "0" {
+			totpsecret, err = hex.DecodeString(split[2])
 			totp = true
 		}
 		return int(version), nil, payload, totp, totpsecret, true
@@ -156,6 +171,14 @@ func (ph PassHash) Verify(plainpass string, totp *string) bool {
 		}
 	}
 
+	if version == 5 {
+		if !hastotp {
+			return bcrypt.CompareHashAndPassword(payload, hash512(plainpass)) == nil
+		} else {
+			return bcrypt.CompareHashAndPassword(payload, hash512(plainpass)) == nil && totpext.Validate(totpsecret, *totp)
+		}
+	}
+
 	return false
 }
 
@@ -209,6 +232,12 @@ func (ph PassHash) ClearTOTP() (PassHash, error) {
 		return PassHash(strings.Join(split, "|")), nil
 	}
 
+	if version == 5 {
+		split := strings.Split(string(ph), "|")
+		split[2] = "0"
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
 	return "", errors.New("unknown version")
 }
 
@@ -242,6 +271,12 @@ func (ph PassHash) WithTOTP(totpSecret []byte) (PassHash, error) {
 		return PassHash(strings.Join(split, "|")), nil
 	}
 
+	if version == 5 {
+		split := strings.Split(string(ph), "|")
+		split[2] = hex.EncodeToString(totpSecret)
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
 	return "", errors.New("unknown version")
 }
 
@@ -271,6 +306,10 @@ func (ph PassHash) Change(newPlainPass string) (PassHash, error) {
 		return HashPasswordV4(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
 	}
 
+	if version == 5 {
+		return HashPasswordV5(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
+	}
+
 	return "", errors.New("unknown version")
 }
 
@@ -279,7 +318,24 @@ func (ph PassHash) String() string {
 }
 
 func HashPassword(plainpass string, totpSecret []byte) (PassHash, error) {
-	return HashPasswordV4(plainpass, totpSecret)
+	return HashPasswordV5(plainpass, totpSecret)
+}
+
+func HashPasswordV5(plainpass string, totpSecret []byte) (PassHash, error) {
+	var strtotp string
+
+	if totpSecret == nil {
+		strtotp = "0"
+	} else {
+		strtotp = hex.EncodeToString(totpSecret)
+	}
+
+	payload, err := bcrypt.GenerateFromPassword(hash512(plainpass), bcrypt.MinCost)
+	if err != nil {
+		return "", err
+	}
+
+	return PassHash(fmt.Sprintf("5|%s|%s", string(payload), strtotp)), nil
 }
 
 func HashPasswordV4(plainpass string, totpSecret []byte) (PassHash, error) {
@@ -340,6 +396,13 @@ func HashPasswordV0(plainpass string) (PassHash, error) {
 	return PassHash(fmt.Sprintf("0|%s", plainpass)), nil
 }
 
+func hash512(s string) []byte {
+	h := sha512.New()
+	h.Write([]byte(s))
+	bs := h.Sum(nil)
+	return bs
+}
+
 func hash256(s string) []byte {
 	h := sha256.New()
 	h.Write([]byte(s))

cryptext/passHash_test.go

@@ -0,0 +1,210 @@
+package cryptext
+
+import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/totpext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"testing"
+)
+
+func TestPassHash1(t *testing.T) {
+	ph, err := HashPassword("test123", nil)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+}
+
+func TestPassHashTOTP(t *testing.T) {
+	sec, err := totpext.GenerateSecret()
+	tst.AssertNoErr(t, err)
+
+	ph, err := HashPassword("test123", sec)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertTrue(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertFalse(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+}
+
+func TestPassHashUpgrade_V0(t *testing.T) {
+	ph, err := HashPasswordV0("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+}
+
+func TestPassHashUpgrade_V1(t *testing.T) {
+	ph, err := HashPasswordV1("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+}
+
+func TestPassHashUpgrade_V2(t *testing.T) {
+	ph, err := HashPasswordV2("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+}
+
+func TestPassHashUpgrade_V3(t *testing.T) {
+	ph, err := HashPasswordV3("test123", nil)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+}
+
+func TestPassHashUpgrade_V3_TOTP(t *testing.T) {
+	sec, err := totpext.GenerateSecret()
+	tst.AssertNoErr(t, err)
+
+	ph, err := HashPasswordV3("test123", sec)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertTrue(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertFalse(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertTrue(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertFalse(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+}
+
+func TestPassHashUpgrade_V4(t *testing.T) {
+	ph, err := HashPasswordV4("test123", nil)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertFalse(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertTrue(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+}
+
+func TestPassHashUpgrade_V4_TOTP(t *testing.T) {
+	sec, err := totpext.GenerateSecret()
+	tst.AssertNoErr(t, err)
+
+	ph, err := HashPasswordV4("test123", sec)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertTrue(t, ph.HasTOTP())
+	tst.AssertTrue(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertFalse(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+
+	ph, err = ph.Upgrade("test123")
+	tst.AssertNoErr(t, err)
+
+	tst.AssertTrue(t, ph.Valid())
+	tst.AssertTrue(t, ph.HasTOTP())
+	tst.AssertFalse(t, ph.NeedsPasswordUpgrade())
+
+	tst.AssertFalse(t, ph.Verify("test123", nil))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+	tst.AssertTrue(t, ph.Verify("test123", langext.Ptr(totpext.TOTP(sec))))
+	tst.AssertFalse(t, ph.Verify("test124", nil))
+}

cryptext/pronouncablePassword.go

@@ -0,0 +1,263 @@
+package cryptext
+
+import (
+	"crypto/rand"
+	"io"
+	"math/big"
+	mathrand "math/rand"
+	"strings"
+)
+
+const (
+	ppStartChar            = "BCDFGHJKLMNPQRSTVWXZ"
+	ppEndChar              = "ABDEFIKMNORSTUXYZ"
+	ppVowel                = "AEIOUY"
+	ppConsonant            = "BCDFGHJKLMNPQRSTVWXZ"
+	ppSegmentLenMin        = 3
+	ppSegmentLenMax        = 7
+	ppMaxRepeatedVowel     = 2
+	ppMaxRepeatedConsonant = 2
+)
+
+var ppContinuation = map[uint8]string{
+	'A': "BCDFGHJKLMNPRSTVWXYZ",
+	'B': "ADFIKLMNORSTUY",
+	'C': "AEIKOUY",
+	'D': "AEILORSUYZ",
+	'E': "BCDFGHJKLMNPRSTVWXYZ",
+	'F': "ADEGIKLOPRTUY",
+	'G': "ABDEFHILMNORSTUY",
+	'H': "AEIOUY",
+	'I': "BCDFGHJKLMNPRSTVWXZ",
+	'J': "AEIOUY",
+	'K': "ADEFHILMNORSTUY",
+	'L': "ADEFGIJKMNOPSTUVWYZ",
+	'M': "ABEFIKOPSTUY",
+	'N': "ABEFIKOPSTUY",
+	'O': "BCDFGHJKLMNPRSTVWXYZ",
+	'P': "AEFIJLORSTUY",
+	'Q': "AEIOUY",
+	'R': "ADEFGHIJKLMNOPSTUVYZ",
+	'S': "ACDEIKLOPTUYZ",
+	'T': "AEHIJOPRSUWY",
+	'U': "BCDFGHJKLMNPRSTVWXZ",
+	'V': "AEIOUY",
+	'W': "AEIOUY",
+	'X': "AEIOUY",
+	'Y': "ABCDFGHKLMNPRSTVXZ",
+	'Z': "AEILOTUY",
+}
+
+var ppLog2Map = map[int]float64{
+	1:  0.00000000,
+	2:  1.00000000,
+	3:  1.58496250,
+	4:  2.00000000,
+	5:  2.32192809,
+	6:  2.58496250,
+	7:  2.80735492,
+	8:  3.00000000,
+	9:  3.16992500,
+	10: 3.32192809,
+	11: 3.45943162,
+	12: 3.58496250,
+	13: 3.70043972,
+	14: 3.80735492,
+	15: 3.90689060,
+	16: 4.00000000,
+	17: 4.08746284,
+	18: 4.16992500,
+	19: 4.24792751,
+	20: 4.32192809,
+	21: 4.39231742,
+	22: 4.45943162,
+	23: 4.52356196,
+	24: 4.58496250,
+	25: 4.64385619,
+	26: 4.70043972,
+	27: 4.75488750,
+	28: 4.80735492,
+	29: 4.85798100,
+	30: 4.90689060,
+	31: 4.95419631,
+	32: 5.00000000,
+}
+
+var (
+	ppVowelMap     = ppMakeSet(ppVowel)
+	ppConsonantMap = ppMakeSet(ppConsonant)
+	ppEndCharMap   = ppMakeSet(ppEndChar)
+)
+
+func ppMakeSet(v string) map[uint8]bool {
+	mp := make(map[uint8]bool, len(v))
+	for _, chr := range v {
+		mp[uint8(chr)] = true
+	}
+	return mp
+}
+
+func ppRandInt(rng io.Reader, max int) int {
+	v, err := rand.Int(rng, big.NewInt(int64(max)))
+	if err != nil {
+		panic(err)
+	}
+	return int(v.Int64())
+}
+
+func ppRand(rng io.Reader, chars string, entropy *float64) uint8 {
+	chr := chars[ppRandInt(rng, len(chars))]
+
+	*entropy = *entropy + ppLog2Map[len(chars)]
+
+	return chr
+}
+
+func ppCharType(chr uint8) (bool, bool) {
+	_, ok1 := ppVowelMap[chr]
+	_, ok2 := ppConsonantMap[chr]
+
+	return ok1, ok2
+}
+
+func ppCharsetRemove(cs string, set map[uint8]bool, allowEmpty bool) string {
+	result := ""
+	for _, chr := range cs {
+		if _, ok := set[uint8(chr)]; !ok {
+			result += string(chr)
+		}
+	}
+	if result == "" && !allowEmpty {
+		return cs
+	}
+	return result
+}
+
+func ppCharsetFilter(cs string, set map[uint8]bool, allowEmpty bool) string {
+	result := ""
+	for _, chr := range cs {
+		if _, ok := set[uint8(chr)]; ok {
+			result += string(chr)
+		}
+	}
+	if result == "" && !allowEmpty {
+		return cs
+	}
+	return result
+}
+
+func PronouncablePasswordExt(rng io.Reader, pwlen int) (string, float64) {
+
+	// kinda pseudo markov-chain - with a few extra rules and no weights...
+
+	if pwlen <= 0 {
+		return "", 0
+	}
+
+	vowelCount := 0
+	consoCount := 0
+	entropy := float64(0)
+
+	startChar := ppRand(rng, ppStartChar, &entropy)
+
+	result := string(startChar)
+	currentChar := startChar
+
+	isVowel, isConsonant := ppCharType(currentChar)
+	if isVowel {
+		vowelCount = 1
+	}
+	if isConsonant {
+		consoCount = ppMaxRepeatedConsonant
+	}
+
+	segmentLen := 1
+
+	segmentLenTarget := ppSegmentLenMin + ppRandInt(rng, ppSegmentLenMax-ppSegmentLenMin)
+
+	for len(result) < pwlen {
+
+		charset := ppContinuation[currentChar]
+		if vowelCount >= ppMaxRepeatedVowel {
+			charset = ppCharsetRemove(charset, ppVowelMap, false)
+		}
+		if consoCount >= ppMaxRepeatedConsonant {
+			charset = ppCharsetRemove(charset, ppConsonantMap, false)
+		}
+
+		lastOfSegment := false
+		newSegment := false
+
+		if len(result)+1 == pwlen {
+			// last of result
+			charset = ppCharsetFilter(charset, ppEndCharMap, false)
+		} else if segmentLen+1 == segmentLenTarget {
+			// last of segment
+			charsetNew := ppCharsetFilter(charset, ppEndCharMap, true)
+			if charsetNew != "" {
+				charset = charsetNew
+				lastOfSegment = true
+			}
+		} else if segmentLen >= segmentLenTarget {
+			// (perhaps) start of new segment
+			if _, ok := ppEndCharMap[currentChar]; ok {
+				charset = ppStartChar
+				newSegment = true
+			} else {
+				// continue segment for one more char to (hopefully) find an end-char
+				charsetNew := ppCharsetFilter(charset, ppEndCharMap, true)
+				if charsetNew != "" {
+					charset = charsetNew
+					lastOfSegment = true
+				}
+			}
+		} else {
+			// normal continuation
+		}
+
+		newChar := ppRand(rng, charset, &entropy)
+		if lastOfSegment {
+			currentChar = newChar
+			segmentLen++
+			result += strings.ToLower(string(newChar))
+		} else if newSegment {
+			currentChar = newChar
+			segmentLen = 1
+			result += strings.ToUpper(string(newChar))
+			segmentLenTarget = ppSegmentLenMin + ppRandInt(rng, ppSegmentLenMax-ppSegmentLenMin)
+			vowelCount = 0
+			consoCount = 0
+		} else {
+			currentChar = newChar
+			segmentLen++
+			result += strings.ToLower(string(newChar))
+		}
+
+		isVowel, isConsonant := ppCharType(currentChar)
+		if isVowel {
+			vowelCount++
+			consoCount = 0
+		}
+		if isConsonant {
+			vowelCount = 0
+			if newSegment {
+				consoCount = ppMaxRepeatedConsonant
+			} else {
+				consoCount++
+			}
+		}
+	}
+
+	return result, entropy
+}
+
+func PronouncablePassword(len int) string {
+	v, _ := PronouncablePasswordExt(rand.Reader, len)
+	return v
+}
+
+func PronouncablePasswordSeeded(seed int64, len int) string {
+
+	v, _ := PronouncablePasswordExt(mathrand.New(mathrand.NewSource(seed)), len)
+	return v
+}

cryptext/pronouncablePassword_test.go

@@ -0,0 +1,35 @@
+package cryptext
+
+import (
+	"fmt"
+	"math/rand"
+	"testing"
+)
+
+func TestPronouncablePasswordExt(t *testing.T) {
+	for i := 0; i < 20; i++ {
+		pw, entropy := PronouncablePasswordExt(rand.New(rand.NewSource(int64(i))), 16)
+		fmt.Printf("[%.2f] => %s\n", entropy, pw)
+	}
+}
+
+func TestPronouncablePasswordSeeded(t *testing.T) {
+	for i := 0; i < 20; i++ {
+		pw := PronouncablePasswordSeeded(int64(i), 8)
+		fmt.Printf("%s\n", pw)
+	}
+}
+
+func TestPronouncablePassword(t *testing.T) {
+	for i := 0; i < 20; i++ {
+		pw := PronouncablePassword(i + 1)
+		fmt.Printf("%s\n", pw)
+	}
+}
+
+func TestPronouncablePasswordWrongLen(t *testing.T) {
+	PronouncablePassword(0)
+	PronouncablePassword(-1)
+	PronouncablePassword(-2)
+	PronouncablePassword(-3)
+}

ctxext/getter.go

@@ -0,0 +1,27 @@
+package ctxext
+
+import "context"
+
+func Value[T any](ctx context.Context, key any) (T, bool) {
+	v := ctx.Value(key)
+	if v == nil {
+		return *new(T), false
+	}
+	if tv, ok := v.(T); !ok {
+		return *new(T), false
+	} else {
+		return tv, true
+	}
+}
+
+func ValueOrDefault[T any](ctx context.Context, key any, def T) T {
+	v := ctx.Value(key)
+	if v == nil {
+		return def
+	}
+	if tv, ok := v.(T); !ok {
+		return def
+	} else {
+		return tv
+	}
+}

cursortoken/direction.go

@@ -6,3 +6,13 @@ const (
 	SortASC  SortDirection = "ASC"
 	SortDESC SortDirection = "DESC"
 )
+
+func (sd SortDirection) ToMongo() int {
+	if sd == SortASC {
+		return 1
+	} else if sd == SortDESC {
+		return -1
+	} else {
+		return 0
+	}
+}

cursortoken/filter.go

@@ -1,10 +1,15 @@
 package cursortoken
 
 import (
+	"context"
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
-type Filter interface {
+type RawFilter interface {
-	FilterQuery() mongo.Pipeline
+	FilterQuery(ctx context.Context) mongo.Pipeline
-	Pagination() (string, SortDirection, string, SortDirection)
+}
+
+type Filter interface {
+	FilterQuery(ctx context.Context) mongo.Pipeline
+	Pagination(ctx context.Context) (string, SortDirection, string, SortDirection)
 }

cursortoken/token.go

@@ -3,12 +3,18 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"errors"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
-	"go.mongodb.org/mongo-driver/bson/primitive"
+	"strconv"
 	"strings"
 	"time"
 )
 
+type CursorToken interface {
+	Token() string
+	IsStart() bool
+	IsEnd() bool
+}
+
 type Mode string
 
 const (
@@ -24,97 +30,6 @@ type Extra struct {
 	PageSize  *int
 }
 
-type CursorToken struct {
-	Mode               Mode
-	ValuePrimary       string
-	ValueSecondary     string
-	Direction          SortDirection
-	DirectionSecondary SortDirection
-	PageSize           int
-	Extra              Extra
-}
-
-type cursorTokenSerialize struct {
-	ValuePrimary       *string        `json:"v1,omitempty"`
-	ValueSecondary     *string        `json:"v2,omitempty"`
-	Direction          *SortDirection `json:"dir,omitempty"`
-	DirectionSecondary *SortDirection `json:"dir2,omitempty"`
-	PageSize           *int           `json:"size,omitempty"`
-
-	ExtraTimestamp *time.Time `json:"ts,omitempty"`
-	ExtraId        *string    `json:"id,omitempty"`
-	ExtraPage      *int       `json:"pg,omitempty"`
-	ExtraPageSize  *int       `json:"sz,omitempty"`
-}
-
-func Start() CursorToken {
-	return CursorToken{
-		Mode:               CTMStart,
-		ValuePrimary:       "",
-		ValueSecondary:     "",
-		Direction:          "",
-		DirectionSecondary: "",
-		PageSize:           0,
-		Extra:              Extra{},
-	}
-}
-
-func End() CursorToken {
-	return CursorToken{
-		Mode:               CTMEnd,
-		ValuePrimary:       "",
-		ValueSecondary:     "",
-		Direction:          "",
-		DirectionSecondary: "",
-		PageSize:           0,
-		Extra:              Extra{},
-	}
-}
-
-func (c *CursorToken) Token() string {
-	if c.Mode == CTMStart {
-		return "@start"
-	}
-	if c.Mode == CTMEnd {
-		return "@end"
-	}
-
-	// We kinda manually implement omitempty for the CursorToken here
-	// because omitempty does not work for time.Time and otherwise we would always
-	// get weird time values when decoding a token that initially didn't have an Timestamp set
-	// For this usecase we treat Unix=0 as an empty timestamp
-
-	sertok := cursorTokenSerialize{}
-
-	if c.ValuePrimary != "" {
-		sertok.ValuePrimary = &c.ValuePrimary
-	}
-	if c.ValueSecondary != "" {
-		sertok.ValueSecondary = &c.ValueSecondary
-	}
-	if c.Direction != "" {
-		sertok.Direction = &c.Direction
-	}
-	if c.DirectionSecondary != "" {
-		sertok.DirectionSecondary = &c.DirectionSecondary
-	}
-	if c.PageSize != 0 {
-		sertok.PageSize = &c.PageSize
-	}
-
-	sertok.ExtraTimestamp = c.Extra.Timestamp
-	sertok.ExtraId = c.Extra.Id
-	sertok.ExtraPage = c.Extra.Page
-	sertok.ExtraPageSize = c.Extra.PageSize
-
-	body, err := json.Marshal(sertok)
-	if err != nil {
-		panic(err)
-	}
-
-	return "tok_" + base32.StdEncoding.EncodeToString(body)
-}
-
 func Decode(tok string) (CursorToken, error) {
 	if tok == "" {
 		return Start(), nil
@@ -125,23 +40,31 @@ func Decode(tok string) (CursorToken, error) {
 	if strings.ToLower(tok) == "@end" {
 		return End(), nil
 	}
-
+	if strings.ToLower(tok) == "$end" {
-	if !strings.HasPrefix(tok, "tok_") {
+		return PageEnd(), nil
-		return CursorToken{}, errors.New("could not decode token, missing prefix")
 	}
+	if strings.HasPrefix(tok, "$") && len(tok) > 1 {
+		n, err := strconv.ParseInt(tok[1:], 10, 64)
+		if err != nil {
+			return nil, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).WithType(exerr.TypeCursorTokenDecode).Build()
+		}
+		return Page(int(n)), nil
+	}
+
+	if strings.HasPrefix(tok, "tok_") {
 
 		body, err := base32.StdEncoding.DecodeString(tok[len("tok_"):])
 		if err != nil {
-		return CursorToken{}, err
+			return nil, err
 		}
 
-	var tokenDeserialize cursorTokenSerialize
+		var tokenDeserialize cursorTokenKeySortSerialize
 		err = json.Unmarshal(body, &tokenDeserialize)
 		if err != nil {
-		return CursorToken{}, err
+			return nil, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).WithType(exerr.TypeCursorTokenDecode).Build()
 		}
 
-	token := CursorToken{Mode: CTMNormal}
+		token := CTKeySort{Mode: CTMNormal}
 
 		if tokenDeserialize.ValuePrimary != nil {
 			token.ValuePrimary = *tokenDeserialize.ValuePrimary
@@ -165,20 +88,8 @@ func Decode(tok string) (CursorToken, error) {
 		token.Extra.PageSize = tokenDeserialize.ExtraPageSize
 
 		return token, nil
-}
 
-func (c *CursorToken) ValuePrimaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValuePrimary); err == nil {
-		return oid, true
 	} else {
-		return primitive.ObjectID{}, false
+		return nil, exerr.New(exerr.TypeCursorTokenDecode, "could not decode token, missing/unknown prefix").Str("token", tok).Build()
-	}
-}
-
-func (c *CursorToken) ValueSecondaryObjectId() (primitive.ObjectID, bool) {
-	if oid, err := primitive.ObjectIDFromHex(c.ValueSecondary); err == nil {
-		return oid, true
-	} else {
-		return primitive.ObjectID{}, false
 	}
 }

cursortoken/tokenKeySort.go

@@ -0,0 +1,136 @@
+package cursortoken
+
+import (
+	"encoding/base32"
+	"encoding/json"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"time"
+)
+
+type CTKeySort struct {
+	Mode               Mode
+	ValuePrimary       string
+	ValueSecondary     string
+	Direction          SortDirection
+	DirectionSecondary SortDirection
+	PageSize           int
+	Extra              Extra
+}
+
+type cursorTokenKeySortSerialize struct {
+	ValuePrimary       *string        `json:"v1,omitempty"`
+	ValueSecondary     *string        `json:"v2,omitempty"`
+	Direction          *SortDirection `json:"dir,omitempty"`
+	DirectionSecondary *SortDirection `json:"dir2,omitempty"`
+	PageSize           *int           `json:"size,omitempty"`
+
+	ExtraTimestamp *time.Time `json:"ts,omitempty"`
+	ExtraId        *string    `json:"id,omitempty"`
+	ExtraPage      *int       `json:"pg,omitempty"`
+	ExtraPageSize  *int       `json:"sz,omitempty"`
+}
+
+func NewKeySortToken(valuePrimary string, valueSecondary string, direction SortDirection, directionSecondary SortDirection, pageSize int, extra Extra) CursorToken {
+	return CTKeySort{
+		Mode:               CTMNormal,
+		ValuePrimary:       valuePrimary,
+		ValueSecondary:     valueSecondary,
+		Direction:          direction,
+		DirectionSecondary: directionSecondary,
+		PageSize:           pageSize,
+		Extra:              extra,
+	}
+}
+
+func Start() CursorToken {
+	return CTKeySort{
+		Mode:               CTMStart,
+		ValuePrimary:       "",
+		ValueSecondary:     "",
+		Direction:          "",
+		DirectionSecondary: "",
+		PageSize:           0,
+		Extra:              Extra{},
+	}
+}
+
+func End() CursorToken {
+	return CTKeySort{
+		Mode:               CTMEnd,
+		ValuePrimary:       "",
+		ValueSecondary:     "",
+		Direction:          "",
+		DirectionSecondary: "",
+		PageSize:           0,
+		Extra:              Extra{},
+	}
+}
+
+func (c CTKeySort) Token() string {
+
+	if c.Mode == CTMStart {
+		return "@start"
+	}
+	if c.Mode == CTMEnd {
+		return "@end"
+	}
+
+	// We kinda manually implement omitempty for the CursorToken here
+	// because omitempty does not work for time.Time and otherwise we would always
+	// get weird time values when decoding a token that initially didn't have an Timestamp set
+	// For this usecase we treat Unix=0 as an empty timestamp
+
+	sertok := cursorTokenKeySortSerialize{}
+
+	if c.ValuePrimary != "" {
+		sertok.ValuePrimary = &c.ValuePrimary
+	}
+	if c.ValueSecondary != "" {
+		sertok.ValueSecondary = &c.ValueSecondary
+	}
+	if c.Direction != "" {
+		sertok.Direction = &c.Direction
+	}
+	if c.DirectionSecondary != "" {
+		sertok.DirectionSecondary = &c.DirectionSecondary
+	}
+	if c.PageSize != 0 {
+		sertok.PageSize = &c.PageSize
+	}
+
+	sertok.ExtraTimestamp = c.Extra.Timestamp
+	sertok.ExtraId = c.Extra.Id
+	sertok.ExtraPage = c.Extra.Page
+	sertok.ExtraPageSize = c.Extra.PageSize
+
+	body, err := json.Marshal(sertok)
+	if err != nil {
+		panic(err)
+	}
+
+	return "tok_" + base32.StdEncoding.EncodeToString(body)
+}
+
+func (c CTKeySort) IsEnd() bool {
+	return c.Mode == CTMEnd
+}
+
+func (c CTKeySort) IsStart() bool {
+	return c.Mode == CTMStart
+}
+
+func (c CTKeySort) valuePrimaryObjectId() (primitive.ObjectID, bool) {
+	if oid, err := primitive.ObjectIDFromHex(c.ValuePrimary); err == nil {
+		return oid, true
+	} else {
+		return primitive.ObjectID{}, false
+	}
+}
+
+func (c CTKeySort) valueSecondaryObjectId() (primitive.ObjectID, bool) {
+	if oid, err := primitive.ObjectIDFromHex(c.ValueSecondary); err == nil {
+		return oid, true
+	} else {
+		return primitive.ObjectID{}, false
+	}
+}

cursortoken/tokenPaginate.go

@@ -0,0 +1,41 @@
+package cursortoken
+
+import "strconv"
+
+type CTPaginated struct {
+	Mode Mode
+	Page int
+}
+
+func Page(p int) CursorToken {
+	return CTPaginated{
+		Mode: CTMNormal,
+		Page: p,
+	}
+}
+
+func PageEnd() CursorToken {
+	return CTPaginated{
+		Mode: CTMEnd,
+		Page: 0,
+	}
+}
+
+func (c CTPaginated) Token() string {
+	if c.Mode == CTMStart {
+		return "$1"
+	}
+	if c.Mode == CTMEnd {
+		return "$end"
+	}
+
+	return "$" + strconv.Itoa(c.Page)
+}
+
+func (c CTPaginated) IsEnd() bool {
+	return c.Mode == CTMEnd
+}
+
+func (c CTPaginated) IsStart() bool {
+	return c.Mode == CTMStart || c.Page == 1
+}

dataext/bufferedReadCloser.go

@@ -115,6 +115,9 @@ func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
 				return nil, err
 			}
 		}
+		if err := b.Reset(); err != nil {
+			return nil, err
+		}
 		return b.buffer, nil
 
 	case modeSourceFinished:
@@ -131,10 +134,22 @@ func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
 	}
 }
 
+// Reset resets the buffer to the beginning of the buffer.
+// If the original source is partially read, we will finish reading it and fill our buffer
 func (b *bufferedReadCloser) Reset() error {
 	switch b.mode {
 	case modeSourceReading:
-		fallthrough
+		if b.off == 0 {
+			return nil // nobody has read anything yet
+		}
+		err := b.Close()
+		if err != nil {
+			return err
+		}
+		b.mode = modeBufferReading
+		b.off = 0
+		return nil
+
 	case modeSourceFinished:
 		err := b.Close()
 		if err != nil {

dataext/casMutex.go

@@ -0,0 +1,254 @@
+package dataext
+
+import (
+	"context"
+	"golang.org/x/sync/semaphore"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+	"unsafe"
+)
+
+// from https://github.com/viney-shih/go-lock/blob/2f19fd8ce335e33e0ab9dccb1ff2ce820c3da332/cas.go
+
+// CASMutex is the struct implementing RWMutex with CAS mechanism.
+type CASMutex struct {
+	state     casState
+	turnstile *semaphore.Weighted
+
+	broadcastChan chan struct{}
+	broadcastMut  sync.RWMutex
+}
+
+func NewCASMutex() *CASMutex {
+	return &CASMutex{
+		state:         casStateNoLock,
+		turnstile:     semaphore.NewWeighted(1),
+		broadcastChan: make(chan struct{}),
+	}
+}
+
+type casState int32
+
+const (
+	casStateUndefined casState = iota - 2 // -2
+	casStateWriteLock                     // -1
+	casStateNoLock                        // 0
+	casStateReadLock                      // >= 1
+)
+
+func (m *CASMutex) getState(n int32) casState {
+	switch st := casState(n); {
+	case st == casStateWriteLock:
+		fallthrough
+	case st == casStateNoLock:
+		return st
+	case st >= casStateReadLock:
+		return casStateReadLock
+	default:
+		// actually, it should not happened.
+		return casStateUndefined
+	}
+}
+
+func (m *CASMutex) listen() <-chan struct{} {
+	m.broadcastMut.RLock()
+	defer m.broadcastMut.RUnlock()
+
+	return m.broadcastChan
+}
+
+func (m *CASMutex) broadcast() {
+	newCh := make(chan struct{})
+
+	m.broadcastMut.Lock()
+	ch := m.broadcastChan
+	m.broadcastChan = newCh
+	m.broadcastMut.Unlock()
+
+	close(ch)
+}
+
+func (m *CASMutex) tryLock(ctx context.Context) bool {
+	for {
+		broker := m.listen()
+		if atomic.CompareAndSwapInt32(
+			(*int32)(unsafe.Pointer(&m.state)),
+			int32(casStateNoLock),
+			int32(casStateWriteLock),
+		) {
+			return true
+		}
+
+		if ctx == nil {
+			return false
+		}
+
+		select {
+		case <-ctx.Done():
+			// timeout or cancellation
+			return false
+		case <-broker:
+			// waiting for signal triggered by m.broadcast() and trying again.
+		}
+	}
+}
+
+// TryLockWithContext attempts to acquire the lock, blocking until resources
+// are available or ctx is done (timeout or cancellation).
+func (m *CASMutex) TryLockWithContext(ctx context.Context) bool {
+	if err := m.turnstile.Acquire(ctx, 1); err != nil {
+		// Acquire failed due to timeout or cancellation
+		return false
+	}
+
+	defer m.turnstile.Release(1)
+
+	return m.tryLock(ctx)
+}
+
+// Lock acquires the lock.
+// If it is currently held by others, Lock will wait until it has a chance to acquire it.
+func (m *CASMutex) Lock() {
+	ctx := context.Background()
+
+	m.TryLockWithContext(ctx)
+}
+
+// TryLock attempts to acquire the lock without blocking.
+// Return false if someone is holding it now.
+func (m *CASMutex) TryLock() bool {
+	if !m.turnstile.TryAcquire(1) {
+		return false
+	}
+
+	defer m.turnstile.Release(1)
+
+	return m.tryLock(nil)
+}
+
+// TryLockWithTimeout attempts to acquire the lock within a period of time.
+// Return false if spending time is more than duration and no chance to acquire it.
+func (m *CASMutex) TryLockWithTimeout(duration time.Duration) bool {
+	ctx, cancel := context.WithTimeout(context.Background(), duration)
+	defer cancel()
+
+	return m.TryLockWithContext(ctx)
+}
+
+// Unlock releases the lock.
+func (m *CASMutex) Unlock() {
+	if ok := atomic.CompareAndSwapInt32(
+		(*int32)(unsafe.Pointer(&m.state)),
+		int32(casStateWriteLock),
+		int32(casStateNoLock),
+	); !ok {
+		panic("Unlock failed")
+	}
+
+	m.broadcast()
+}
+
+func (m *CASMutex) rTryLock(ctx context.Context) bool {
+	for {
+		broker := m.listen()
+		n := atomic.LoadInt32((*int32)(unsafe.Pointer(&m.state)))
+		st := m.getState(n)
+		switch st {
+		case casStateNoLock, casStateReadLock:
+			if atomic.CompareAndSwapInt32((*int32)(unsafe.Pointer(&m.state)), n, n+1) {
+				return true
+			}
+		}
+
+		if ctx == nil {
+			return false
+		}
+
+		select {
+		case <-ctx.Done():
+			// timeout or cancellation
+			return false
+		default:
+			switch st {
+			// read-lock failed due to concurrence issue, try again immediately
+			case casStateNoLock, casStateReadLock:
+				runtime.Gosched() // allow other goroutines to do stuff.
+				continue
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			// timeout or cancellation
+			return false
+		case <-broker:
+			// waiting for signal triggered by m.broadcast() and trying again.
+		}
+	}
+}
+
+// RTryLockWithContext attempts to acquire the read lock, blocking until resources
+// are available or ctx is done (timeout or cancellation).
+func (m *CASMutex) RTryLockWithContext(ctx context.Context) bool {
+	if err := m.turnstile.Acquire(ctx, 1); err != nil {
+		// Acquire failed due to timeout or cancellation
+		return false
+	}
+
+	m.turnstile.Release(1)
+
+	return m.rTryLock(ctx)
+}
+
+// RLock acquires the read lock.
+// If it is currently held by others writing, RLock will wait until it has a chance to acquire it.
+func (m *CASMutex) RLock() {
+	ctx := context.Background()
+
+	m.RTryLockWithContext(ctx)
+}
+
+// RTryLock attempts to acquire the read lock without blocking.
+// Return false if someone is writing it now.
+func (m *CASMutex) RTryLock() bool {
+	if !m.turnstile.TryAcquire(1) {
+		return false
+	}
+
+	m.turnstile.Release(1)
+
+	return m.rTryLock(nil)
+}
+
+// RTryLockWithTimeout attempts to acquire the read lock within a period of time.
+// Return false if spending time is more than duration and no chance to acquire it.
+func (m *CASMutex) RTryLockWithTimeout(duration time.Duration) bool {
+	ctx, cancel := context.WithTimeout(context.Background(), duration)
+	defer cancel()
+
+	return m.RTryLockWithContext(ctx)
+}
+
+// RUnlock releases the read lock.
+func (m *CASMutex) RUnlock() {
+	n := atomic.AddInt32((*int32)(unsafe.Pointer(&m.state)), -1)
+	switch m.getState(n) {
+	case casStateUndefined, casStateWriteLock:
+		panic("RUnlock failed")
+	case casStateNoLock:
+		m.broadcast()
+	}
+}
+
+// RLocker returns a Locker interface that implements the Lock and Unlock methods
+// by calling CASMutex.RLock and CASMutex.RUnlock.
+func (m *CASMutex) RLocker() sync.Locker {
+	return (*rlocker)(m)
+}
+
+type rlocker CASMutex
+
+func (r *rlocker) Lock()   { (*CASMutex)(r).RLock() }
+func (r *rlocker) Unlock() { (*CASMutex)(r).RUnlock() }

dataext/delayedCombiningInvoker.go

@@ -0,0 +1,132 @@
+package dataext
+
+import (
+	"context"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/syncext"
+	"sync"
+	"time"
+)
+
+type DelayedCombiningInvoker struct {
+	syncLock           sync.Mutex
+	triggerChan        chan bool
+	cancelChan         chan bool
+	execNowChan        chan bool
+	action             func()
+	delay              time.Duration
+	maxDelay           time.Duration
+	executorRunning    *syncext.AtomicBool
+	lastRequestTime    time.Time
+	initialRequestTime time.Time
+}
+
+func NewDelayedCombiningInvoker(action func(), delay time.Duration, maxDelay time.Duration) *DelayedCombiningInvoker {
+	return &DelayedCombiningInvoker{
+		action:             action,
+		delay:              delay,
+		maxDelay:           maxDelay,
+		executorRunning:    syncext.NewAtomicBool(false),
+		triggerChan:        make(chan bool),
+		cancelChan:         make(chan bool, 1),
+		execNowChan:        make(chan bool, 1),
+		lastRequestTime:    time.Now(),
+		initialRequestTime: time.Now(),
+	}
+}
+
+func (d *DelayedCombiningInvoker) Request() {
+	now := time.Now()
+
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	if d.executorRunning.Get() {
+		d.lastRequestTime = now
+
+		d.triggerChan <- true
+	} else {
+		d.initialRequestTime = now
+		d.lastRequestTime = now
+
+		d.executorRunning.Set(true)
+		syncext.ReadNonBlocking(d.triggerChan) // clear the channel
+		syncext.ReadNonBlocking(d.cancelChan)  // clear the channel
+		syncext.ReadNonBlocking(d.execNowChan) // clear the channel
+		go d.run()
+	}
+}
+
+func (d *DelayedCombiningInvoker) run() {
+	defer func() {
+		d.syncLock.Lock()
+		d.executorRunning.Set(false)
+		d.syncLock.Unlock()
+	}()
+
+	for {
+		d.syncLock.Lock()
+		timeOut := min(d.maxDelay-time.Since(d.initialRequestTime), d.delay-time.Since(d.lastRequestTime))
+		if timeOut < 0 {
+			timeOut = 0
+		}
+		d.syncLock.Unlock()
+
+		immediately := false
+
+		select {
+		case <-d.execNowChan:
+			// run immediately
+			immediately = true
+			break
+		case <-d.triggerChan:
+			// external trigger - needs to re-evaluate
+			break
+		case <-d.cancelChan:
+			// cancel
+			return
+		case <-time.After(timeOut):
+			// time elapsed - check for execution
+			break
+
+		}
+
+		d.syncLock.Lock()
+		execute := immediately || time.Since(d.lastRequestTime) >= d.delay || time.Since(d.initialRequestTime) >= d.maxDelay
+		if !execute {
+			d.syncLock.Unlock()
+			continue
+		}
+
+		_ = langext.RunPanicSafe(d.action)
+		d.syncLock.Unlock()
+		return
+	}
+}
+
+func (d *DelayedCombiningInvoker) CancelPendingRequests() {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	syncext.WriteNonBlocking(d.cancelChan, true)
+}
+
+func (d *DelayedCombiningInvoker) HasPendingRequests() bool {
+	return d.executorRunning.Get()
+}
+
+func (d *DelayedCombiningInvoker) ExecuteNow() bool {
+	d.syncLock.Lock()
+	defer d.syncLock.Unlock()
+
+	if d.executorRunning.Get() {
+		syncext.WriteNonBlocking(d.execNowChan, true)
+		return true
+	} else {
+		return false
+	}
+}
+
+func (d *DelayedCombiningInvoker) WaitForCompletion(ctx context.Context) error {
+	return d.executorRunning.WaitWithContext(ctx, false)
+}

dataext/lruMap_test.go

@@ -1,7 +1,7 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"math/rand"
 	"strconv"
 	"testing"

dataext/merge_test.go

@@ -1,8 +1,8 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

dataext/optional.go

@@ -0,0 +1,83 @@
+package dataext
+
+import (
+	"encoding/json"
+	"errors"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type JsonOpt[T any] struct {
+	isSet bool
+	value T
+}
+
+func NewJsonOpt[T any](v T) JsonOpt[T] {
+	return JsonOpt[T]{isSet: true, value: v}
+}
+
+func EmptyJsonOpt[T any]() JsonOpt[T] {
+	return JsonOpt[T]{isSet: false}
+}
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m JsonOpt[T]) MarshalJSON() ([]byte, error) {
+	if !m.isSet {
+		return []byte("null"), nil // actually this would be undefined - but undefined is not valid JSON
+	}
+
+	return json.Marshal(m.value)
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *JsonOpt[T]) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("JsonOpt: UnmarshalJSON on nil pointer")
+	}
+
+	m.isSet = true
+	return json.Unmarshal(data, &m.value)
+}
+
+func (m JsonOpt[T]) IsSet() bool {
+	return m.isSet
+}
+
+func (m JsonOpt[T]) IsUnset() bool {
+	return !m.isSet
+}
+
+func (m JsonOpt[T]) Value() (T, bool) {
+	if !m.isSet {
+		return *new(T), false
+	}
+	return m.value, true
+}
+
+func (m JsonOpt[T]) ValueOrNil() *T {
+	if !m.isSet {
+		return nil
+	}
+	return &m.value
+}
+
+func (m JsonOpt[T]) ValueDblPtrOrNil() **T {
+	if !m.isSet {
+		return nil
+	}
+	return langext.DblPtr(m.value)
+}
+
+func (m JsonOpt[T]) MustValue() T {
+	if !m.isSet {
+		panic("value not set")
+	}
+	return m.value
+}
+
+func (m JsonOpt[T]) IfSet(fn func(v T)) bool {
+	if !m.isSet {
+		return false
+	}
+	fn(m.value)
+	return true
+}

dataext/ringBuffer.go

@@ -0,0 +1,144 @@
+package dataext
+
+import "iter"
+
+type RingBuffer[T any] struct {
+	items    []T //
+	capacity int // max number of items the buffer can hold
+	size     int // how many items are in the buffer
+	head     int // ptr to next item
+}
+
+func NewRingBuffer[T any](capacity int) *RingBuffer[T] {
+	return &RingBuffer[T]{
+		items:    make([]T, capacity),
+		capacity: capacity,
+		size:     0,
+		head:     0,
+	}
+}
+
+func (rb *RingBuffer[T]) Push(item T) {
+	if rb.size < rb.capacity {
+		rb.size++
+	}
+	rb.items[rb.head] = item
+	rb.head = (rb.head + 1) % rb.capacity
+}
+
+func (rb *RingBuffer[T]) PushPop(item T) *T {
+	if rb.size < rb.capacity {
+		rb.size++
+		rb.items[rb.head] = item
+		rb.head = (rb.head + 1) % rb.capacity
+		return nil
+	} else {
+		prev := rb.items[rb.head]
+		rb.items[rb.head] = item
+		rb.head = (rb.head + 1) % rb.capacity
+		return &prev
+	}
+}
+
+func (rb *RingBuffer[T]) Peek() (T, bool) {
+	if rb.size == 0 {
+		return *new(T), false
+	}
+	return rb.items[(rb.head-1+rb.capacity)%rb.capacity], true
+}
+
+func (rb *RingBuffer[T]) Items() []T {
+	if rb.size < rb.capacity {
+		return rb.items[:rb.size]
+	}
+	return append(rb.items[rb.head:], rb.items[:rb.head]...)
+}
+
+func (rb *RingBuffer[T]) Size() int {
+	return rb.size
+}
+
+func (rb *RingBuffer[T]) Capacity() int {
+	return rb.capacity
+}
+
+func (rb *RingBuffer[T]) Clear() {
+	rb.size = 0
+	rb.head = 0
+}
+
+func (rb *RingBuffer[T]) IsFull() bool {
+	return rb.size == rb.capacity
+}
+
+func (rb *RingBuffer[T]) At(i int) T {
+	if i < 0 || i >= rb.size {
+		panic("Index out of bounds")
+	}
+	if rb.size < rb.capacity {
+		return rb.items[i]
+	}
+	return rb.items[(rb.head+i)%rb.capacity]
+}
+
+func (rb *RingBuffer[T]) Get(i int) (T, bool) {
+	if i < 0 || i >= rb.size {
+		return *new(T), false
+	}
+	if rb.size < rb.capacity {
+		return rb.items[i], true
+	}
+	return rb.items[(rb.head+i)%rb.capacity], true
+}
+
+func (rb *RingBuffer[T]) Iter() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for i := 0; i < rb.size; i++ {
+			if !yield(rb.At(i)) {
+				return
+			}
+		}
+	}
+}
+
+func (rb *RingBuffer[T]) Iter2() iter.Seq2[int, T] {
+	return func(yield func(int, T) bool) {
+		for i := 0; i < rb.size; i++ {
+			if !yield(i, rb.At(i)) {
+				return
+			}
+		}
+	}
+}
+
+func (rb *RingBuffer[T]) Remove(fnEqual func(v T) bool) int {
+	// Mike [2024-11-13]: I *really* tried to write an in-place algorithm to remove elements
+	//                    But after carful consideration, I left that as an exercise for future readers
+	//                    It is, suprisingly, non-trivial, especially because the head-ptr must be weirdly updated
+	//                    And out At() method does not work correctly with {head<>0 && size<capacity}
+
+	dc := 0
+	b := make([]T, rb.capacity)
+	bsize := 0
+
+	for i := 0; i < rb.size; i++ {
+		comp := rb.At(i)
+		if fnEqual(comp) {
+			dc++
+		} else {
+			b[bsize] = comp
+			bsize++
+		}
+	}
+
+	if dc == 0 {
+		return 0
+	}
+
+	rb.items = b
+	rb.size = bsize
+	rb.head = bsize % rb.capacity
+
+	return dc
+
+}

dataext/ringBuffer_test.go

@@ -0,0 +1,447 @@
+package dataext
+
+import "testing"
+
+func TestRingBufferPushAddsItem(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	if rb.Size() != 1 {
+		t.Errorf("Expected size 1, got %d", rb.Size())
+	}
+	if item, _ := rb.Peek(); item != 1 {
+		t.Errorf("Expected item 1, got %d", item)
+	}
+}
+
+func TestRingBufferPushPopReturnsOldestItem(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	if item := rb.PushPop(4); item == nil || *item != 1 {
+		t.Errorf("Expected item 1, got %v", item)
+	}
+}
+
+func TestRingBufferPeekReturnsLastPushedItem(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	if item, _ := rb.Peek(); item != 2 {
+		t.Errorf("Expected item 2, got %d", item)
+	}
+}
+
+func TestRingBufferOverflow1(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1) // overriden
+	rb.Push(2) // overriden
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	rb.Push(5)
+	rb.Push(7)
+	if rb.Size() != 5 {
+		t.Errorf("Expected size 4, got %d", rb.Size())
+	}
+	expected := []int{3, 9, 4, 5, 7}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferItemsReturnsAllItems(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	items := rb.Items()
+	expected := []int{1, 2, 3}
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferClearEmptiesBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Clear()
+	if rb.Size() != 0 {
+		t.Errorf("Expected size 0, got %d", rb.Size())
+	}
+}
+
+func TestRingBufferIsFullReturnsTrueWhenFull(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	if !rb.IsFull() {
+		t.Errorf("Expected buffer to be full")
+	}
+}
+
+func TestRingBufferAtReturnsCorrectItem(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	if item := rb.At(1); item != 2 {
+		t.Errorf("Expected item 2, got %d", item)
+	}
+}
+
+func TestRingBufferGetReturnsCorrectItem(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	if item, ok := rb.Get(1); !ok || item != 2 {
+		t.Errorf("Expected item 2, got %d", item)
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	rb.Push(2)
+	rb.Push(4)
+	removed := rb.Remove(func(v int) bool { return v == 2 })
+	if removed != 2 {
+		t.Errorf("Expected 2 items removed, got %d", removed)
+	}
+	if rb.Size() != 3 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+	expected := []int{1, 3, 4}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems2(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	rb.Push(2)
+	rb.Push(4)
+	removed := rb.Remove(func(v int) bool { return v == 3 })
+	if removed != 1 {
+		t.Errorf("Expected 2 items removed, got %d", removed)
+	}
+	if rb.Size() != 4 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+	expected := []int{1, 2, 2, 4}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems3(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	removed := rb.Remove(func(v int) bool { return v == 3 })
+	if removed != 1 {
+		t.Errorf("Expected 2 items removed, got %d", removed)
+	}
+	if rb.Size() != 4 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+	expected := []int{1, 2, 9, 4}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems4(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1) // overriden
+	rb.Push(2) // overriden
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	rb.Push(5)
+	rb.Push(7)
+	removed := rb.Remove(func(v int) bool { return v == 7 })
+	if removed != 1 {
+		t.Errorf("Expected 1 items removed, got %d", removed)
+	}
+	if rb.Size() != 4 {
+		t.Errorf("Expected size 4, got %d", rb.Size())
+	}
+	expected := []int{3, 9, 4, 5}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems5(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1) // overriden
+	rb.Push(2) // overriden
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	rb.Push(5)
+	rb.Push(7)
+	removed := rb.Remove(func(v int) bool { return v == 3 })
+	if removed != 1 {
+		t.Errorf("Expected 1 items removed, got %d", removed)
+	}
+	if rb.Size() != 4 {
+		t.Errorf("Expected size 4, got %d", rb.Size())
+	}
+	expected := []int{9, 4, 5, 7}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems6(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1) // overriden
+	rb.Push(2) // overriden
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	rb.Push(5)
+	rb.Push(7)
+	removed := rb.Remove(func(v int) bool { return v == 1 })
+	if removed != 0 {
+		t.Errorf("Expected 0 items removed, got %d", removed)
+	}
+	if rb.Size() != 5 {
+		t.Errorf("Expected size 5, got %d", rb.Size())
+	}
+	expected := []int{3, 9, 4, 5, 7}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+	if !rb.IsFull() {
+		t.Errorf("Expected buffer to not be full")
+	}
+}
+
+func TestRingBufferRemoveDeletesMatchingItems7(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1) // overriden
+	rb.Push(2) // overriden
+	rb.Push(3)
+	rb.Push(9)
+	rb.Push(4)
+	rb.Push(5)
+	rb.Push(7)
+	removed := rb.Remove(func(v int) bool { return v == 9 })
+	if removed != 1 {
+		t.Errorf("Expected 1 items removed, got %d", removed)
+	}
+	if rb.Size() != 4 {
+		t.Errorf("Expected size 4, got %d", rb.Size())
+	}
+	expected := []int{3, 4, 5, 7}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+	if rb.IsFull() {
+		t.Errorf("Expected buffer to not be full")
+	}
+}
+
+func TestRingBufferAddItemsToFullRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	rb.Push(4)
+	if rb.Size() != 3 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+	expected := []int{2, 3, 4}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferAddItemsToNonFullRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	if rb.Size() != 2 {
+		t.Errorf("Expected size 2, got %d", rb.Size())
+	}
+	expected := []int{1, 2}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveItemsFromNonFullRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	removed := rb.Remove(func(v int) bool { return v == 1 })
+	if removed != 1 {
+		t.Errorf("Expected 1 item removed, got %d", removed)
+	}
+	if rb.Size() != 1 {
+		t.Errorf("Expected size 1, got %d", rb.Size())
+	}
+	expected := []int{2}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveItemsFromFullRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	removed := rb.Remove(func(v int) bool { return v == 2 })
+	if removed != 1 {
+		t.Errorf("Expected 1 item removed, got %d", removed)
+	}
+	if rb.Size() != 2 {
+		t.Errorf("Expected size 2, got %d", rb.Size())
+	}
+	expected := []int{1, 3}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveMultipleItemsFromRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](5)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	rb.Push(2)
+	rb.Push(4)
+	removed := rb.Remove(func(v int) bool { return v == 2 })
+	if removed != 2 {
+		t.Errorf("Expected 2 items removed, got %d", removed)
+	}
+	if rb.Size() != 3 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+	expected := []int{1, 3, 4}
+	items := rb.Items()
+	for i, item := range items {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+	}
+}
+
+func TestRingBufferRemoveAllItemsFromRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	removed := rb.Remove(func(v int) bool { return true })
+	if removed != 3 {
+		t.Errorf("Expected 3 items removed, got %d", removed)
+	}
+	if rb.Size() != 0 {
+		t.Errorf("Expected size 0, got %d", rb.Size())
+	}
+}
+
+func TestRingBufferRemoveNoItemsFromRingBuffer(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	removed := rb.Remove(func(v int) bool { return false })
+	if removed != 0 {
+		t.Errorf("Expected 0 items removed, got %d", removed)
+	}
+	if rb.Size() != 3 {
+		t.Errorf("Expected size 3, got %d", rb.Size())
+	}
+}
+
+func TestRingBufferIteratesOverAllItems(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	expected := []int{1, 2, 3}
+	i := 0
+	for item := range rb.Iter() {
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+		i++
+	}
+	if i != len(expected) {
+		t.Errorf("Expected to iterate over %d items, but iterated over %d", len(expected), i)
+	}
+}
+
+func TestRingBufferIter2IteratesOverAllItemsWithIndices(t *testing.T) {
+	rb := NewRingBuffer[int](3)
+	rb.Push(1)
+	rb.Push(2)
+	rb.Push(3)
+	expected := []int{1, 2, 3}
+	i := 0
+	for index, item := range rb.Iter2() {
+		if index != i {
+			t.Errorf("Expected index %d, got %d", i, index)
+		}
+		if item != expected[i] {
+			t.Errorf("Expected item %d, got %d", expected[i], item)
+		}
+		i++
+	}
+	if i != len(expected) {
+		t.Errorf("Expected to iterate over %d items, but iterated over %d", len(expected), i)
+	}
+}

dataext/stack.go

@@ -2,7 +2,7 @@ package dataext
 
 import (
 	"errors"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"sync"
 )
 

dataext/structHash.go

@@ -6,7 +6,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
 	"hash"
 	"io"
 	"reflect"

dataext/structHash_test.go

@@ -1,8 +1,8 @@
 package dataext
 
 import (
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
 	"testing"
 )
 

dataext/syncMap.go

@@ -0,0 +1,204 @@
+package dataext
+
+import "sync"
+
+type SyncMap[TKey comparable, TData any] struct {
+	data map[TKey]TData
+	lock sync.Mutex
+}
+
+func NewSyncMap[TKey comparable, TData any]() *SyncMap[TKey, TData] {
+	return &SyncMap[TKey, TData]{data: make(map[TKey]TData), lock: sync.Mutex{}}
+}
+
+func (s *SyncMap[TKey, TData]) Set(key TKey, data TData) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	s.data[key] = data
+}
+
+func (s *SyncMap[TKey, TData]) SetIfNotContains(key TKey, data TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if _, existsInPreState := s.data[key]; existsInPreState {
+		return false
+	}
+
+	s.data[key] = data
+
+	return true
+}
+
+func (s *SyncMap[TKey, TData]) SetIfNotContainsFunc(key TKey, data func() TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if _, existsInPreState := s.data[key]; existsInPreState {
+		return false
+	}
+
+	s.data[key] = data()
+
+	return true
+}
+
+func (s *SyncMap[TKey, TData]) Get(key TKey) (TData, bool) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if v, ok := s.data[key]; ok {
+		return v, true
+	} else {
+		return *new(TData), false
+	}
+}
+
+func (s *SyncMap[TKey, TData]) GetAndSetIfNotContains(key TKey, data TData) TData {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if v, ok := s.data[key]; ok {
+		return v
+	} else {
+		s.data[key] = data
+		return data
+	}
+}
+
+func (s *SyncMap[TKey, TData]) GetAndSetIfNotContainsFunc(key TKey, data func() TData) TData {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	if v, ok := s.data[key]; ok {
+		return v
+	} else {
+		dataObj := data()
+		s.data[key] = dataObj
+		return dataObj
+	}
+}
+
+func (s *SyncMap[TKey, TData]) Delete(key TKey) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	_, ok := s.data[key]
+
+	delete(s.data, key)
+
+	return ok
+}
+
+func (s *SyncMap[TKey, TData]) DeleteIf(fn func(key TKey, data TData) bool) int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	rm := 0
+	for k, v := range s.data {
+		if fn(k, v) {
+			delete(s.data, k)
+			rm++
+		}
+	}
+
+	return rm
+}
+
+func (s *SyncMap[TKey, TData]) Clear() {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.data = make(map[TKey]TData)
+}
+
+func (s *SyncMap[TKey, TData]) Contains(key TKey) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	_, ok := s.data[key]
+
+	return ok
+}
+
+func (s *SyncMap[TKey, TData]) GetAllKeys() []TKey {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	r := make([]TKey, 0, len(s.data))
+
+	for k := range s.data {
+		r = append(r, k)
+	}
+
+	return r
+}
+
+func (s *SyncMap[TKey, TData]) GetAllValues() []TData {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	r := make([]TData, 0, len(s.data))
+
+	for _, v := range s.data {
+		r = append(r, v)
+	}
+
+	return r
+}
+
+func (s *SyncMap[TKey, TData]) Count() int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TKey]TData)
+	}
+
+	return len(s.data)
+}

dataext/syncRingSet.go

@@ -0,0 +1,143 @@
+package dataext
+
+import "sync"
+
+type SyncRingSet[TData comparable] struct {
+	data map[TData]bool
+	lock sync.Mutex
+	ring *RingBuffer[TData]
+}
+
+func NewSyncRingSet[TData comparable](capacity int) *SyncRingSet[TData] {
+	return &SyncRingSet[TData]{
+		data: make(map[TData]bool, capacity+1),
+		lock: sync.Mutex{},
+		ring: NewRingBuffer[TData](capacity),
+	}
+}
+
+// Add adds `value` to the set
+// returns true  if the value was actually inserted (value did not exist beforehand)
+// returns false if the value already existed
+func (s *SyncRingSet[TData]) Add(value TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	_, existsInPreState := s.data[value]
+	if existsInPreState {
+		return false
+	}
+
+	prev := s.ring.PushPop(value)
+
+	s.data[value] = true
+	if prev != nil {
+		delete(s.data, *prev)
+	}
+
+	return true
+}
+
+func (s *SyncRingSet[TData]) AddAll(values []TData) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	for _, value := range values {
+		_, existsInPreState := s.data[value]
+		if existsInPreState {
+			continue
+		}
+
+		prev := s.ring.PushPop(value)
+
+		s.data[value] = true
+		if prev != nil {
+			delete(s.data, *prev)
+		}
+	}
+}
+
+func (s *SyncRingSet[TData]) Remove(value TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	_, existsInPreState := s.data[value]
+	if !existsInPreState {
+		return false
+	}
+
+	delete(s.data, value)
+	s.ring.Remove(func(v TData) bool { return value == v })
+
+	return true
+}
+
+func (s *SyncRingSet[TData]) RemoveAll(values []TData) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	for _, value := range values {
+		delete(s.data, value)
+		s.ring.Remove(func(v TData) bool { return value == v })
+	}
+}
+
+func (s *SyncRingSet[TData]) Contains(value TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	_, ok := s.data[value]
+
+	return ok
+}
+
+func (s *SyncRingSet[TData]) Get() []TData {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	r := make([]TData, 0, len(s.data))
+
+	for k := range s.data {
+		r = append(r, k)
+	}
+
+	return r
+}
+
+// AddIfNotContains
+// returns true  if the value was actually added (value did not exist beforehand)
+// returns false if the value already existed
+func (s *SyncRingSet[TData]) AddIfNotContains(key TData) bool {
+	return s.Add(key)
+}
+
+// RemoveIfContains
+// returns true  if the value was actually removed (value did exist beforehand)
+// returns false if the value did not exist in the set
+func (s *SyncRingSet[TData]) RemoveIfContains(key TData) bool {
+	return s.Remove(key)
+}

dataext/syncSet.go

@@ -7,6 +7,13 @@ type SyncSet[TData comparable] struct {
 	lock sync.Mutex
 }
 
+func NewSyncSet[TData comparable]() *SyncSet[TData] {
+	return &SyncSet[TData]{data: make(map[TData]bool), lock: sync.Mutex{}}
+}
+
+// Add adds `value` to the set
+// returns true  if the value was actually inserted (value did not exist beforehand)
+// returns false if the value already existed
 func (s *SyncSet[TData]) Add(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -15,10 +22,13 @@ 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
+	if existsInPreState {
+		return false
+	}
 
-	return !ok
+	s.data[value] = true
+	return true
 }
 
 func (s *SyncSet[TData]) AddAll(values []TData) {
@@ -34,6 +44,36 @@ func (s *SyncSet[TData]) AddAll(values []TData) {
 	}
 }
 
+func (s *SyncSet[TData]) Remove(value TData) bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	_, existsInPreState := s.data[value]
+	if !existsInPreState {
+		return false
+	}
+
+	delete(s.data, value)
+	return true
+}
+
+func (s *SyncSet[TData]) RemoveAll(values []TData) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if s.data == nil {
+		s.data = make(map[TData]bool)
+	}
+
+	for _, value := range values {
+		delete(s.data, value)
+	}
+}
+
 func (s *SyncSet[TData]) Contains(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@@ -63,3 +103,17 @@ func (s *SyncSet[TData]) Get() []TData {
 
 	return r
 }
+
+// AddIfNotContains
+// returns true  if the value was actually added (value did not exist beforehand)
+// returns false if the value already existed
+func (s *SyncSet[TData]) AddIfNotContains(key TData) bool {
+	return s.Add(key)
+}
+
+// RemoveIfContains
+// returns true  if the value was actually removed (value did exist beforehand)
+// returns false if the value did not exist in the set
+func (s *SyncSet[TData]) RemoveIfContains(key TData) bool {
+	return s.Remove(key)
+}

dataext/tuple.go

@@ -0,0 +1,241 @@
+package dataext
+
+type ValueGroup interface {
+	TupleLength() int
+	TupleValues() []any
+}
+
+// ----------------------------------------------------------------------------
+
+type Single[T1 any] struct {
+	V1 T1
+}
+
+func (s Single[T1]) TupleLength() int {
+	return 1
+}
+
+func (s Single[T1]) TupleValues() []any {
+	return []any{s.V1}
+}
+
+func NewSingle[T1 any](v1 T1) Single[T1] {
+	return Single[T1]{V1: v1}
+}
+
+func NewTuple1[T1 any](v1 T1) Single[T1] {
+	return Single[T1]{V1: v1}
+}
+
+// ----------------------------------------------------------------------------
+
+type Tuple[T1 any, T2 any] struct {
+	V1 T1
+	V2 T2
+}
+
+func (t Tuple[T1, T2]) TupleLength() int {
+	return 2
+}
+
+func (t Tuple[T1, T2]) TupleValues() []any {
+	return []any{t.V1, t.V2}
+}
+
+func NewTuple[T1 any, T2 any](v1 T1, v2 T2) Tuple[T1, T2] {
+	return Tuple[T1, T2]{V1: v1, V2: v2}
+}
+
+func NewTuple2[T1 any, T2 any](v1 T1, v2 T2) Tuple[T1, T2] {
+	return Tuple[T1, T2]{V1: v1, V2: v2}
+}
+
+// ----------------------------------------------------------------------------
+
+type Triple[T1 any, T2 any, T3 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+}
+
+func (t Triple[T1, T2, T3]) TupleLength() int {
+	return 3
+}
+
+func (t Triple[T1, T2, T3]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3}
+}
+
+func NewTriple[T1 any, T2 any, T3 any](v1 T1, v2 T2, v3 T3) Triple[T1, T2, T3] {
+	return Triple[T1, T2, T3]{V1: v1, V2: v2, V3: v3}
+}
+
+func NewTuple3[T1 any, T2 any, T3 any](v1 T1, v2 T2, v3 T3) Triple[T1, T2, T3] {
+	return Triple[T1, T2, T3]{V1: v1, V2: v2, V3: v3}
+}
+
+// ----------------------------------------------------------------------------
+
+type Quadruple[T1 any, T2 any, T3 any, T4 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+}
+
+func (t Quadruple[T1, T2, T3, T4]) TupleLength() int {
+	return 4
+}
+
+func (t Quadruple[T1, T2, T3, T4]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4}
+}
+
+func NewQuadruple[T1 any, T2 any, T3 any, T4 any](v1 T1, v2 T2, v3 T3, v4 T4) Quadruple[T1, T2, T3, T4] {
+	return Quadruple[T1, T2, T3, T4]{V1: v1, V2: v2, V3: v3, V4: v4}
+}
+
+func NewTuple4[T1 any, T2 any, T3 any, T4 any](v1 T1, v2 T2, v3 T3, v4 T4) Quadruple[T1, T2, T3, T4] {
+	return Quadruple[T1, T2, T3, T4]{V1: v1, V2: v2, V3: v3, V4: v4}
+}
+
+// ----------------------------------------------------------------------------
+
+type Quintuple[T1 any, T2 any, T3 any, T4 any, T5 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+}
+
+func (t Quintuple[T1, T2, T3, T4, T5]) TupleLength() int {
+	return 5
+}
+
+func (t Quintuple[T1, T2, T3, T4, T5]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4, t.V5}
+
+}
+
+func NewQuintuple[T1 any, T2 any, T3 any, T4 any, T5 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) Quintuple[T1, T2, T3, T4, T5] {
+	return Quintuple[T1, T2, T3, T4, T5]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5}
+}
+
+func NewTuple5[T1 any, T2 any, T3 any, T4 any, T5 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5) Quintuple[T1, T2, T3, T4, T5] {
+	return Quintuple[T1, T2, T3, T4, T5]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5}
+}
+
+// ----------------------------------------------------------------------------
+
+type Sextuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+}
+
+func (t Sextuple[T1, T2, T3, T4, T5, T6]) TupleLength() int {
+	return 6
+}
+
+func (t Sextuple[T1, T2, T3, T4, T5, T6]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6}
+
+}
+
+func NewSextuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) Sextuple[T1, T2, T3, T4, T5, T6] {
+	return Sextuple[T1, T2, T3, T4, T5, T6]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6}
+}
+
+func NewTuple6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6) Sextuple[T1, T2, T3, T4, T5, T6] {
+	return Sextuple[T1, T2, T3, T4, T5, T6]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6}
+}
+
+// ----------------------------------------------------------------------------
+
+type Septuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+}
+
+func (t Septuple[T1, T2, T3, T4, T5, T6, T7]) TupleLength() int {
+	return 7
+}
+
+func (t Septuple[T1, T2, T3, T4, T5, T6, T7]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7}
+}
+
+func NewSeptuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) Septuple[T1, T2, T3, T4, T5, T6, T7] {
+	return Septuple[T1, T2, T3, T4, T5, T6, T7]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7}
+}
+
+func NewTuple7[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7) Septuple[T1, T2, T3, T4, T5, T6, T7] {
+	return Septuple[T1, T2, T3, T4, T5, T6, T7]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7}
+}
+
+// ----------------------------------------------------------------------------
+
+type Octuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+	V8 T8
+}
+
+func (t Octuple[T1, T2, T3, T4, T5, T6, T7, T8]) TupleLength() int {
+	return 8
+}
+
+func (t Octuple[T1, T2, T3, T4, T5, T6, T7, T8]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8}
+}
+
+func NewOctuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) Octuple[T1, T2, T3, T4, T5, T6, T7, T8] {
+	return Octuple[T1, T2, T3, T4, T5, T6, T7, T8]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8}
+}
+
+func NewTuple8[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8) Octuple[T1, T2, T3, T4, T5, T6, T7, T8] {
+	return Octuple[T1, T2, T3, T4, T5, T6, T7, T8]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8}
+}
+
+// ----------------------------------------------------------------------------
+
+type Nonuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any] struct {
+	V1 T1
+	V2 T2
+	V3 T3
+	V4 T4
+	V5 T5
+	V6 T6
+	V7 T7
+	V8 T8
+	V9 T9
+}
+
+func (t Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]) TupleLength() int {
+	return 9
+}
+
+func (t Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]) TupleValues() []any {
+	return []any{t.V1, t.V2, t.V3, t.V4, t.V5, t.V6, t.V7, t.V8, t.V9}
+}
+
+func NewNonuple[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	return Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8, V9: v9}
+}
+func NewTuple9[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any, T7 any, T8 any, T9 any](v1 T1, v2 T2, v3 T3, v4 T4, v5 T5, v6 T6, v7 T7, v8 T8, v9 T9) Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	return Nonuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]{V1: v1, V2: v2, V3: v3, V4: v4, V5: v5, V6: v6, V7: v7, V8: v8, V9: v9}
+}

enums/enum.go

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

exerr/builder.go

@@ -0,0 +1,536 @@
+package exerr
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/enums"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"net/http"
+	"os"
+	"runtime/debug"
+	"strings"
+	"time"
+)
+
+//
+// ==== USAGE =====
+//
+// If some method returns an error _always wrap it into an exerror:
+//     value, err := do_something(..)
+//     if err != nil {
+//         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, exerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
+//
+// You can also add extra-data to an error with Extra(..)
+// in contrast to metadata is extradata always printed in the resulting error and is more intended for additional (programmatically readable) data in addition to the errortype
+// (metadata is more internal debug info/help)
+//
+// 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, 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:
+//   - return the error to the caller and let him handle it:
+//     (also auto-prints the error to the log)
+//     => Wrap/New + Build
+//   - Print the error
+//     (also auto-sends it to the error-service)
+//     This is useful for errors that happen asynchron or are non-fatal for the current request
+//     => Wrap/New + Print
+//   - Return the error to the Rest-API caller
+//     (also auto-prints the error to the log)
+//     (also auto-sends it to the error-service)
+//     => Wrap/New + Output
+//   - Print and stop the service
+//     (also auto-sends it to the error-service)
+//     => Wrap/New + Fatal
+//
+
+type Builder struct {
+	wrappedErr          error
+	errorData           *ExErr
+	containsGinData     bool
+	containsContextData bool
+	noLog               bool
+}
+
+func Get(err error) *Builder {
+	return &Builder{errorData: FromError(err)}
+}
+
+func New(t ErrorType, msg string) *Builder {
+	return &Builder{errorData: newExErr(CatSystem, t, msg)}
+}
+
+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
+	}
+
+	v := FromError(err)
+
+	if !pkgconfig.RecursiveErrors {
+		v.Message = msg
+		return &Builder{wrappedErr: err, errorData: v}
+	} else {
+		return &Builder{wrappedErr: err, errorData: wrapExErr(v, msg, CatWrap, 1)}
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) WithType(t ErrorType) *Builder {
+	b.errorData.Type = t
+	return b
+}
+
+func (b *Builder) WithStatuscode(status int) *Builder {
+	b.errorData.StatusCode = &status
+	return b
+}
+
+func (b *Builder) WithMessage(msg string) *Builder {
+	b.errorData.Message = msg
+	return b
+}
+
+func (b *Builder) WithSeverity(v ErrorSeverity) *Builder {
+	b.errorData.Severity = v
+	return b
+}
+
+func (b *Builder) WithCategory(v ErrorCategory) *Builder {
+	b.errorData.Category = v
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+// Err changes the Severity to ERROR (default)
+// The error will be:
+//
+//   - On Build():
+//
+//   - Short-Logged as Err
+//
+//   - On Print():
+//
+//   - Logged as Err
+//
+//   - Send to the error-service
+//
+//   - On Output():
+//
+//   - Logged as Err
+//
+//   - Send to the error-service
+func (b *Builder) Err() *Builder {
+	b.errorData.Severity = SevErr
+	return b
+}
+
+// Warn changes the Severity to WARN
+// The error will be:
+//
+//   - On Build():
+//
+//   - -(nothing)-
+//
+//   - On Print():
+//
+//   - Short-Logged as Warn
+//
+//   - On Output():
+//
+//   - Logged as Warn
+func (b *Builder) Warn() *Builder {
+	b.errorData.Severity = SevWarn
+	return b
+}
+
+// Info changes the Severity to INFO
+// The error will be:
+//
+//   - On Build():
+//
+//   - -(nothing)-
+//
+//   - On Print():
+//
+//   - -(nothing)-
+//
+//   - On Output():
+//
+//   - -(nothing)-
+func (b *Builder) Info() *Builder {
+	b.errorData.Severity = SevInfo
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+// User sets the Category to CatUser
+//
+// Errors with category
+func (b *Builder) User() *Builder {
+	b.errorData.Category = CatUser
+	return b
+}
+
+func (b *Builder) System() *Builder {
+	b.errorData.Category = CatSystem
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) NoLog() *Builder {
+	b.noLog = true
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) Id(key string, val fmt.Stringer) *Builder {
+	return b.addMeta(key, MDTID, newIDWrap(val))
+}
+
+func (b *Builder) StrPtr(key string, val *string) *Builder {
+	return b.addMeta(key, MDTStringPtr, val)
+}
+
+func (b *Builder) Str(key string, val string) *Builder {
+	return b.addMeta(key, MDTString, val)
+}
+
+func (b *Builder) Int(key string, val int) *Builder {
+	return b.addMeta(key, MDTInt, val)
+}
+
+func (b *Builder) Int8(key string, val int8) *Builder {
+	return b.addMeta(key, MDTInt8, val)
+}
+
+func (b *Builder) Int16(key string, val int16) *Builder {
+	return b.addMeta(key, MDTInt16, val)
+}
+
+func (b *Builder) Int32(key string, val int32) *Builder {
+	return b.addMeta(key, MDTInt32, val)
+}
+
+func (b *Builder) Int64(key string, val int64) *Builder {
+	return b.addMeta(key, MDTInt64, val)
+}
+
+func (b *Builder) Float32(key string, val float32) *Builder {
+	return b.addMeta(key, MDTFloat32, val)
+}
+
+func (b *Builder) Float64(key string, val float64) *Builder {
+	return b.addMeta(key, MDTFloat64, val)
+}
+
+func (b *Builder) Bool(key string, val bool) *Builder {
+	return b.addMeta(key, MDTBool, val)
+}
+
+func (b *Builder) Bytes(key string, val []byte) *Builder {
+	return b.addMeta(key, MDTBytes, val)
+}
+
+func (b *Builder) ObjectID(key string, val primitive.ObjectID) *Builder {
+	return b.addMeta(key, MDTObjectID, val)
+}
+
+func (b *Builder) Time(key string, val time.Time) *Builder {
+	return b.addMeta(key, MDTTime, val)
+}
+
+func (b *Builder) Dur(key string, val time.Duration) *Builder {
+	return b.addMeta(key, MDTDuration, val)
+}
+
+func (b *Builder) Strs(key string, val []string) *Builder {
+	return b.addMeta(key, MDTStringArray, val)
+}
+
+func (b *Builder) Ints(key string, val []int) *Builder {
+	return b.addMeta(key, MDTIntArray, val)
+}
+
+func (b *Builder) Ints32(key string, val []int32) *Builder {
+	return b.addMeta(key, MDTInt32Array, val)
+}
+
+func (b *Builder) Type(key string, cls interface{}) *Builder {
+	return b.addMeta(key, MDTString, fmt.Sprintf("%T", cls))
+}
+
+func (b *Builder) Interface(key string, val interface{}) *Builder {
+	return b.addMeta(key, MDTAny, newAnyWrap(val))
+}
+
+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 langext.IsNil(val) {
+		return b.addMeta(key, MDTString, "(!nil)")
+	} else {
+		return b.addMeta(key, MDTString, val.String())
+	}
+}
+
+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()))
+}
+
+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).errorData.FormatLog(LogPrintFull))
+	}
+	return b
+}
+
+func (b *Builder) GinReq(ctx context.Context, g *gin.Context, req *http.Request) *Builder {
+	if v := ctx.Value("start_timestamp"); v != nil {
+		if t, ok := v.(time.Time); ok {
+			b.Time("ctx_startTimestamp", t)
+			b.Time("ctx_endTimestamp", time.Now())
+		}
+	}
+	b.Str("gin_method", req.Method)
+	b.Str("gin_host", req.Host)
+	b.Str("gin_path", g.FullPath())
+	b.Strs("gin_header", extractHeader(g.Request.Header))
+	if req.URL != nil {
+		b.Str("gin_url", req.URL.String())
+	}
+	if ctxVal := g.GetString("apiversion"); ctxVal != "" {
+		b.Str("gin_context_apiversion", ctxVal)
+	}
+	if ctxVal := g.GetString("uid"); ctxVal != "" {
+		b.Str("gin_context_uid", ctxVal)
+	}
+	if ctxVal := g.GetString("fcmId"); ctxVal != "" {
+		b.Str("gin_context_fcmid", ctxVal)
+	}
+	if ctxVal := g.GetString("reqid"); ctxVal != "" {
+		b.Str("gin_context_reqid", ctxVal)
+	}
+	if req.Method != "GET" && req.Body != nil {
+
+		if req.Header.Get("Content-Type") == "application/json" {
+			if brc, ok := req.Body.(dataext.BufferedReadCloser); ok {
+				if bin, err := brc.BufferedAll(); err == nil {
+					if len(bin) < 16*1024 {
+						var prettyJSON bytes.Buffer
+						err = json.Indent(&prettyJSON, bin, "", "  ")
+						if err == nil {
+							b.Str("gin_body", string(prettyJSON.Bytes()))
+						} else {
+							b.Bytes("gin_body", bin)
+						}
+					} else {
+						b.Str("gin_body", fmt.Sprintf("[[%v bytes | %s]]", len(bin), req.Header.Get("Content-Type")))
+					}
+				}
+			}
+		}
+
+		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")))
+					}
+				}
+			}
+		}
+
+	}
+
+	pkgconfig.ExtendGinMeta(ctx, b, g, req)
+
+	b.containsGinData = true
+	return b
+}
+
+func (b *Builder) CtxData(method Method, ctx context.Context) *Builder {
+	pkgconfig.ExtendContextMeta(b, method, ctx)
+
+	b.containsContextData = true
+
+	return b
+}
+
+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
+}
+
+// ----------------------------------------------------------------------------
+
+// Extra adds additional data to the error
+// this is not like the other metadata (like Id(), Str(), etc)
+// this data is public and will be printed/outputted
+func (b *Builder) Extra(key string, val any) *Builder {
+	b.errorData.Extra[key] = val
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
+// 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
+// Can be gloablly configured with ZeroLogErrTraces and ZeroLogAllTraces
+// Can be locally suppressed with Builder.NoLog()
+func (b *Builder) Build(ctxs ...context.Context) error {
+	return b.BuildAsExerr(ctxs...)
+}
+
+func (b *Builder) BuildAsExerr(ctxs ...context.Context) *ExErr {
+	warnOnPkgConfigNotInitialized()
+
+	for _, dctx := range ctxs {
+		b.CtxData(MethodBuild, dctx)
+	}
+
+	if pkgconfig.DisableErrorWrapping && b.wrappedErr != nil {
+		return FromError(b.wrappedErr)
+	}
+
+	if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
+	} else if pkgconfig.ZeroLogAllTraces && !b.noLog {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Error())
+	}
+
+	b.errorData.CallListener(MethodBuild, ListenerOpt{NoLog: b.noLog})
+
+	return b.errorData
+}
+
+// Output prints the error onto the gin stdout.
+// The error also gets printed to stdout/stderr
+// If the error is SevErr|SevFatal we also send it to the error-service
+func (b *Builder) Output(ctx context.Context, g *gin.Context) {
+	warnOnPkgConfigNotInitialized()
+
+	if !b.containsGinData && g.Request != nil {
+		// Auto-Add gin metadata if the caller hasn't already done it
+		b.GinReq(ctx, g, g.Request)
+	}
+
+	b.CtxData(MethodOutput, ctx)
+
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	b.doOutput(ctx, g)
+}
+
+func (b *Builder) doOutput(ctx context.Context, g *gin.Context) {
+	b.errorData.Output(g)
+
+	if (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) && (pkgconfig.ZeroLogErrGinOutput || pkgconfig.ZeroLogAllGinOutput) {
+		b.errorData.Log(pkgconfig.ZeroLogger.Error())
+	} else if (b.errorData.Severity == SevWarn) && (pkgconfig.ZeroLogAllGinOutput) {
+		b.errorData.Log(pkgconfig.ZeroLogger.Warn())
+	}
+
+	b.errorData.CallListener(MethodOutput, ListenerOpt{NoLog: b.noLog})
+}
+
+// Print prints the error
+// If the error is SevErr we also send it to the error-service
+func (b *Builder) Print(ctxs ...context.Context) Proxy {
+	warnOnPkgConfigNotInitialized()
+
+	for _, dctx := range ctxs {
+		b.CtxData(MethodPrint, dctx)
+	}
+
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	return b.doPrint()
+}
+
+func (b *Builder) doPrint() Proxy {
+	if b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal {
+		b.errorData.Log(pkgconfig.ZeroLogger.Error())
+	} else if b.errorData.Severity == SevWarn {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
+	} else if b.errorData.Severity == SevInfo {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
+	} else {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
+	}
+
+	b.errorData.CallListener(MethodPrint, ListenerOpt{NoLog: b.noLog})
+
+	return Proxy{v: *b.errorData} // we return Proxy<Exerr> here instead of Exerr to prevent warnings on ignored err-returns
+}
+
+func (b *Builder) Format(level LogPrintLevel) string {
+	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(ctxs ...context.Context) {
+
+	b.errorData.Severity = SevFatal
+
+	for _, dctx := range ctxs {
+		b.CtxData(MethodFatal, dctx)
+	}
+
+	// this is only here to add one level to the trace
+	// so that .Build() and .Output() and .Print() have the same depth and our stack-skip logger can have the same skip-count
+	b.doLogFatal()
+
+	b.errorData.CallListener(MethodFatal, ListenerOpt{NoLog: b.noLog})
+
+	os.Exit(1)
+}
+
+func (b *Builder) doLogFatal() {
+	b.errorData.Log(pkgconfig.ZeroLogger.WithLevel(zerolog.FatalLevel))
+}
+
+// ----------------------------------------------------------------------------
+
+func (b *Builder) addMeta(key string, mdtype metaDataType, val interface{}) *Builder {
+	b.errorData.Meta.add(key, mdtype, val)
+	return b
+}

exerr/constructor.go

@@ -0,0 +1,274 @@
+package exerr
+
+import (
+	"encoding/json"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"time"
+)
+
+var reflectTypeStr = reflect.TypeOf("")
+
+func FromError(err error) *ExErr {
+
+	if err == nil {
+		// prevent NPE if we call FromError with err==nil
+		return &ExErr{
+			UniqueID:       newID(),
+			Category:       CatForeign,
+			Type:           TypeInternal,
+			Severity:       SevErr,
+			Timestamp:      time.Time{},
+			StatusCode:     nil,
+			Message:        "",
+			WrappedErrType: "nil",
+			WrappedErr:     err,
+			Caller:         "",
+			OriginalError:  nil,
+			Meta:           make(MetaMap),
+			Extra:          make(map[string]any),
+		}
+	}
+
+	//goland:noinspection GoTypeAssertionOnErrors
+	if verr, ok := err.(*ExErr); ok {
+		// A simple ExErr
+		return verr
+	}
+
+	//goland:noinspection GoTypeAssertionOnErrors
+	if verr, ok := err.(langext.PanicWrappedErr); ok {
+		return &ExErr{
+			UniqueID:       newID(),
+			Category:       CatForeign,
+			Type:           TypePanic,
+			Severity:       SevErr,
+			Timestamp:      time.Time{},
+			StatusCode:     nil,
+			Message:        "A panic occured",
+			WrappedErrType: fmt.Sprintf("%T", verr),
+			WrappedErr:     err,
+			Caller:         "",
+			OriginalError:  nil,
+			Meta: MetaMap{
+				"panic_object": {DataType: MDTString, Value: fmt.Sprintf("%+v", verr.RecoveredObj())},
+				"panic_type":   {DataType: MDTString, Value: fmt.Sprintf("%T", verr.RecoveredObj())},
+				"stack":        {DataType: MDTString, Value: verr.Stack},
+			},
+			Extra: make(map[string]any),
+		}
+	}
+
+	//goland:noinspection GoTypeAssertionOnErrors
+	if verr, ok := err.(*langext.PanicWrappedErr); ok && verr != nil {
+		return &ExErr{
+			UniqueID:       newID(),
+			Category:       CatForeign,
+			Type:           TypePanic,
+			Severity:       SevErr,
+			Timestamp:      time.Time{},
+			StatusCode:     nil,
+			Message:        "A panic occured",
+			WrappedErrType: fmt.Sprintf("%T", verr),
+			WrappedErr:     err,
+			Caller:         "",
+			OriginalError:  nil,
+			Meta: MetaMap{
+				"panic_object": {DataType: MDTString, Value: fmt.Sprintf("%+v", verr.RecoveredObj())},
+				"panic_type":   {DataType: MDTString, Value: fmt.Sprintf("%T", verr.RecoveredObj())},
+				"stack":        {DataType: MDTString, Value: verr.Stack},
+			},
+			Extra: make(map[string]any),
+		}
+	}
+
+	// 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),
+		WrappedErr:     err,
+		Caller:         "",
+		OriginalError:  nil,
+		Meta:           getForeignMeta(err),
+		Extra:          make(map[string]any),
+	}
+}
+
+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: "",
+		WrappedErr:     nil,
+		Caller:         callername(2),
+		OriginalError:  nil,
+		Meta:           make(map[string]MetaValue),
+		Extra:          make(map[string]any),
+	}
+}
+
+func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExErr {
+	return &ExErr{
+		UniqueID:       newID(),
+		Category:       cat,
+		Type:           TypeWrap,
+		Severity:       e.Severity,
+		Timestamp:      time.Now(),
+		StatusCode:     e.StatusCode,
+		Message:        msg,
+		WrappedErrType: "",
+		WrappedErr:     nil,
+		Caller:         callername(1 + stacktraceskip),
+		OriginalError:  e,
+		Meta:           make(map[string]MetaValue),
+		Extra:          langext.CopyMap(langext.ForceMap(e.Extra)),
+	}
+}
+
+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 {
+		return map[string]MetaValue{"": {DataType: MDTString, Value: fmt.Sprintf("Failed to Marshal %T:\n%+v", value, value)}}
+	}
+
+	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

@@ -0,0 +1,18 @@
+package exerr
+
+type Method string
+
+const (
+	MethodOutput Method = "OUTPUT"
+	MethodPrint  Method = "PRINT"
+	MethodBuild  Method = "BUILD"
+	MethodFatal  Method = "FATAL"
+)
+
+type LogPrintLevel string
+
+const (
+	LogPrintFull     LogPrintLevel = "Full"
+	LogPrintOverview LogPrintLevel = "Overview"
+	LogPrintShort    LogPrintLevel = "Short"
+)

exerr/dataCategory.go

@@ -0,0 +1,89 @@
+package exerr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"reflect"
+)
+
+type ErrorCategory struct{ Category string }
+
+var (
+	CatWrap    = ErrorCategory{"Wrap"}    // The error is simply wrapping another error (e.g. when a grpc call returns an error)
+	CatSystem  = ErrorCategory{"System"}  // An internal system error (e.g. connection to db failed)
+	CatUser    = ErrorCategory{"User"}    // The user (the API caller) did something wrong (e.g. he has no permissions to do this)
+	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
+)
+
+func (e *ErrorCategory) UnmarshalJSON(bytes []byte) error {
+	return json.Unmarshal(bytes, &e.Category)
+}
+
+func (e ErrorCategory) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.Category)
+}
+
+func (e *ErrorCategory) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+	if bt == bson.TypeNull {
+		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
+		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
+		// https://stackoverflow.com/questions/75167597
+		// https://jira.mongodb.org/browse/GODRIVER-2252
+		*e = ErrorCategory{}
+		return nil
+	}
+	if bt != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	}
+	var tt string
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*e = ErrorCategory{tt}
+	return nil
+}
+
+func (e ErrorCategory) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(e.Category)
+}
+
+func (e ErrorCategory) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return errors.New("ValueUnmarshalerDecodeValue")
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	err = e.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&e))
+	} else {
+		val.Set(reflect.ValueOf(e))
+	}
+
+	return nil
+}
+
+//goland:noinspection GoUnusedGlobalVariable
+var AllCategories = []ErrorCategory{CatWrap, CatSystem, CatUser, CatForeign}

exerr/dataSeverity.go

@@ -0,0 +1,91 @@
+package exerr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"reflect"
+)
+
+type ErrorSeverity struct{ Severity string }
+
+var (
+	SevTrace = ErrorSeverity{"Trace"}
+	SevDebug = ErrorSeverity{"Debug"}
+	SevInfo  = ErrorSeverity{"Info"}
+	SevWarn  = ErrorSeverity{"Warn"}
+	SevErr   = ErrorSeverity{"Err"}
+	SevFatal = ErrorSeverity{"Fatal"}
+)
+
+func (e *ErrorSeverity) UnmarshalJSON(bytes []byte) error {
+	return json.Unmarshal(bytes, &e.Severity)
+}
+
+func (e ErrorSeverity) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.Severity)
+}
+
+func (e *ErrorSeverity) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+	if bt == bson.TypeNull {
+		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
+		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
+		// https://stackoverflow.com/questions/75167597
+		// https://jira.mongodb.org/browse/GODRIVER-2252
+		*e = ErrorSeverity{}
+		return nil
+	}
+	if bt != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	}
+	var tt string
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*e = ErrorSeverity{tt}
+	return nil
+}
+
+func (e ErrorSeverity) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(e.Severity)
+}
+
+func (e ErrorSeverity) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return errors.New("ValueUnmarshalerDecodeValue")
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	err = e.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&e))
+	} else {
+		val.Set(reflect.ValueOf(e))
+	}
+
+	return nil
+}
+
+//goland:noinspection GoUnusedGlobalVariable
+var AllSeverities = []ErrorSeverity{SevTrace, SevDebug, SevInfo, SevWarn, SevErr, SevFatal}

exerr/dataType.go

@@ -0,0 +1,156 @@
+package exerr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"reflect"
+)
+
+type ErrorType struct {
+	Key               string
+	DefaultStatusCode *int
+}
+
+//goland:noinspection GoUnusedGlobalVariable
+var (
+	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
+	TypePanic          = NewType("PANIC", langext.Ptr(500))
+	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
+	TypeAssert         = NewType("ASSERT", langext.Ptr(500))
+
+	TypeMongoQuery        = NewType("MONGO_QUERY", langext.Ptr(500))
+	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500))
+	TypeMongoFilter       = NewType("MONGO_FILTER", langext.Ptr(500))
+	TypeMongoReflection   = NewType("MONGO_REFLECTION", langext.Ptr(500))
+	TypeMongoInvalidOpt   = NewType("MONGO_INVALIDOPT", langext.Ptr(500))
+
+	TypeSQLQuery  = NewType("SQL_QUERY", langext.Ptr(500))
+	TypeSQLBuild  = NewType("SQL_BUILD", langext.Ptr(500))
+	TypeSQLDecode = NewType("SQL_DECODE", langext.Ptr(500))
+
+	TypeWrap = NewType("Wrap", nil)
+
+	TypeBindFailURI      = NewType("BINDFAIL_URI", langext.Ptr(400))
+	TypeBindFailQuery    = NewType("BINDFAIL_QUERY", langext.Ptr(400))
+	TypeBindFailJSON     = NewType("BINDFAIL_JSON", langext.Ptr(400))
+	TypeBindFailFormData = NewType("BINDFAIL_FORMDATA", langext.Ptr(400))
+	TypeBindFailHeader   = NewType("BINDFAIL_HEADER", langext.Ptr(400))
+
+	TypeMarshalEntityID = NewType("MARSHAL_ENTITY_ID", langext.Ptr(400))
+	TypeInvalidCSID     = NewType("INVALID_CSID", langext.Ptr(400))
+
+	TypeGoogleStatuscode = NewType("GOOGLE_STATUSCODE", langext.Ptr(400))
+	TypeGoogleResponse   = NewType("GOOGLE_RESPONSE", langext.Ptr(400))
+
+	TypeUnauthorized = NewType("UNAUTHORIZED", langext.Ptr(401))
+	TypeAuthFailed   = NewType("AUTH_FAILED", langext.Ptr(401))
+
+	TypeInvalidImage    = NewType("IMAGEEXT_INVALID_IMAGE", langext.Ptr(400))
+	TypeInvalidMimeType = NewType("IMAGEEXT_INVALID_MIMETYPE", langext.Ptr(400))
+
+	// other values come from the downstream application that uses goext
+)
+
+func (e *ErrorType) UnmarshalJSON(bytes []byte) error {
+	var k string
+	err := json.Unmarshal(bytes, &k)
+	if err != nil {
+		return err
+	}
+
+	if d, ok := registeredTypes.Get(k); ok {
+		*e = d
+		return nil
+	} else {
+		*e = ErrorType{k, nil}
+		return nil
+	}
+}
+
+func (e ErrorType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.Key)
+}
+
+func (e *ErrorType) UnmarshalBSONValue(bt bsontype.Type, data []byte) error {
+	if bt == bson.TypeNull {
+		// we can't set nil in UnmarshalBSONValue (so we use default(struct))
+		// Use mongoext.CreateGoExtBsonRegistry if you need to unmarsh pointer values
+		// https://stackoverflow.com/questions/75167597
+		// https://jira.mongodb.org/browse/GODRIVER-2252
+		*e = ErrorType{}
+		return nil
+	}
+	if bt != bson.TypeString {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into String", bt))
+	}
+	var tt string
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+
+	if d, ok := registeredTypes.Get(tt); ok {
+		*e = d
+		return nil
+	} else {
+		*e = ErrorType{tt, nil}
+		return nil
+	}
+}
+
+func (e ErrorType) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(e.Key)
+}
+
+func (e ErrorType) DecodeValue(dc bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		if !val.CanSet() {
+			return errors.New("ValueUnmarshalerDecodeValue")
+		}
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+
+	tp, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr && len(src) == 0 {
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	err = e.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&e))
+	} else {
+		val.Set(reflect.ValueOf(e))
+	}
+
+	return nil
+}
+
+var registeredTypes = dataext.SyncMap[string, ErrorType]{}
+
+func NewType(key string, defStatusCode *int) ErrorType {
+	et := ErrorType{key, defStatusCode}
+
+	registeredTypes.Set(key, et)
+
+	return et
+}
+
+func ListRegisteredTypes() []ErrorType {
+	return registeredTypes.GetAllValues()
+}

exerr/data_test.go

@@ -0,0 +1,153 @@
+package exerr
+
+import (
+	"context"
+	"encoding/json"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"testing"
+	"time"
+)
+
+func TestJSONMarshalErrorCategory(t *testing.T) {
+
+	c1 := CatSystem
+
+	jsonbin := tst.Must(json.Marshal(c1))(t)
+
+	var c2 ErrorCategory
+	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
+
+	tst.AssertEqual(t, c1, c2)
+
+	tst.AssertEqual(t, string(jsonbin), "\"System\"")
+}
+
+func TestJSONMarshalErrorSeverity(t *testing.T) {
+
+	c1 := SevErr
+
+	jsonbin := tst.Must(json.Marshal(c1))(t)
+
+	var c2 ErrorSeverity
+	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
+
+	tst.AssertEqual(t, c1, c2)
+
+	tst.AssertEqual(t, string(jsonbin), "\"Err\"")
+}
+
+func TestJSONMarshalErrorType(t *testing.T) {
+
+	c1 := TypeNotImplemented
+
+	jsonbin := tst.Must(json.Marshal(c1))(t)
+
+	var c2 ErrorType
+	tst.AssertNoErr(t, json.Unmarshal(jsonbin, &c2))
+
+	tst.AssertEqual(t, c1, c2)
+
+	tst.AssertEqual(t, string(jsonbin), "\"NOT_IMPLEMENTED\"")
+}
+
+func TestBSONMarshalErrorCategory(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
+	defer cancel()
+
+	client, err := mongo.Connect(ctx)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+	err = client.Ping(ctx, nil)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+
+	primimd := primitive.NewObjectID()
+
+	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": CatSystem})
+	tst.AssertNoErr(t, err)
+
+	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
+
+	var c1 struct {
+		ID  primitive.ObjectID `bson:"_id"`
+		Val ErrorCategory      `bson:"val"`
+	}
+
+	err = cursor.Decode(&c1)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertEqual(t, c1.Val, CatSystem)
+}
+
+func TestBSONMarshalErrorSeverity(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
+	defer cancel()
+
+	client, err := mongo.Connect(ctx)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+	err = client.Ping(ctx, nil)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+
+	primimd := primitive.NewObjectID()
+
+	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": SevErr})
+	tst.AssertNoErr(t, err)
+
+	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
+
+	var c1 struct {
+		ID  primitive.ObjectID `bson:"_id"`
+		Val ErrorSeverity      `bson:"val"`
+	}
+
+	err = cursor.Decode(&c1)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertEqual(t, c1.Val, SevErr)
+}
+
+func TestBSONMarshalErrorType(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 350*time.Millisecond)
+	defer cancel()
+
+	client, err := mongo.Connect(ctx)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+	err = client.Ping(ctx, nil)
+	if err != nil {
+		t.Skip("Skip test - no local mongo found")
+		return
+	}
+
+	primimd := primitive.NewObjectID()
+
+	_, err = client.Database("_test").Collection("goext-cicd").InsertOne(ctx, bson.M{"_id": primimd, "val": TypeNotImplemented})
+	tst.AssertNoErr(t, err)
+
+	cursor := client.Database("_test").Collection("goext-cicd").FindOne(ctx, bson.M{"_id": primimd, "val": bson.M{"$type": "string"}})
+
+	var c1 struct {
+		ID  primitive.ObjectID `bson:"_id"`
+		Val ErrorType          `bson:"val"`
+	}
+
+	err = cursor.Decode(&c1)
+	tst.AssertNoErr(t, err)
+
+	tst.AssertEqual(t, c1.Val, TypeNotImplemented)
+}

exerr/errinit.go

@@ -0,0 +1,138 @@
+package exerr
+
+import (
+	"context"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog"
+	"net/http"
+	"os"
+)
+
+type ErrorPackageConfig struct {
+	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
+	ExtendedGinOutput      bool                                                                     // Log extended data (trace, meta, ...) to gin in err.Output()
+	IncludeMetaInGinOutput bool                                                                     // Log meta fields ( from e.g. `.Str(key, val).Build()` ) 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
+	DisableErrorWrapping   bool                                                                     // Disables the exerr.Wrap()...Build() function - will always return the original error
+	ZeroLogErrGinOutput    bool                                                                     // autom print zerolog logs on ginext.Error() / .Output(gin)  (for SevErr and SevFatal)
+	ZeroLogAllGinOutput    bool                                                                     // autom print zerolog logs on ginext.Error() / .Output(gin)  (for all Severities)
+	ExtendGinMeta          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) // (Optionally) extend the final error meta values with additional data from the gin context (a few are automatically added, here more can be included)
+	ExtendContextMeta      func(b *Builder, method Method, dctx context.Context)                    // (Optionally) extend the final error meta values with additional data from the context (a few are automatically added, here more can be included)
+	ZeroLogger             zerolog.Logger                                                           // The logger used to print exerr log messages
+}
+
+type ErrorPackageConfigInit struct {
+	ZeroLogErrTraces       *bool
+	ZeroLogAllTraces       *bool
+	RecursiveErrors        *bool
+	ExtendedGinOutput      *bool
+	IncludeMetaInGinOutput *bool
+	ExtendGinOutput        func(err *ExErr, json map[string]any)
+	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)
+	DisableErrorWrapping   *bool
+	ZeroLogErrGinOutput    *bool
+	ZeroLogAllGinOutput    *bool
+	ExtendGinMeta          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request)
+	ExtendContextMeta      func(b *Builder, method Method, dctx context.Context)
+	ZeroLogger             *zerolog.Logger
+}
+
+var initialized = false
+
+var pkgconfig = ErrorPackageConfig{
+	ZeroLogErrTraces:       true,
+	ZeroLogAllTraces:       false,
+	RecursiveErrors:        true,
+	ExtendedGinOutput:      false,
+	IncludeMetaInGinOutput: true,
+	ExtendGinOutput:        func(err *ExErr, json map[string]any) {},
+	ExtendGinDataOutput:    func(err *ExErr, depth int, json map[string]any) {},
+	DisableErrorWrapping:   false,
+	ZeroLogErrGinOutput:    true,
+	ZeroLogAllGinOutput:    false,
+	ExtendGinMeta:          func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) {},
+	ExtendContextMeta:      func(b *Builder, method Method, dctx context.Context) {},
+}
+
+// Init initializes the exerr packages
+// Must be called at the program start, before (!) any errors
+// Is not thread-safe
+func Init(cfg ErrorPackageConfigInit) {
+	if initialized {
+		panic("Cannot re-init error package")
+	}
+
+	ego := func(err *ExErr, json map[string]any) {}
+	egdo := func(err *ExErr, depth int, json map[string]any) {}
+	egm := func(ctx context.Context, b *Builder, g *gin.Context, req *http.Request) {}
+	egcm := func(b *Builder, method Method, dctx context.Context) {}
+
+	if cfg.ExtendGinOutput != nil {
+		ego = cfg.ExtendGinOutput
+	}
+	if cfg.ExtendGinDataOutput != nil {
+		egdo = cfg.ExtendGinDataOutput
+	}
+	if cfg.ExtendGinMeta != nil {
+		egm = cfg.ExtendGinMeta
+	}
+	if cfg.ExtendContextMeta != nil {
+		egcm = cfg.ExtendContextMeta
+	}
+
+	var logger zerolog.Logger
+	if cfg.ZeroLogger != nil {
+		logger = *cfg.ZeroLogger
+	} else {
+		logger = newDefaultLogger()
+	}
+
+	pkgconfig = ErrorPackageConfig{
+		ZeroLogErrTraces:       langext.Coalesce(cfg.ZeroLogErrTraces, pkgconfig.ZeroLogErrTraces),
+		ZeroLogAllTraces:       langext.Coalesce(cfg.ZeroLogAllTraces, pkgconfig.ZeroLogAllTraces),
+		RecursiveErrors:        langext.Coalesce(cfg.RecursiveErrors, pkgconfig.RecursiveErrors),
+		ExtendedGinOutput:      langext.Coalesce(cfg.ExtendedGinOutput, pkgconfig.ExtendedGinOutput),
+		IncludeMetaInGinOutput: langext.Coalesce(cfg.IncludeMetaInGinOutput, pkgconfig.IncludeMetaInGinOutput),
+		ExtendGinOutput:        ego,
+		ExtendGinDataOutput:    egdo,
+		DisableErrorWrapping:   langext.Coalesce(cfg.DisableErrorWrapping, pkgconfig.DisableErrorWrapping),
+		ZeroLogAllGinOutput:    langext.Coalesce(cfg.ZeroLogAllGinOutput, pkgconfig.ZeroLogAllGinOutput),
+		ZeroLogErrGinOutput:    langext.Coalesce(cfg.ZeroLogErrGinOutput, pkgconfig.ZeroLogErrGinOutput),
+		ExtendGinMeta:          egm,
+		ExtendContextMeta:      egcm,
+		ZeroLogger:             logger,
+	}
+
+	initialized = true
+}
+
+func newDefaultLogger() zerolog.Logger {
+	cw := zerolog.ConsoleWriter{
+		Out:        os.Stdout,
+		TimeFormat: "2006-01-02 15:04:05 Z07:00",
+	}
+
+	multi := zerolog.MultiLevelWriter(cw)
+
+	return zerolog.New(multi).With().Timestamp().CallerWithSkipFrameCount(5).Logger()
+}
+
+func Initialized() bool {
+	return initialized
+}
+
+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

@@ -0,0 +1,436 @@
+package exerr
+
+import (
+	"fmt"
+	"github.com/rs/xid"
+	"github.com/rs/zerolog"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"strings"
+	"time"
+)
+
+type ExErr struct {
+	UniqueID string `json:"uniqueID"`
+
+	Timestamp time.Time     `json:"timestamp"`
+	Category  ErrorCategory `json:"category"`
+	Severity  ErrorSeverity `json:"severity"`
+	Type      ErrorType     `json:"type"`
+
+	StatusCode *int `json:"statusCode"`
+
+	Message        string `json:"message"`
+	WrappedErrType string `json:"wrappedErrType"`
+	WrappedErr     any    `json:"-"`
+	Caller         string `json:"caller"`
+
+	OriginalError *ExErr `json:"originalError"`
+
+	Extra map[string]any `json:"extra"`
+	Meta  MetaMap        `json:"meta"`
+}
+
+func (ee *ExErr) Error() string {
+	return ee.RecursiveMessage()
+}
+
+// Unwrap must be implemented so that some error.XXX methods work
+func (ee *ExErr) Unwrap() error {
+	if ee.OriginalError == nil {
+
+		if ee.WrappedErr != nil {
+			if werr, ok := ee.WrappedErr.(error); ok {
+				return werr
+			}
+		}
+
+		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))
+}
+
+func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
+
+	// [LogPrintShort]
+	//
+	// - Only print message and type
+	// - Used e.g. for logging to the console when Build is called
+	// - also used in Print() if level == Warn/Info
+	//
+	// [LogPrintOverview]
+	//
+	// - print message, extra and errortrace
+	//
+	// [LogPrintFull]
+	//
+	// - print full error, with meta and extra, and trace, etc
+	// - Used in Output() and Print()
+	//
+
+	if lvl == LogPrintShort {
+
+		msg := ee.Message
+		if msg == "" {
+			msg = ee.RecursiveMessage()
+		}
+		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"
+
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
+		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"
+
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
+		indent := ""
+		for curr := ee; curr != nil; curr = curr.OriginalError {
+			indent += "  "
+
+			etype := curr.Type.Key
+			if curr.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, langext.Ptr(240)).Msg(ee.FormatLog(LogPrintShort))
+}
+
+// RecursiveMessage returns the message to show
+// = first error (top-down) that is not foreign/empty
+// = lowest level error (that is not empty)
+// = fallback to self.message
+func (ee *ExErr) RecursiveMessage() string {
+
+	// ==== [1] ==== first error (top-down) that is not wrapping/foreign/empty
+
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.Message != "" && curr.Category != CatForeign {
+			return curr.Message
+		}
+	}
+
+	// ==== [2] ==== lowest level error (that is not empty)
+
+	deepestMsg := ""
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if curr.Message != "" {
+			deepestMsg = curr.Message
+		}
+	}
+	if deepestMsg != "" {
+		return deepestMsg
+	}
+
+	// ==== [3] ==== fallback to self.message
+
+	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
+}
+
+// Depth returns the depth of recursively contained errors
+func (ee *ExErr) Depth() int {
+	if ee.OriginalError == nil {
+		return 1
+	} else {
+		return ee.OriginalError.Depth() + 1
+	}
+}
+
+// GetMeta returns the meta value with the specified key
+// this method recurses through all wrapped errors and returns the first matching meta value
+func (ee *ExErr) GetMeta(key string) (any, bool) {
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		if v, ok := curr.Meta[key]; ok {
+			return v.Value, true
+		}
+	}
+
+	return nil, false
+}
+
+// GetMetaString functions the same as GetMeta, but returns false if the type does not match
+func (ee *ExErr) GetMetaString(key string) (string, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(string); ok {
+			return v2, true
+		}
+	}
+	return "", false
+}
+
+func (ee *ExErr) GetMetaBool(key string) (bool, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(bool); ok {
+			return v2, true
+		}
+	}
+	return false, false
+}
+
+func (ee *ExErr) GetMetaInt(key string) (int, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(int); ok {
+			return v2, true
+		}
+	}
+	return 0, false
+}
+
+func (ee *ExErr) GetMetaFloat32(key string) (float32, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(float32); ok {
+			return v2, true
+		}
+	}
+	return 0, false
+}
+
+func (ee *ExErr) GetMetaFloat64(key string) (float64, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(float64); ok {
+			return v2, true
+		}
+	}
+	return 0, false
+}
+
+func (ee *ExErr) GetMetaTime(key string) (time.Time, bool) {
+	if v1, ok := ee.GetMeta(key); ok {
+		if v2, ok := v1.(time.Time); ok {
+			return v2, true
+		}
+	}
+	return time.Time{}, false
+}
+
+func (ee *ExErr) GetExtra(key string) (any, bool) {
+	if v, ok := ee.Extra[key]; ok {
+		return v, true
+	}
+
+	return nil, false
+}
+
+func (ee *ExErr) UniqueIDs() []string {
+	ids := make([]string, 0, 1)
+	for curr := ee; curr != nil; curr = curr.OriginalError {
+		ids = append(ids, curr.UniqueID)
+	}
+	return ids
+}
+
+// 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,102 @@
+package exerr
+
+import (
+	"errors"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"os"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	if !Initialized() {
+		Init(ErrorPackageConfigInit{ZeroLogErrTraces: langext.PFalse, ZeroLogAllTraces: langext.PFalse})
+	}
+	os.Exit(m.Run())
+}
+
+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

@@ -0,0 +1,145 @@
+package exerr
+
+import (
+	"github.com/gin-gonic/gin"
+	json "git.blackforestbytes.com/BlackForestBytes/goext/gojson"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"net/http"
+	"time"
+)
+
+func (ee *ExErr) toJson(depth int, applyExtendListener bool, outputMeta bool) langext.H {
+	ginJson := langext.H{}
+
+	if ee.UniqueID != "" {
+		ginJson["id"] = ee.UniqueID
+	}
+	if ee.Category != CatWrap {
+		ginJson["category"] = ee.Category.Category
+	}
+	if ee.Type != TypeWrap {
+		ginJson["type"] = ee.Type.Key
+	}
+	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.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, outputMeta)
+	}
+
+	if outputMeta {
+		metaJson := langext.H{}
+		for metaKey, metaVal := range ee.Meta {
+			metaJson[metaKey] = metaVal.rawValueForJson()
+		}
+		ginJson["meta"] = metaJson
+
+		extraJson := langext.H{}
+		for extraKey, extraVal := range ee.Extra {
+			extraJson[extraKey] = extraVal
+		}
+		ginJson["extra"] = extraJson
+	}
+
+	if applyExtendListener {
+		pkgconfig.ExtendGinDataOutput(ee, depth, ginJson)
+	}
+
+	return ginJson
+}
+
+func (ee *ExErr) ToDefaultAPIJson() (string, error) {
+
+	gjr := json.GoJsonRender{Data: ee.ToAPIJson(true, pkgconfig.ExtendedGinOutput, pkgconfig.IncludeMetaInGinOutput), NilSafeSlices: true, NilSafeMaps: true}
+
+	r, err := gjr.RenderString()
+
+	if err != nil {
+		return "", err
+	}
+
+	return r, nil
+}
+
+// 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`
+//   - [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,
+		"message":   ee.RecursiveMessage(),
+		"errorcode": ee.RecursiveType().Key,
+		"category":  ee.RecursiveCategory().Category,
+	}
+
+	if includeWrappedErrors {
+		apiOutput["__data"] = ee.toJson(0, applyExtendListener, includeMetaFields)
+	}
+
+	for exkey, exval := range ee.Extra {
+
+		// ensure we do not override existing values
+		for {
+			if _, ok := apiOutput[exkey]; ok {
+				exkey = "_" + exkey
+			} else {
+				break
+			}
+		}
+
+		apiOutput[exkey] = exval
+	}
+
+	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, pkgconfig.IncludeMetaInGinOutput)
+
+	g.Render(statuscode, json.GoJsonRender{Data: ginOutput, NilSafeSlices: true, NilSafeMaps: true})
+}

exerr/helper.go

@@ -0,0 +1,126 @@
+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
+	}
+
+	//goland:noinspection GoDirectComparisonOfErrors
+	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
+}
+
+// OriginalError returns the lowest level error, probably the original/external error that was originally wrapped
+func OriginalError(e error) error {
+	if e == nil {
+		return nil
+	}
+
+	//goland:noinspection GoTypeAssertionOnErrors
+	bmerr, ok := e.(*ExErr)
+	for !ok {
+		return e
+	}
+
+	for bmerr.OriginalError != nil {
+		bmerr = bmerr.OriginalError
+	}
+
+	if bmerr.WrappedErr != nil {
+		if werr, ok := bmerr.WrappedErr.(error); ok {
+			return werr
+		}
+	}
+
+	return bmerr
+}
+
+func UniqueID(v error) *string {
+	if v == nil {
+		return nil
+	}
+
+	//goland:noinspection GoTypeAssertionOnErrors
+	if verr, ok := v.(*ExErr); ok {
+		return &verr.UniqueID
+	}
+
+	return nil
+}

exerr/listener.go

@@ -0,0 +1,30 @@
+package exerr
+
+import (
+	"sync"
+)
+
+type ListenerOpt struct {
+	NoLog bool
+}
+
+type Listener = func(method Method, v *ExErr, opt ListenerOpt)
+
+var listenerLock = sync.Mutex{}
+var listener = make([]Listener, 0)
+
+func RegisterListener(l Listener) {
+	listenerLock.Lock()
+	defer listenerLock.Unlock()
+
+	listener = append(listener, l)
+}
+
+func (ee *ExErr) CallListener(m Method, opt ListenerOpt) {
+	listenerLock.Lock()
+	defer listenerLock.Unlock()
+
+	for _, v := range listener {
+		v(m, ee, opt)
+	}
+}

exerr/meta.go

@@ -0,0 +1,762 @@
+package exerr
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"github.com/rs/zerolog"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"math"
+	"strconv"
+	"strings"
+	"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
+
+const (
+	MDTString      metaDataType = "String"
+	MDTStringPtr   metaDataType = "StringPtr"
+	MDTInt         metaDataType = "Int"
+	MDTInt8        metaDataType = "Int8"
+	MDTInt16       metaDataType = "Int16"
+	MDTInt32       metaDataType = "Int32"
+	MDTInt64       metaDataType = "Int64"
+	MDTFloat32     metaDataType = "Float32"
+	MDTFloat64     metaDataType = "Float64"
+	MDTBool        metaDataType = "Bool"
+	MDTBytes       metaDataType = "Bytes"
+	MDTObjectID    metaDataType = "ObjectID"
+	MDTTime        metaDataType = "Time"
+	MDTDuration    metaDataType = "Duration"
+	MDTStringArray metaDataType = "StringArr"
+	MDTIntArray    metaDataType = "IntArr"
+	MDTInt32Array  metaDataType = "Int32Arr"
+	MDTID          metaDataType = "ID"
+	MDTAny         metaDataType = "Interface"
+	MDTNil         metaDataType = "Nil"
+	MDTEnum        metaDataType = "Enum"
+)
+
+type MetaValue struct {
+	DataType metaDataType `json:"dataType"`
+	Value    interface{}  `json:"value"`
+}
+
+type metaValueSerialization struct {
+	DataType metaDataType `bson:"dataType"`
+	Value    string       `bson:"value"`
+	Raw      interface{}  `bson:"raw"`
+}
+
+func (v MetaValue) SerializeValue() (string, error) {
+	switch v.DataType {
+	case MDTString:
+		return v.Value.(string), nil
+	case MDTID:
+		return v.Value.(IDWrap).Serialize(), nil
+	case MDTAny:
+		return v.Value.(AnyWrap).Serialize(), nil
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r := v.Value.(*string)
+		if r != nil {
+			return "*" + *r, nil
+		} else {
+			return "#", nil
+		}
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int)), nil
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10), nil
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10), nil
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10), nil
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10), nil
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'X', -1, 32), nil
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'X', -1, 64), nil
+	case MDTBool:
+		if v.Value.(bool) {
+			return "true", nil
+		} else {
+			return "false", nil
+		}
+	case MDTBytes:
+		return hex.EncodeToString(v.Value.([]byte)), nil
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex(), nil
+	case MDTTime:
+		return strconv.FormatInt(v.Value.(time.Time).Unix(), 10) + "|" + strconv.FormatInt(int64(v.Value.(time.Time).Nanosecond()), 10), nil
+	case MDTDuration:
+		return v.Value.(time.Duration).String(), nil
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]string))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]int))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "#", nil
+		}
+		r, err := json.Marshal(v.Value.([]int32))
+		if err != nil {
+			return "", err
+		}
+		return string(r), nil
+	case MDTNil:
+		return "", nil
+	case MDTEnum:
+		return v.Value.(EnumWrap).Serialize(), nil
+	}
+	return "", errors.New("Unknown type: " + string(v.DataType))
+}
+
+func (v MetaValue) ShortString(lim int) string {
+	switch v.DataType {
+	case MDTString:
+		r := strings.ReplaceAll(v.Value.(string), "\r", "")
+		r = strings.ReplaceAll(r, "\n", "\\n")
+		r = strings.ReplaceAll(r, "\t", "\\t")
+		return langext.StrLimit(r, lim, "...")
+	case MDTID:
+		return v.Value.(IDWrap).String()
+	case MDTAny:
+		return v.Value.(AnyWrap).String()
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r := langext.CoalesceString(v.Value.(*string), "<<null>>")
+		r = strings.ReplaceAll(r, "\r", "")
+		r = strings.ReplaceAll(r, "\n", "\\n")
+		r = strings.ReplaceAll(r, "\t", "\\t")
+		return langext.StrLimit(r, lim, "...")
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int))
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10)
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10)
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10)
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10)
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'g', 4, 32)
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'g', 4, 64)
+	case MDTBool:
+		return fmt.Sprintf("%v", v.Value.(bool))
+	case MDTBytes:
+		return langext.StrLimit(hex.EncodeToString(v.Value.([]byte)), lim, "...")
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex()
+	case MDTTime:
+		return v.Value.(time.Time).Format(time.RFC3339)
+	case MDTDuration:
+		return v.Value.(time.Duration).String()
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]string))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]int))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.Marshal(v.Value.([]int32))
+		if err != nil {
+			return "(err)"
+		}
+		return langext.StrLimit(string(r), lim, "...")
+	case MDTNil:
+		return "<<null>>"
+	case MDTEnum:
+		return v.Value.(EnumWrap).String()
+	}
+	return "(err)"
+}
+
+func (v MetaValue) Apply(key string, evt *zerolog.Event, limitLen *int) *zerolog.Event {
+	switch v.DataType {
+	case MDTString:
+		if limitLen == nil {
+			return evt.Str(key, v.Value.(string))
+		} else {
+			return evt.Str(key, langext.StrLimit(v.Value.(string), *limitLen, "..."))
+		}
+	case MDTID:
+		return evt.Str(key, v.Value.(IDWrap).Value)
+	case MDTAny:
+		if v.Value.(AnyWrap).IsError {
+			return evt.Str(key, "(err)")
+		} else {
+			if limitLen == nil {
+				return evt.Str(key, v.Value.(AnyWrap).Json)
+			} else {
+				return evt.Str(key, langext.StrLimit(v.Value.(AnyWrap).Json, *limitLen, "..."))
+			}
+		}
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return evt.Str(key, "<<null>>")
+		}
+		if limitLen == nil {
+			return evt.Str(key, langext.CoalesceString(v.Value.(*string), "<<null>>"))
+		} else {
+			return evt.Str(key, langext.StrLimit(langext.CoalesceString(v.Value.(*string), "<<null>>"), *limitLen, "..."))
+		}
+	case MDTInt:
+		return evt.Int(key, v.Value.(int))
+	case MDTInt8:
+		return evt.Int8(key, v.Value.(int8))
+	case MDTInt16:
+		return evt.Int16(key, v.Value.(int16))
+	case MDTInt32:
+		return evt.Int32(key, v.Value.(int32))
+	case MDTInt64:
+		return evt.Int64(key, v.Value.(int64))
+	case MDTFloat32:
+		return evt.Float32(key, v.Value.(float32))
+	case MDTFloat64:
+		return evt.Float64(key, v.Value.(float64))
+	case MDTBool:
+		return evt.Bool(key, v.Value.(bool))
+	case MDTBytes:
+		return evt.Bytes(key, v.Value.([]byte))
+	case MDTObjectID:
+		return evt.Str(key, v.Value.(primitive.ObjectID).Hex())
+	case MDTTime:
+		return evt.Time(key, v.Value.(time.Time))
+	case MDTDuration:
+		return evt.Dur(key, v.Value.(time.Duration))
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return evt.Strs(key, nil)
+		}
+		return evt.Strs(key, v.Value.([]string))
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return evt.Ints(key, nil)
+		}
+		return evt.Ints(key, v.Value.([]int))
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return evt.Ints32(key, nil)
+		}
+		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)")
+}
+
+func (v MetaValue) MarshalJSON() ([]byte, error) {
+	str, err := v.SerializeValue()
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(string(v.DataType) + ":" + str)
+}
+
+func (v *MetaValue) UnmarshalJSON(data []byte) error {
+	var str = ""
+	err := json.Unmarshal(data, &str)
+	if err != nil {
+		return err
+	}
+
+	split := strings.SplitN(str, ":", 2)
+	if len(split) != 2 {
+		return errors.New("failed to decode MetaValue: '" + str + "'")
+	}
+
+	return v.Deserialize(split[1], metaDataType(split[0]))
+}
+
+func (v MetaValue) MarshalBSON() ([]byte, error) {
+	serval, err := v.SerializeValue()
+	if err != nil {
+		return nil, Wrap(err, "failed to bson-marshal MetaValue (serialize)").Build()
+	}
+
+	// this is an kinda ugly hack - but serialization to mongodb and back can loose the correct type information....
+	bin, err := bson.Marshal(metaValueSerialization{
+		DataType: v.DataType,
+		Value:    serval,
+		Raw:      v.Value,
+	})
+	if err != nil {
+		return nil, Wrap(err, "failed to bson-marshal MetaValue (marshal)").Build()
+	}
+
+	return bin, nil
+}
+
+func (v *MetaValue) UnmarshalBSON(bytes []byte) error {
+	var serval metaValueSerialization
+	err := bson.Unmarshal(bytes, &serval)
+	if err != nil {
+		return Wrap(err, "failed to bson-unmarshal MetaValue (unmarshal)").Build()
+	}
+
+	err = v.Deserialize(serval.Value, serval.DataType)
+	if err != nil {
+		return Wrap(err, "failed to deserialize MetaValue from bson").Str("raw", serval.Value).Build()
+	}
+
+	return nil
+}
+
+func (v *MetaValue) Deserialize(value string, datatype metaDataType) error {
+	switch datatype {
+	case MDTString:
+		v.Value = value
+		v.DataType = datatype
+		return nil
+	case MDTID:
+		v.Value = deserializeIDWrap(value)
+		v.DataType = datatype
+		return nil
+	case MDTAny:
+		v.Value = deserializeAnyWrap(value)
+		v.DataType = datatype
+		return nil
+	case MDTStringPtr:
+		if len(value) <= 0 || (value[0] != '*' && value[0] != '#') {
+			return errors.New("Invalid StringPtr: " + value)
+		} else if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		} else {
+			v.Value = langext.Ptr(value[1:])
+			v.DataType = datatype
+			return nil
+		}
+	case MDTInt:
+		pv, err := strconv.ParseInt(value, 10, 0)
+		if err != nil {
+			return err
+		}
+		v.Value = int(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt8:
+		pv, err := strconv.ParseInt(value, 10, 8)
+		if err != nil {
+			return err
+		}
+		v.Value = int8(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt16:
+		pv, err := strconv.ParseInt(value, 10, 16)
+		if err != nil {
+			return err
+		}
+		v.Value = int16(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt32:
+		pv, err := strconv.ParseInt(value, 10, 32)
+		if err != nil {
+			return err
+		}
+		v.Value = int32(pv)
+		v.DataType = datatype
+		return nil
+	case MDTInt64:
+		pv, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = pv
+		v.DataType = datatype
+		return nil
+	case MDTFloat32:
+		pv, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = float32(pv)
+		v.DataType = datatype
+		return nil
+	case MDTFloat64:
+		pv, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		v.Value = pv
+		v.DataType = datatype
+		return nil
+	case MDTBool:
+		if value == "true" {
+			v.Value = true
+			v.DataType = datatype
+			return nil
+		}
+		if value == "false" {
+			v.Value = false
+			v.DataType = datatype
+			return nil
+		}
+		return errors.New("invalid bool value: " + value)
+	case MDTBytes:
+		r, err := hex.DecodeString(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTObjectID:
+		r, err := primitive.ObjectIDFromHex(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTTime:
+		ps := strings.Split(value, "|")
+		if len(ps) != 2 {
+			return errors.New("invalid time.time: " + value)
+		}
+		p1, err := strconv.ParseInt(ps[0], 10, 64)
+		if err != nil {
+			return err
+		}
+		p2, err := strconv.ParseInt(ps[1], 10, 32)
+		if err != nil {
+			return err
+		}
+		v.Value = time.Unix(p1, p2)
+		v.DataType = datatype
+		return nil
+	case MDTDuration:
+		r, err := time.ParseDuration(value)
+		if err != nil {
+			return err
+		}
+		v.Value = r
+		v.DataType = datatype
+		return nil
+	case MDTStringArray:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]string, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTIntArray:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]int, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTInt32Array:
+		if value == "#" {
+			v.Value = nil
+			v.DataType = datatype
+			return nil
+		}
+		pj := make([]int32, 0)
+		err := json.Unmarshal([]byte(value), &pj)
+		if err != nil {
+			return err
+		}
+		v.Value = pj
+		v.DataType = datatype
+		return nil
+	case MDTNil:
+		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))
+}
+
+func (v MetaValue) ValueString() string {
+	switch v.DataType {
+	case MDTString:
+		return v.Value.(string)
+	case MDTID:
+		return v.Value.(IDWrap).String()
+	case MDTAny:
+		return v.Value.(AnyWrap).String()
+	case MDTStringPtr:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		return langext.CoalesceString(v.Value.(*string), "<<null>>")
+	case MDTInt:
+		return strconv.Itoa(v.Value.(int))
+	case MDTInt8:
+		return strconv.FormatInt(int64(v.Value.(int8)), 10)
+	case MDTInt16:
+		return strconv.FormatInt(int64(v.Value.(int16)), 10)
+	case MDTInt32:
+		return strconv.FormatInt(int64(v.Value.(int32)), 10)
+	case MDTInt64:
+		return strconv.FormatInt(v.Value.(int64), 10)
+	case MDTFloat32:
+		return strconv.FormatFloat(float64(v.Value.(float32)), 'g', 4, 32)
+	case MDTFloat64:
+		return strconv.FormatFloat(v.Value.(float64), 'g', 4, 64)
+	case MDTBool:
+		return fmt.Sprintf("%v", v.Value.(bool))
+	case MDTBytes:
+		return hex.EncodeToString(v.Value.([]byte))
+	case MDTObjectID:
+		return v.Value.(primitive.ObjectID).Hex()
+	case MDTTime:
+		return v.Value.(time.Time).Format(time.RFC3339Nano)
+	case MDTDuration:
+		return v.Value.(time.Duration).String()
+	case MDTStringArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]string), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		return string(r)
+	case MDTIntArray:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]int), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		return string(r)
+	case MDTInt32Array:
+		if langext.IsNil(v.Value) {
+			return "<<null>>"
+		}
+		r, err := json.MarshalIndent(v.Value.([]int32), "", "  ")
+		if err != nil {
+			return "(err)"
+		}
+		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
+		}
+		if v.Value.(AnyWrap).IsError {
+			return bson.M{"@error": true}
+		}
+		jsonobj := primitive.M{}
+		jsonarr := primitive.A{}
+		if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonobj); err == nil {
+			return jsonobj
+		} else if err := json.Unmarshal([]byte(v.Value.(AnyWrap).Json), &jsonarr); err == nil {
+			return jsonarr
+		} else {
+			return bson.M{"type": v.Value.(AnyWrap).Type, "data": v.Value.(AnyWrap).Json}
+		}
+	}
+	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
+	}
+	if v.DataType == MDTFloat32 {
+		if math.IsNaN(float64(v.Value.(float32))) {
+			return "float64::NaN"
+		} else if math.IsInf(float64(v.Value.(float32)), +1) {
+			return "float64::+inf"
+		} else if math.IsInf(float64(v.Value.(float32)), -1) {
+			return "float64::-inf"
+		} else {
+			return v.Value
+		}
+	}
+	if v.DataType == MDTFloat64 {
+		if math.IsNaN(v.Value.(float64)) {
+			return "float64::NaN"
+		} else if math.IsInf(v.Value.(float64), +1) {
+			return "float64::+inf"
+		} else if math.IsInf(v.Value.(float64), -1) {
+			return "float64::-inf"
+		} else {
+			return v.Value
+		}
+	}
+	return v.Value
+}
+
+func (mm MetaMap) FormatOneLine(singleMaxLen int) string {
+	r := ""
+
+	i := 0
+	for key, val := range mm {
+		if i > 0 {
+			r += ", "
+		}
+
+		r += "\"" + key + "\""
+		r += ": "
+		r += "\"" + val.ShortString(singleMaxLen) + "\""
+
+		i++
+	}
+
+	return r
+}
+
+func (mm MetaMap) FormatMultiLine(indentFront string, indentKeys string, maxLenValue int) string {
+	r := ""
+
+	r += indentFront + "{" + "\n"
+	for key, val := range mm {
+		if key == "gin.body" {
+			continue
+		}
+		if key == "gin_body" {
+			continue
+		}
+
+		r += indentFront
+		r += indentKeys
+		r += "\"" + key + "\""
+		r += ": "
+		r += "\"" + val.ShortString(maxLenValue) + "\""
+		r += ",\n"
+	}
+	r += indentFront + "}"
+
+	return r
+}
+
+func (mm MetaMap) Any() bool {
+	return len(mm) > 0
+}
+
+func (mm MetaMap) Apply(evt *zerolog.Event, limitLen *int) *zerolog.Event {
+	for key, val := range mm {
+		evt = val.Apply(key, evt, limitLen)
+	}
+	return evt
+}
+
+func (mm MetaMap) add(key string, mdtype metaDataType, val interface{}) {
+	if _, ok := mm[key]; !ok {
+		mm[key] = MetaValue{DataType: mdtype, Value: val}
+		return
+	}
+	for i := 2; ; i++ {
+		realkey := key + "-" + strconv.Itoa(i)
+		if _, ok := mm[realkey]; !ok {
+			mm[realkey] = MetaValue{DataType: mdtype, Value: val}
+			return
+		}
+	}
+}

exerr/proxy.go

@@ -0,0 +1,13 @@
+package exerr
+
+type Proxy struct {
+	v ExErr
+}
+
+func (p *Proxy) UniqueID() string {
+	return p.v.UniqueID
+}
+
+func (p *Proxy) Get() ExErr {
+	return p.v
+}

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)
+}

exerr/typeWrapper.go

@@ -0,0 +1,189 @@
+package exerr
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog/log"
+	"git.blackforestbytes.com/BlackForestBytes/goext/enums"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"strings"
+)
+
+//
+// These are wrapper objects, because for some metadata-types we need to serialize a bit more complex data
+// (eg thy actual type for ID objects, or the json representation for any types)
+//
+
+type IDWrap struct {
+	Type  string
+	Value string
+	IsNil bool
+}
+
+func newIDWrap(val fmt.Stringer) IDWrap {
+	t := fmt.Sprintf("%T", val)
+	arr := strings.Split(t, ".")
+	if len(arr) > 0 {
+		t = arr[len(arr)-1]
+	}
+
+	if langext.IsNil(val) {
+		return IDWrap{Type: t, Value: "", IsNil: true}
+	}
+
+	v := val.String()
+	return IDWrap{Type: t, Value: v, IsNil: false}
+}
+
+func (w IDWrap) Serialize() string {
+	if w.IsNil {
+		return "!nil" + ":" + w.Type
+	}
+	return w.Type + ":" + w.Value
+}
+
+func (w IDWrap) String() string {
+	if w.IsNil {
+		return w.Type + "<<nil>>"
+	}
+	return w.Type + "(" + w.Value + ")"
+}
+
+func deserializeIDWrap(v string) IDWrap {
+	r := strings.SplitN(v, ":", 2)
+
+	if len(r) == 2 && r[0] == "!nil" {
+		return IDWrap{Type: r[1], Value: v, IsNil: true}
+	}
+
+	if len(r) == 0 {
+		return IDWrap{}
+	} else if len(r) == 1 {
+		return IDWrap{Type: "", Value: v, IsNil: false}
+	} else {
+		return IDWrap{Type: r[0], Value: r[1], IsNil: false}
+	}
+}
+
+type AnyWrap struct {
+	Type    string
+	Json    string
+	IsError bool
+	IsNil   bool
+}
+
+func newAnyWrap(val any) (result AnyWrap) {
+	result = AnyWrap{Type: "", Json: "", IsError: true, IsNil: false} // ensure a return in case of recover()
+
+	defer func() {
+		if err := recover(); err != nil {
+			// send error should never crash our program
+			log.Error().Interface("err", err).Msg("Panic while trying to marshal anywrap ( bmerror.Interface )")
+		}
+	}()
+
+	t := fmt.Sprintf("%T", val)
+
+	if langext.IsNil(val) {
+		return AnyWrap{Type: t, Json: "", IsError: false, IsNil: true}
+	}
+
+	j, err := json.Marshal(val)
+	if err == nil {
+		return AnyWrap{Type: t, Json: string(j), IsError: false, IsNil: false}
+	} else {
+		return AnyWrap{Type: t, Json: "", IsError: true, IsNil: false}
+	}
+}
+
+func (w AnyWrap) Serialize() string {
+	if w.IsError {
+		return "ERR" + ":" + w.Type + ":" + w.Json
+	} else if w.IsNil {
+		return "NIL" + ":" + w.Type + ":" + w.Json
+	} else {
+		return "OK" + ":" + w.Type + ":" + w.Json
+	}
+}
+
+func (w AnyWrap) String() string {
+	if w.IsError {
+		return "(error)"
+	} else if w.IsNil {
+		return "(nil)"
+	} else {
+		return w.Json
+	}
+}
+
+func deserializeAnyWrap(v string) AnyWrap {
+	r := strings.SplitN(v, ":", 3)
+	if len(r) != 3 {
+		return AnyWrap{IsError: true, Type: "", Json: "", IsNil: false}
+	} else {
+		if r[0] == "OK" {
+			return AnyWrap{IsError: false, Type: r[1], Json: r[2], IsNil: false}
+		} else if r[0] == "ERR" {
+			return AnyWrap{IsError: true, Type: r[1], Json: r[2], IsNil: false}
+		} else if r[0] == "NIL" {
+			return AnyWrap{IsError: false, Type: r[1], Json: "", IsNil: true}
+		} else {
+			return AnyWrap{IsError: true, Type: "", Json: "", IsNil: false}
+		}
+	}
+}
+
+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}
+	}
+}

fsext/exists.go

@@ -0,0 +1,36 @@
+package fsext
+
+import "os"
+
+func PathExists(fp string) (bool, error) {
+	_, err := os.Stat(fp)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}
+
+func FileExists(fp string) (bool, error) {
+	stat, err := os.Stat(fp)
+	if err == nil {
+		return !stat.IsDir(), nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}
+
+func DirectoryExists(fp string) (bool, error) {
+	stat, err := os.Stat(fp)
+	if err == nil {
+		return stat.IsDir(), nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}

ginext/appContext.go

@@ -0,0 +1,68 @@
+package ginext
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+type AppContext struct {
+	inner      context.Context
+	cancelFunc context.CancelFunc
+	cancelled  bool
+	GinContext *gin.Context
+}
+
+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,
+		cancelled:  false,
+		GinContext: g,
+	}
+}
+
+func CreateBackgroundAppContext() *AppContext {
+	return &AppContext{
+		inner:      context.Background(),
+		cancelFunc: nil,
+		cancelled:  false,
+		GinContext: nil,
+	}
+}
+
+func (ac *AppContext) Deadline() (deadline time.Time, ok bool) {
+	return ac.inner.Deadline()
+}
+
+func (ac *AppContext) Done() <-chan struct{} {
+	return ac.inner.Done()
+}
+
+func (ac *AppContext) Err() error {
+	return ac.inner.Err()
+}
+
+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()
+}
+
+func (ac *AppContext) RequestURI() string {
+	if ac.GinContext != nil && ac.GinContext.Request != nil {
+		return ac.GinContext.Request.Method + " :: " + ac.GinContext.Request.RequestURI
+	} else {
+		return ""
+	}
+}

ginext/commonHandler.go

@@ -0,0 +1,23 @@
+package ginext
+
+import (
+	"net/http"
+)
+
+func RedirectFound(newuri string) WHandlerFunc {
+	return func(pctx PreContext) HTTPResponse {
+		return Redirect(http.StatusFound, newuri)
+	}
+}
+
+func RedirectTemporary(newuri string) WHandlerFunc {
+	return func(pctx PreContext) HTTPResponse {
+		return Redirect(http.StatusTemporaryRedirect, newuri)
+	}
+}
+
+func RedirectPermanent(newuri string) WHandlerFunc {
+	return func(pctx PreContext) HTTPResponse {
+		return Redirect(http.StatusPermanentRedirect, newuri)
+	}
+}

ginext/commonMiddlewares.go

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

ginext/cors.go

@@ -0,0 +1,25 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func CorsMiddleware(allowheader []string, exposeheader []string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", strings.Join(allowheader, ", "))
+		if len(exposeheader) > 0 {
+			c.Writer.Header().Set("Access-Control-Expose-Headers", strings.Join(exposeheader, ", "))
+		}
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE, COUNT")
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(http.StatusOK)
+		} else {
+			c.Next()
+		}
+	}
+}

ginext/engine.go

@@ -0,0 +1,238 @@
+package ginext
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog/log"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/mathext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/rext"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strings"
+	"time"
+)
+
+type GinWrapper struct {
+	engine          *gin.Engine
+	suppressGinLogs bool
+
+	opt                   Options
+	allowCors             bool
+	corsAllowHeader       []string
+	corsExposeHeader      []string
+	ginDebug              bool
+	bufferBody            bool
+	requestTimeout        time.Duration
+	listenerBeforeRequest []func(g *gin.Context)
+	listenerAfterRequest  []func(g *gin.Context, resp HTTPResponse)
+
+	buildRequestBindError func(g *gin.Context, fieldtype string, err error) HTTPResponse
+
+	routeSpecs []ginRouteSpec
+}
+
+type ginRouteSpec struct {
+	Method      string
+	URL         string
+	Middlewares []string
+	Handler     string
+}
+
+type Options struct {
+	AllowCors                *bool                                                          // Add cors handler to allow all CORS requests on the default http methods
+	CorsAllowHeader          *[]string                                                      // override the default values of Access-Control-Allow-Headers (AllowCors must be true)
+	CorsExposeHeader         *[]string                                                      // return Access-Control-Expose-Headers (AllowCors must be true)
+	GinDebug                 *bool                                                          // Set gin.debug to true (adds more logs)
+	SuppressGinLogs          *bool                                                          // Suppress our custom gin logs (even if GinDebug == true)
+	BufferBody               *bool                                                          // Buffers the input body stream, this way the ginext error handler can later include the whole request body
+	Timeout                  *time.Duration                                                 // The default handler timeout
+	ListenerBeforeRequest    []func(g *gin.Context)                                         // Register listener that are called before the handler method
+	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse)                      // Register listener that are called after the handler method
+	DebugTrimHandlerPrefixes []string                                                       // Trim these prefixes from the handler names in the debug print
+	DebugReplaceHandlerNames map[string]string                                              // Replace handler names in debug output
+	BuildRequestBindError    func(g *gin.Context, fieldtype string, err error) HTTPResponse // Override function which generates the HTTPResponse errors that are returned by the preContext..Start() methids
+}
+
+// NewEngine creates a new (wrapped) ginEngine
+func NewEngine(opt Options) *GinWrapper {
+	ginDebug := langext.Coalesce(opt.GinDebug, true)
+	if ginDebug {
+		gin.SetMode(gin.DebugMode)
+
+		// do not debug-print routes
+		gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
+
+	} else {
+		gin.SetMode(gin.ReleaseMode)
+
+		// do not debug-print routes
+		gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
+	}
+
+	engine := gin.New()
+
+	wrapper := &GinWrapper{
+		engine:                engine,
+		opt:                   opt,
+		suppressGinLogs:       langext.Coalesce(opt.SuppressGinLogs, false),
+		allowCors:             langext.Coalesce(opt.AllowCors, false),
+		corsAllowHeader:       langext.Coalesce(opt.CorsAllowHeader, []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization", "accept", "origin", "Cache-Control", "X-Requested-With"}),
+		corsExposeHeader:      langext.Coalesce(opt.CorsExposeHeader, []string{}),
+		ginDebug:              ginDebug,
+		bufferBody:            langext.Coalesce(opt.BufferBody, false),
+		requestTimeout:        langext.Coalesce(opt.Timeout, 24*time.Hour),
+		listenerBeforeRequest: opt.ListenerBeforeRequest,
+		listenerAfterRequest:  opt.ListenerAfterRequest,
+		buildRequestBindError: langext.Conditional(opt.BuildRequestBindError == nil, defaultBuildRequestBindError, opt.BuildRequestBindError),
+	}
+
+	engine.RedirectFixedPath = false
+	engine.RedirectTrailingSlash = false
+
+	if wrapper.allowCors {
+		engine.Use(CorsMiddleware(wrapper.corsAllowHeader, wrapper.corsExposeHeader))
+	}
+
+	if ginDebug && !wrapper.suppressGinLogs {
+		ginlogger := gin.Logger()
+		engine.Use(func(context *gin.Context) { ginlogger(context) })
+	}
+	return wrapper
+}
+
+func (w *GinWrapper) ListenAndServeHTTP(addr string, postInit func(port string)) (chan error, *http.Server) {
+
+	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(langext.ArrMap(spec.Middlewares, w.cleanMiddlewareName), " -> "),
+			w.cleanMiddlewareName(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]))
+	}
+
+	fmt.Printf("Gin-Routes:\n")
+	fmt.Printf("{\n")
+	for _, line := range lines {
+
+		fmt.Printf(" %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]))
+	}
+	fmt.Printf("}\n")
+}
+
+func (w *GinWrapper) cleanMiddlewareName(fname string) string {
+
+	funcSuffix := rext.W(regexp.MustCompile(`\.func[0-9]+(?:\.[0-9]+)*$`))
+	if match, ok := funcSuffix.MatchFirst(fname); ok {
+		fname = fname[:len(fname)-match.FullMatch().Length()]
+	}
+
+	if strings.HasSuffix(fname, ".(*GinRoutesWrapper).WithJSONFilter") {
+		fname = "[JSONFilter]"
+	}
+
+	if fname == "ginext.BodyBuffer" {
+		fname = "[BodyBuffer]"
+	}
+
+	skipPrefixes := []string{"api.(*Handler).", "api.", "ginext.", "handler.", "admin-app.", "employee-app.", "employer-app."}
+	for _, pfx := range skipPrefixes {
+		if strings.HasPrefix(fname, pfx) {
+			fname = fname[len(pfx):]
+		}
+	}
+
+	for _, pfx := range w.opt.DebugTrimHandlerPrefixes {
+		if strings.HasPrefix(fname, pfx) {
+			fname = fname[len(pfx):]
+		}
+	}
+
+	for k, v := range langext.ForceMap(w.opt.DebugReplaceHandlerNames) {
+		if strings.EqualFold(fname, k) {
+			fname = v
+		}
+	}
+
+	return fname
+}
+
+// ServeHTTP only used for unit tests
+func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
+	respRec := httptest.NewRecorder()
+	w.engine.ServeHTTP(respRec, req)
+	return respRec
+}
+
+// ForwardRequest manually inserts a request into this router
+// = behaves as if the request came from the outside (and writes the response to `writer`)
+func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
+	w.engine.ServeHTTP(writer, req)
+}
+
+func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
+	return w.engine.Routes()
+}
+
+func defaultBuildRequestBindError(g *gin.Context, fieldtype string, err error) HTTPResponse {
+	return Error(err)
+}

ginext/funcWrapper.go

@@ -0,0 +1,60 @@
+package ginext
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+)
+
+type WHandlerFunc func(PreContext) HTTPResponse
+
+func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
+
+	return func(g *gin.Context) {
+
+		reqctx := g.Request.Context()
+
+		pctx := PreContext{
+			wrapper:        w,
+			ginCtx:         g,
+			persistantData: &preContextData{},
+		}
+
+		for _, lstr := range w.listenerBeforeRequest {
+			lstr(g)
+		}
+
+		wrap, stackTrace, panicObj := callPanicSafe(fn, pctx)
+		if panicObj != nil {
+
+			fmt.Printf("\n======== ======== STACKTRACE ======== ========\n%s\n======== ======== ======== ========\n\n", stackTrace)
+
+			err := exerr.
+				New(exerr.TypePanic, "Panic occured (in gin handler)").
+				Any("panicObj", panicObj).
+				Str("trace", stackTrace).
+				Build()
+
+			wrap = Error(err)
+		}
+
+		if g.Writer.Written() {
+			panic("Writing in WrapperFunc is not supported")
+		}
+
+		if pctx.persistantData.sessionObj != nil {
+			err := pctx.persistantData.sessionObj.Finish(reqctx, wrap)
+			if err != nil {
+				wrap = Error(exerr.Wrap(err, "Failed to finish session").Any("originalResponse", wrap).Build())
+			}
+		}
+
+		for _, lstr := range w.listenerAfterRequest {
+			lstr(g, wrap)
+		}
+
+		if reqctx.Err() == nil {
+			wrap.Write(g)
+		}
+	}
+}

ginext/jsonFilter.go

@@ -0,0 +1,9 @@
+package ginext
+
+import "github.com/gin-gonic/gin"
+
+var jsonFilterKey = "goext.jsonfilter"
+
+func SetJSONFilter(g *gin.Context, filter string) {
+	g.Set(jsonFilterKey, filter)
+}

ginext/preContext.go

@@ -0,0 +1,211 @@
+package ginext
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"git.blackforestbytes.com/BlackForestBytes/goext/dataext"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"io"
+	"runtime/debug"
+	"time"
+)
+
+type PreContext struct {
+	ginCtx                 *gin.Context
+	wrapper                *GinWrapper
+	uri                    any
+	query                  any
+	body                   any
+	rawbody                *[]byte
+	form                   any
+	header                 any
+	timeout                *time.Duration
+	persistantData         *preContextData // must be a ptr, so that we can get the values back in out Wrap func
+	ignoreWrongContentType bool
+}
+
+type preContextData struct {
+	sessionObj SessionObject
+}
+
+func (pctx *PreContext) URI(uri any) *PreContext {
+	pctx.uri = uri
+	return pctx
+}
+
+func (pctx *PreContext) Query(query any) *PreContext {
+	pctx.query = query
+	return pctx
+}
+
+func (pctx *PreContext) Body(body any) *PreContext {
+	pctx.body = body
+	return pctx
+}
+
+func (pctx *PreContext) RawBody(rawbody *[]byte) *PreContext {
+	pctx.rawbody = rawbody
+	return pctx
+}
+
+func (pctx *PreContext) Form(form any) *PreContext {
+	pctx.form = form
+	return pctx
+}
+
+func (pctx *PreContext) Header(header any) *PreContext {
+	pctx.header = header
+	return pctx
+}
+
+func (pctx *PreContext) WithTimeout(to time.Duration) *PreContext {
+	pctx.timeout = &to
+	return pctx
+}
+
+func (pctx *PreContext) WithSession(sessionObj SessionObject) *PreContext {
+	pctx.persistantData.sessionObj = sessionObj
+	return pctx
+}
+
+func (pctx *PreContext) IgnoreWrongContentType() *PreContext {
+	pctx.ignoreWrongContentType = true
+	return pctx
+}
+
+func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
+	if pctx.uri != nil {
+		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
+			err = exerr.Wrap(err, "Failed to read uri").
+				WithType(exerr.TypeBindFailURI).
+				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
+				Build()
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
+		}
+	}
+
+	if pctx.query != nil {
+		if err := pctx.ginCtx.ShouldBindQuery(pctx.query); err != nil {
+			err = exerr.Wrap(err, "Failed to read query").
+				WithType(exerr.TypeBindFailQuery).
+				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
+				Build()
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
+		}
+	}
+
+	if pctx.body != nil {
+		if pctx.ginCtx.ContentType() == "application/json" {
+			if brc, ok := pctx.body.(dataext.BufferedReadCloser); ok {
+				// Ensures a fully reset (offset=0) buffer before parsing
+				err := brc.Reset()
+				if err != nil {
+					err = exerr.Wrap(err, "Failed to read (brc.reset) json-body").
+						WithType(exerr.TypeBindFailJSON).
+						Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+						Build()
+					return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+				}
+			}
+			if err := pctx.ginCtx.ShouldBindJSON(pctx.body); err != nil {
+				err = exerr.Wrap(err, "Failed to read json-body").
+					WithType(exerr.TypeBindFailJSON).
+					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+					Build()
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+			}
+		} else {
+			if !pctx.ignoreWrongContentType {
+				err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
+					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+					Build()
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+			}
+		}
+	}
+
+	if pctx.rawbody != nil {
+		if brc, ok := pctx.ginCtx.Request.Body.(dataext.BufferedReadCloser); ok {
+			v, err := brc.BufferedAll()
+			if err != nil {
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
+			}
+			*pctx.rawbody = v
+		} else {
+			buf := &bytes.Buffer{}
+			_, err := io.Copy(buf, pctx.ginCtx.Request.Body)
+			if err != nil {
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
+			}
+			*pctx.rawbody = buf.Bytes()
+		}
+	}
+
+	if pctx.form != nil {
+		if pctx.ginCtx.ContentType() == "multipart/form-data" {
+			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
+				err = exerr.Wrap(err, "Failed to read multipart-form").
+					WithType(exerr.TypeBindFailFormData).
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+					Build()
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", 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 CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+			}
+		} else {
+			if !pctx.ignoreWrongContentType {
+				err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+					Build()
+				return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+			}
+		}
+	}
+
+	if pctx.header != nil {
+		if err := pctx.ginCtx.ShouldBindHeader(pctx.header); err != nil {
+			err = exerr.Wrap(err, "Failed to read header").
+				WithType(exerr.TypeBindFailHeader).
+				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
+				Build()
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
+		}
+	}
+
+	ictx, cancel := context.WithTimeout(context.Background(), langext.Coalesce(pctx.timeout, pctx.wrapper.requestTimeout))
+
+	actx := CreateAppContext(pctx.ginCtx, ictx, cancel)
+
+	if pctx.persistantData.sessionObj != nil {
+		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, actx)
+		if err != nil {
+			actx.Cancel()
+			return CreateBackgroundAppContext(), nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
+		}
+	}
+
+	return actx, pctx.ginCtx, nil
+}
+
+func callPanicSafe(fn WHandlerFunc, pctx PreContext) (res HTTPResponse, stackTrace string, panicObj any) {
+	defer func() {
+		if rec := recover(); rec != nil {
+			res = nil
+			stackTrace = string(debug.Stack())
+			panicObj = rec
+		}
+	}()
+
+	res = fn(pctx)
+	return res, "", nil
+}

ginext/response.go

@@ -0,0 +1,47 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+)
+
+type cookieval struct {
+	name     string
+	value    string
+	maxAge   int
+	path     string
+	domain   string
+	secure   bool
+	httpOnly bool
+}
+
+type headerval struct {
+	Key string
+	Val string
+}
+
+type HTTPResponse interface {
+	Write(g *gin.Context)
+	WithHeader(k string, v string) HTTPResponse
+	WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse
+	IsSuccess() bool
+}
+
+type InspectableHTTPResponse interface {
+	HTTPResponse
+
+	Statuscode() int
+	BodyString(g *gin.Context) *string
+	ContentType() string
+	Headers() []string
+}
+
+type HTTPErrorResponse interface {
+	HTTPResponse
+
+	Error() error
+}
+
+func NotImplemented() HTTPResponse {
+	return Error(exerr.New(exerr.TypeNotImplemented, "").Build())
+}

ginext/responseData.go

@@ -0,0 +1,58 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type dataHTTPResponse struct {
+	statusCode  int
+	data        []byte
+	contentType string
+	headers     []headerval
+	cookies     []cookieval
+}
+
+func (j dataHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	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
+}
+
+func (j dataHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j dataHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j dataHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j dataHTTPResponse) BodyString(*gin.Context) *string {
+	return langext.Ptr(string(j.data))
+}
+
+func (j dataHTTPResponse) ContentType() string {
+	return j.contentType
+}
+
+func (j dataHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func Data(sc int, contentType string, data []byte) HTTPResponse {
+	return &dataHTTPResponse{statusCode: sc, contentType: contentType, data: data}
+}

ginext/responseDownload.go

@@ -0,0 +1,64 @@
+package ginext
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type downloadDataHTTPResponse struct {
+	statusCode int
+	mimetype   string
+	data       []byte
+	filename   *string
+	headers    []headerval
+	cookies    []cookieval
+}
+
+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)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	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
+}
+
+func (j downloadDataHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j downloadDataHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j downloadDataHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j downloadDataHTTPResponse) BodyString(*gin.Context) *string {
+	return langext.Ptr(string(j.data))
+}
+
+func (j downloadDataHTTPResponse) ContentType() string {
+	return j.mimetype
+}
+
+func (j downloadDataHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func DownloadData(status int, mimetype string, filename string, data []byte) HTTPResponse {
+	return &downloadDataHTTPResponse{statusCode: status, mimetype: mimetype, data: data, filename: &filename}
+}

ginext/responseEmpty.go

@@ -0,0 +1,56 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type emptyHTTPResponse struct {
+	statusCode int
+	headers    []headerval
+	cookies    []cookieval
+}
+
+func (j emptyHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	g.Status(j.statusCode)
+}
+
+func (j emptyHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+func (j emptyHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j emptyHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j emptyHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j emptyHTTPResponse) BodyString(*gin.Context) *string {
+	return nil
+}
+
+func (j emptyHTTPResponse) ContentType() string {
+	return ""
+}
+
+func (j emptyHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func Status(sc int) HTTPResponse {
+	return &emptyHTTPResponse{statusCode: sc}
+}

ginext/responseFile.go

@@ -0,0 +1,73 @@
+package ginext
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"os"
+)
+
+type fileHTTPResponse struct {
+	mimetype string
+	filepath string
+	filename *string
+	headers  []headerval
+	cookies  []cookieval
+}
+
+func (j fileHTTPResponse) 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)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	g.File(j.filepath)
+}
+
+func (j fileHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+func (j fileHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j fileHTTPResponse) IsSuccess() bool {
+	return true
+}
+
+func (j fileHTTPResponse) Statuscode() int {
+	return 200
+}
+
+func (j fileHTTPResponse) BodyString(*gin.Context) *string {
+	data, err := os.ReadFile(j.filepath)
+	if err != nil {
+		return nil
+	}
+	return langext.Ptr(string(data))
+}
+
+func (j fileHTTPResponse) ContentType() string {
+	return j.mimetype
+}
+
+func (j fileHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func File(mimetype string, filepath string) HTTPResponse {
+	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath}
+}
+
+func Download(mimetype string, filepath string, filename string) HTTPResponse {
+	return &fileHTTPResponse{mimetype: mimetype, filepath: filepath, filename: &filename}
+}

ginext/responseJson.go

@@ -0,0 +1,78 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	json "git.blackforestbytes.com/BlackForestBytes/goext/gojson"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type jsonHTTPResponse struct {
+	statusCode     int
+	data           any
+	headers        []headerval
+	cookies        []cookieval
+	filterOverride *string
+}
+
+func (j jsonHTTPResponse) jsonRenderer(g *gin.Context) json.GoJsonRender {
+	var f *string
+	if jsonfilter := g.GetString(jsonFilterKey); jsonfilter != "" {
+		f = &jsonfilter
+	}
+	if j.filterOverride != nil {
+		f = j.filterOverride
+	}
+	return json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true, Filter: f}
+}
+
+func (j jsonHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	g.Render(j.statusCode, j.jsonRenderer(g))
+}
+
+func (j jsonHTTPResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+func (j jsonHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j jsonHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j jsonHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j jsonHTTPResponse) BodyString(g *gin.Context) *string {
+	if str, err := j.jsonRenderer(g).RenderString(); err == nil {
+		return &str
+	} else {
+		return nil
+	}
+}
+
+func (j jsonHTTPResponse) ContentType() string {
+	return "application/json"
+}
+
+func (j jsonHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func JSON(sc int, data any) HTTPResponse {
+	return &jsonHTTPResponse{statusCode: sc, data: data}
+}
+
+func JSONWithFilter(sc int, data any, f string) HTTPResponse {
+	return &jsonHTTPResponse{statusCode: sc, data: data, filterOverride: &f}
+}

ginext/responseJsonAPI.go

@@ -0,0 +1,81 @@
+package ginext
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type jsonAPIErrResponse struct {
+	err     *exerr.ExErr
+	headers []headerval
+	cookies []cookieval
+}
+
+func (j jsonAPIErrResponse) Error() error {
+	return j.err
+}
+
+func (j jsonAPIErrResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+
+	exerr.Get(j.err).Output(context.Background(), g)
+
+	j.err.CallListener(exerr.MethodOutput, exerr.ListenerOpt{NoLog: false})
+}
+
+func (j jsonAPIErrResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+func (j jsonAPIErrResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j jsonAPIErrResponse) IsSuccess() bool {
+	return false
+}
+
+func (j jsonAPIErrResponse) Statuscode() int {
+	return langext.Coalesce(j.err.RecursiveStatuscode(), 0)
+}
+
+func (j jsonAPIErrResponse) BodyString(*gin.Context) *string {
+	if str, err := j.err.ToDefaultAPIJson(); err == nil {
+		return &str
+	} else {
+		return nil
+	}
+}
+
+func (j jsonAPIErrResponse) ContentType() string {
+	return "application/json"
+}
+
+func (j jsonAPIErrResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func (j jsonAPIErrResponse) Unwrap() error {
+	return j.err
+}
+
+func Error(e error) HTTPResponse {
+	return &jsonAPIErrResponse{
+		err: exerr.FromError(e),
+	}
+}
+
+func ErrWrap(e error, errorType exerr.ErrorType, msg string) HTTPResponse {
+	return &jsonAPIErrResponse{
+		err: exerr.FromError(exerr.Wrap(e, msg).WithType(errorType).Build()),
+	}
+}

ginext/responseRedirect.go

@@ -0,0 +1,57 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type redirectHTTPResponse struct {
+	statusCode int
+	url        string
+	headers    []headerval
+	cookies    []cookieval
+}
+
+func (j redirectHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	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
+}
+
+func (j redirectHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j redirectHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j redirectHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j redirectHTTPResponse) BodyString(*gin.Context) *string {
+	return nil
+}
+
+func (j redirectHTTPResponse) ContentType() string {
+	return ""
+}
+
+func (j redirectHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func Redirect(sc int, newURL string) HTTPResponse {
+	return &redirectHTTPResponse{statusCode: sc, url: newURL}
+}

ginext/responseSeekable.go

@@ -0,0 +1,72 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/exerr"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"io"
+	"net/http"
+	"time"
+)
+
+type seekableResponse struct {
+	data        io.ReadSeeker
+	contentType string
+	filename    string
+	headers     []headerval
+	cookies     []cookieval
+}
+
+func (j seekableResponse) Write(g *gin.Context) {
+	g.Header("Content-Type", j.contentType) // if we don't set it here http.ServeContent does weird sniffing later...
+
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+
+	http.ServeContent(g.Writer, g.Request, j.filename, time.Unix(0, 0), j.data)
+
+	if clsr, ok := j.data.(io.ReadSeekCloser); ok {
+		err := clsr.Close()
+		if err != nil {
+			exerr.Wrap(err, "failed to close io.ReadSeerkClose in ginext.Seekable").Str("filename", j.filename).Print()
+		}
+	}
+}
+
+func (j seekableResponse) WithHeader(k string, v string) HTTPResponse {
+	j.headers = append(j.headers, headerval{k, v})
+	return j
+}
+
+func (j seekableResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j seekableResponse) IsSuccess() bool {
+	return true
+}
+
+func (j seekableResponse) Statuscode() int {
+	return 200
+}
+
+func (j seekableResponse) BodyString(*gin.Context) *string {
+	return langext.Ptr("(seekable)")
+}
+
+func (j seekableResponse) ContentType() string {
+	return j.contentType
+}
+
+func (j seekableResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func Seekable(filename string, contentType string, data io.ReadSeeker) HTTPResponse {
+	return &seekableResponse{filename: filename, contentType: contentType, data: data}
+}

ginext/responseText.go

@@ -0,0 +1,57 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+)
+
+type textHTTPResponse struct {
+	statusCode int
+	data       string
+	headers    []headerval
+	cookies    []cookieval
+}
+
+func (j textHTTPResponse) Write(g *gin.Context) {
+	for _, v := range j.headers {
+		g.Header(v.Key, v.Val)
+	}
+	for _, v := range j.cookies {
+		g.SetCookie(v.name, v.value, v.maxAge, v.path, v.domain, v.secure, v.httpOnly)
+	}
+	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
+}
+
+func (j textHTTPResponse) WithCookie(name string, value string, maxAge int, path string, domain string, secure bool, httpOnly bool) HTTPResponse {
+	j.cookies = append(j.cookies, cookieval{name, value, maxAge, path, domain, secure, httpOnly})
+	return j
+}
+
+func (j textHTTPResponse) IsSuccess() bool {
+	return j.statusCode >= 200 && j.statusCode <= 399
+}
+
+func (j textHTTPResponse) Statuscode() int {
+	return j.statusCode
+}
+
+func (j textHTTPResponse) BodyString(*gin.Context) *string {
+	return langext.Ptr(j.data)
+}
+
+func (j textHTTPResponse) ContentType() string {
+	return "text/plain"
+}
+
+func (j textHTTPResponse) Headers() []string {
+	return langext.ArrMap(j.headers, func(v headerval) string { return v.Key + "=" + v.Val })
+}
+
+func Text(sc int, data string) HTTPResponse {
+	return &textHTTPResponse{statusCode: sc, data: data}
+}

ginext/routes.go

@@ -0,0 +1,211 @@
+package ginext
+
+import (
+	"github.com/gin-gonic/gin"
+	"git.blackforestbytes.com/BlackForestBytes/goext/langext"
+	"net/http"
+	"path"
+	"reflect"
+	"runtime"
+	"strings"
+)
+
+var anyMethods = []string{
+	http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch,
+	http.MethodHead, http.MethodOptions, http.MethodDelete, http.MethodConnect,
+	http.MethodTrace,
+}
+
+type GinRoutesWrapper struct {
+	wrapper        *GinWrapper
+	routes         gin.IRouter
+	absPath        string
+	defaultHandler []gin.HandlerFunc
+}
+
+type GinRouteBuilder struct {
+	routes *GinRoutesWrapper
+
+	method   string
+	relPath  string
+	absPath  string
+	handlers []gin.HandlerFunc
+}
+
+func (w *GinWrapper) Routes() *GinRoutesWrapper {
+	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),
+		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, absPath: w.absPath}
+}
+
+func (w *GinRoutesWrapper) WithJSONFilter(filter string) *GinRoutesWrapper {
+	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
+}
+
+func (w *GinRoutesWrapper) GET(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodGet, relativePath)
+}
+
+func (w *GinRoutesWrapper) POST(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodPost, relativePath)
+}
+
+func (w *GinRoutesWrapper) DELETE(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodDelete, relativePath)
+}
+
+func (w *GinRoutesWrapper) PATCH(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodPatch, relativePath)
+}
+
+func (w *GinRoutesWrapper) PUT(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodPut, relativePath)
+}
+
+func (w *GinRoutesWrapper) OPTIONS(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodOptions, relativePath)
+}
+
+func (w *GinRoutesWrapper) HEAD(relativePath string) *GinRouteBuilder {
+	return w._route(http.MethodHead, relativePath)
+}
+
+func (w *GinRoutesWrapper) COUNT(relativePath string) *GinRouteBuilder {
+	return w._route("COUNT", relativePath)
+}
+
+func (w *GinRoutesWrapper) Any(relativePath string) *GinRouteBuilder {
+	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 {
+	w.handlers = append(w.handlers, middleware...)
+	return w
+}
+
+func (w *GinRouteBuilder) WithJSONFilter(filter string) *GinRouteBuilder {
+	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
+}
+
+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)
+
+	w.handlers = append(w.handlers, Wrap(w.routes.wrapper, handler))
+
+	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) {
+
+	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: middlewareNames,
+		Handler:     handlerName,
+	})
+}
+
+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")]
+	}
+
+	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]
+}

ginext/session.go

@@ -0,0 +1,11 @@
+package ginext
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+)
+
+type SessionObject interface {
+	Init(g *gin.Context, ctx *AppContext) error
+	Finish(ctx context.Context, resp HTTPResponse) error
+}

go.mod

@@ -1,24 +1,66 @@
-module gogs.mikescher.com/BlackForestBytes/goext
+module git.blackforestbytes.com/BlackForestBytes/goext
 
-go 1.19
+go 1.23.0
+
+toolchain go1.24.0
 
 require (
-	github.com/jmoiron/sqlx v1.3.5
+	github.com/gin-gonic/gin v1.10.1
-	go.mongodb.org/mongo-driver v1.11.7
+	github.com/glebarez/go-sqlite v1.22.0 // only needed for tests -.-
-	golang.org/x/crypto v0.9.0
+	github.com/jmoiron/sqlx v1.4.0
-	golang.org/x/sys v0.8.0
+	github.com/rs/xid v1.6.0
-	golang.org/x/term v0.8.0
+	github.com/rs/zerolog v1.34.0
+	go.mongodb.org/mongo-driver v1.17.4
+	golang.org/x/crypto v0.39.0
+	golang.org/x/sys v0.33.0
+	golang.org/x/term v0.32.0
 )
 
 require (
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/disintegration/imaging v1.6.2
-	github.com/klauspost/compress v1.16.5 // indirect
+	github.com/jung-kurt/gofpdf v1.16.2
+	golang.org/x/sync v0.15.0
+)
+
+require (
+	github.com/bytedance/sonic v1.13.3 // indirect
+	github.com/bytedance/sonic/loader v0.2.4 // indirect
+	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.9 // indirect
+	github.com/gin-contrib/sse v1.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.27.0 // indirect
+	github.com/goccy/go-json v0.10.5 // indirect
+	github.com/golang/snappy v1.0.0 // indirect
+	github.com/google/uuid v1.5.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.11 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/montanaflynn/stats v0.7.1 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/sync v0.2.0 // indirect
+	golang.org/x/arch v0.18.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
+	golang.org/x/image v0.28.0 // indirect
+	golang.org/x/net v0.41.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
+	google.golang.org/protobuf v1.36.6 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	modernc.org/libc v1.37.6 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
+	modernc.org/sqlite v1.28.0 // indirect
 )

go.sum

@@ -1,115 +1,411 @@
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
+github.com/bytedance/sonic v1.12.3 h1:W2MGa7RCU1QTeYRTPE3+88mVC0yXmsRQRChiyVocVjU=
+github.com/bytedance/sonic v1.12.3/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic v1.12.4 h1:9Csb3c9ZJhfUWeMtpCDCq6BUoH5ogfDFLUgQ/jG+R0k=
+github.com/bytedance/sonic v1.12.4/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic v1.12.5 h1:hoZxY8uW+mT+OpkcUWw4k0fDINtOcVavEsGfzwzFU/w=
+github.com/bytedance/sonic v1.12.5/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic v1.12.6 h1:/isNmCUF2x3Sh8RAp/4mh4ZGkcFAX/hLrzrK3AvpRzk=
+github.com/bytedance/sonic v1.12.6/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic v1.12.7 h1:CQU8pxOy9HToxhndH0Kx/S1qU/CuS9GnKYrGioDcU1Q=
+github.com/bytedance/sonic v1.12.7/go.mod h1:tnbal4mxOMju17EGfknm2XyYcpyCnIROYOEYuemj13I=
+github.com/bytedance/sonic v1.12.8 h1:4xYRVRlXIgvSZ4e8iVTlMF5szgpXd4AfvuWgA8I8lgs=
+github.com/bytedance/sonic v1.12.8/go.mod h1:uVvFidNmlt9+wa31S1urfwwthTWteBgG0hWuoKAXTx8=
+github.com/bytedance/sonic v1.12.9 h1:Od1BvK55NnewtGaJsTDeAOSnLVO2BTSLOe0+ooKokmQ=
+github.com/bytedance/sonic v1.12.9/go.mod h1:uVvFidNmlt9+wa31S1urfwwthTWteBgG0hWuoKAXTx8=
+github.com/bytedance/sonic v1.12.10 h1:uVCQr6oS5669E9ZVW0HyksTLfNS7Q/9hV6IVS4nEMsI=
+github.com/bytedance/sonic v1.12.10/go.mod h1:uVvFidNmlt9+wa31S1urfwwthTWteBgG0hWuoKAXTx8=
+github.com/bytedance/sonic v1.13.1 h1:Jyd5CIvdFnkOWuKXr+wm4Nyk2h0yAFsr8ucJgEasO3g=
+github.com/bytedance/sonic v1.13.1/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ=
+github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic v1.13.3 h1:MS8gmaH16Gtirygw7jV91pDCN33NyMrPbN7qiYhEsF0=
+github.com/bytedance/sonic v1.13.3/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
+github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.1 h1:1GgorWTqf12TA8mma4DDSbaQigE2wOgQo7iCjjJv3+E=
+github.com/bytedance/sonic/loader v0.2.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.2 h1:jxAJuN9fOot/cyz5Q6dUuMJF5OqQ6+5GfA8FjjQ0R4o=
+github.com/bytedance/sonic/loader v0.2.2/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/bytedance/sonic/loader v0.2.3 h1:yctD0Q3v2NOGfSWPLPvG2ggA2kV6TS6s4wioyEqssH0=
+github.com/bytedance/sonic/loader v0.2.3/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
+github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4=
+github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
-github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
+github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
+github.com/gabriel-vasile/mimetype v1.4.6 h1:3+PzJTKLkvgjeTbts6msPJt4DixhT4YtFNf1gtGe3zc=
+github.com/gabriel-vasile/mimetype v1.4.6/go.mod h1:JX1qVKqZd40hUPpAfiNTe0Sne7hdfKSbOqqmkq8GCXc=
+github.com/gabriel-vasile/mimetype v1.4.7 h1:SKFKl7kD0RiPdbht0s7hFtjl489WcQ1VyPW8ZzUMYCA=
+github.com/gabriel-vasile/mimetype v1.4.7/go.mod h1:GDlAgAyIRT27BhFl53XNAFtfjzOkLaF35JdEG0P7LtU=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
+github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E=
+github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0=
+github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
+github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/gin-gonic/gin v1.10.1 h1:T0ujvqyCSqRopADpgPgiTT63DUQVSfojyME59Ei63pQ=
+github.com/gin-gonic/gin v1.10.1/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
+github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.22.1 h1:40JcKH+bBNGFczGuoBYgX4I6m/i27HYW8P9FDk5PbgA=
+github.com/go-playground/validator/v10 v10.22.1/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-playground/validator/v10 v10.23.0 h1:/PwmTwZhS0dPkav3cdK9kV1FsAmrL8sThn8IHr/sO+o=
+github.com/go-playground/validator/v10 v10.23.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-playground/validator/v10 v10.24.0 h1:KHQckvo8G6hlWnrPX4NJJ+aBfWNAE/HH+qdL2cBpCmg=
+github.com/go-playground/validator/v10 v10.24.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
+github.com/go-playground/validator/v10 v10.25.0 h1:5Dh7cjvzR7BRZadnsVOzPhWsrwUr0nmsZJxEAnFLNO8=
+github.com/go-playground/validator/v10 v10.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
+github.com/go-playground/validator/v10 v10.26.0 h1:SP05Nqhjcvz81uJaRfEV0YBSSSGMc/iMaVtFbr3Sw2k=
+github.com/go-playground/validator/v10 v10.26.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
+github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
+github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
+github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
+github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
+github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
-github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
-github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/lib/pq v1.2.0 h1:LXpIM/LZ5xGFhOpXAQUIMM1HdyqzVYM13zNdjCEEcA0=
+github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/jung-kurt/gofpdf v1.16.2 h1:jgbatWHfRlPYiK85qgevsZTHviWXKwB1TTiKdz5PtRc=
-github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg=
+github.com/jung-kurt/gofpdf v1.16.2/go.mod h1:1hl7y57EsiPAkLbOwzpzqgx1A30nQCk/YmFV8S2vmK0=
-github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/klauspost/compress v1.17.10 h1:oXAz+Vh0PMUvJczoi+flxpnBEPxoER1IaAnU/NMPtT0=
-github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0=
+github.com/klauspost/compress v1.17.10/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
-github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
+github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
+github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU=
+github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
 github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
+github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/phpdave11/gofpdi v1.0.7/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
-github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.2.14 h1:yOQvXCBc3Ij46LRkRoh4Yd5qK6LVOgi0bYOXfb7ifjw=
+github.com/ugorji/go/codec v1.2.14/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
+github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.1.1 h1:VOMT+81stJgXW3CpHyqHN3AXDYIMsx56mEFrB37Mb/E=
-github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
 github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
 github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
-github.com/xdg-go/stringprep v1.0.3 h1:kdwGpVNwPFtjs98xCGkHjQtGKh86rDcRZN17QEMCOIs=
-github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
 github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
 github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
-github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
-github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
-github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a h1:fZHgsYlfvtyqToslyjUt3VOPF4J7aK/3MPcK7xp3PDk=
-github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a/go.mod h1:ul22v+Nro/R083muKhosV54bj5niojjWZvU8xrevuH4=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.mongodb.org/mongo-driver v1.11.1 h1:QP0znIRTuL0jf1oBQoAoM0C6ZJfBK4kx0Uumtv1A7w8=
+go.mongodb.org/mongo-driver v1.17.1 h1:Wic5cJIwJgSpBhe3lx3+/RybR5PiYRMpVFgO7cOHyIM=
-go.mongodb.org/mongo-driver v1.11.1/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
+go.mongodb.org/mongo-driver v1.17.1/go.mod h1:wwWm/+BuOddhcq3n68LKRmgk2wXzmF6s0SFOa0GINL4=
-go.mongodb.org/mongo-driver v1.11.7 h1:LIwYxASDLGUg/8wOhgOOZhX8tQa/9tgZPgzZoVqJvcs=
+go.mongodb.org/mongo-driver v1.17.2 h1:gvZyk8352qSfzyZ2UMWcpDpMSGEr1eqE4T793SqyhzM=
-go.mongodb.org/mongo-driver v1.11.7/go.mod h1:G9TgswdsWjX4tmDA5zfs2+6AEPpYJwqblyjsfuh8oXY=
+go.mongodb.org/mongo-driver v1.17.2/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.mongodb.org/mongo-driver v1.17.3 h1:TQyXhnsWfWtgAhMtOgtYHMTkZIfBTpMTsMnd9ZBeHxQ=
+go.mongodb.org/mongo-driver v1.17.3/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+go.mongodb.org/mongo-driver v1.17.4 h1:jUorfmVzljjr0FLzYQsGP8cgN/qzzxlY9Vh0C9KFXVw=
+go.mongodb.org/mongo-driver v1.17.4/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
+golang.org/x/arch v0.11.0 h1:KXV8WWKCXm6tRpLirl2szsO5j/oOODwZf4hATmGVNs4=
+golang.org/x/arch v0.11.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.12.0 h1:UsYJhbzPYGsT0HbEdmYcqtCv8UNGvnaL561NnIUvaKg=
+golang.org/x/arch v0.12.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.13.0 h1:KCkqVVV1kGg0X87TFysjCJ8MxtZEIU4Ja/yXGeoECdA=
+golang.org/x/arch v0.13.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4=
+golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw=
+golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
+golang.org/x/arch v0.16.0 h1:foMtLTdyOmIniqWCHjY6+JxuC54XP1fDwx4N0ASyW+U=
+golang.org/x/arch v0.16.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
+golang.org/x/arch v0.17.0 h1:4O3dfLzd+lQewptAHqjewQZQDyEdejz3VwgeYwkZneU=
+golang.org/x/arch v0.17.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/arch v0.18.0 h1:WN9poc33zL4AzGxqf8VtpKUnGvMi8O9lhNyBMF/85qc=
+golang.org/x/arch v0.18.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.28.0 h1:GBDwsMXVQi34v5CCYUm2jkJvu4cbtru2U4TN2PSyQnw=
-golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
+golang.org/x/crypto v0.28.0/go.mod h1:rmgy+3RHxRZMyY0jjAJShp2zgEdOqj2AO7U0pYmeQ7U=
-golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
-golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
-golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY=
+golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/crypto v0.35.0 h1:b15kiHdrGCHrP6LvwaQ3c03kgNhhiMgvlhxHQhmg2Xs=
+golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
+golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
+golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
+golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
+golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/image v0.21.0 h1:c5qV36ajHpdj4Qi0GnE0jUc/yuo33OLFaa0d+crTD5s=
+golang.org/x/image v0.21.0/go.mod h1:vUbsLavqK/W303ZroQQVKQ+Af3Yl6Uz1Ppu5J/cLz78=
+golang.org/x/image v0.22.0 h1:UtK5yLUzilVrkjMAZAZ34DXGpASN8i8pj8g+O+yd10g=
+golang.org/x/image v0.22.0/go.mod h1:9hPFhljd4zZ1GNSIZJ49sqbp45GKK9t6w+iXvGqZUz4=
+golang.org/x/image v0.23.0 h1:HseQ7c2OpPKTPVzNjG5fwJsOTCiiwS4QdsYi5XU6H68=
+golang.org/x/image v0.23.0/go.mod h1:wJJBTdLfCCf3tiHa1fNxpZmUI4mmoZvwMCPP0ddoNKY=
+golang.org/x/image v0.24.0 h1:AN7zRgVsbvmTfNyqIbbOraYL8mSwcKncEj8ofjgzcMQ=
+golang.org/x/image v0.24.0/go.mod h1:4b/ITuLfqYq1hqZcjofwctIhi7sZh2WaCjvsBNjjya8=
+golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
+golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
+golang.org/x/image v0.26.0 h1:4XjIFEZWQmCZi6Wv8BoxsDhRU3RVnLX04dToTDAEPlY=
+golang.org/x/image v0.26.0/go.mod h1:lcxbMFAovzpnJxzXS3nyL83K27tmqtKzIJpctK8YO5c=
+golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
+golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
+golang.org/x/image v0.28.0 h1:gdem5JW1OLS4FbkWgLO+7ZeFzYtL3xClb97GaUzYMFE=
+golang.org/x/image v0.28.0/go.mod h1:GUJYXtnGKEUgggyzh+Vxt+AviiCcyiwpsl8iQ8MvwGY=
 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=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4=
+golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU=
+golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=
+golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM=
+golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
+golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
+golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c=
+golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
+golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
+golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 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=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
+golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 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.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
+golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
-golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=
+golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
-golang.org/x/term v0.8.0 h1:n5xxQn2i3PC0yLAbjTpNT85q/Kgzcr2gIoX9OrJUols=
+golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
+golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
+golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 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=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
-golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
+golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
 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=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
+google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.35.2 h1:8Ar7bF+apOIoThw1EdZl0p1oWvMqTHmpA2fRTyZO8io=
+google.golang.org/protobuf v1.35.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
+google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU=
+google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.4 h1:6A3ZDJHn/eNqc1i+IdefRzy/9PokBTPvcqMySR7NNIM=
+google.golang.org/protobuf v1.36.4/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw=
+modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
+modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
+modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
+modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
+modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
+modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
+modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.156"
+const GoextVersion = "0.0.585"
 
-const GoextVersionTimestamp = "2023-06-10T00:19:17+0200"
+const GoextVersionTimestamp = "2025-07-04T11:46:00+0200"

gojson/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

gojson/README.md

@@ -4,9 +4,12 @@ JSON serializer which serializes nil-Arrays as `[]` and nil-maps als `{}`.
 
 Idea from: https://github.com/homelight/json
 
-Forked from https://github.com/golang/go/tree/547e8e22fe565d65d1fd4d6e71436a5a855447b0/src/encoding/json ( tag go1.20.2 )
+Forked from https://github.com/golang/go/tree/194de8fbfaf4c3ed54e1a3c1b14fc67a830b8d95/src/encoding/json ( tag go1.23.4 )
+  -> https://github.com/golang/go/tree/go1.23.4/src/encoding/json
 
 Added:
 
  - `MarshalSafeCollections()` method
  - `Encoder.nilSafeSlices` and `Encoder.nilSafeMaps` fields
+ - `Add 'tagkey' to use different key than json (set on Decoder struct)`
+ - `Add 'jsonfilter' to filter printed fields (set via MarshalSafeCollections)`

gojson/decode.go

@@ -17,14 +17,15 @@ import (
 	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
+	_ "unsafe" // for linkname
 )
 
 // Unmarshal parses the JSON-encoded data and stores the result
 // in the value pointed to by v. If v is nil or not a pointer,
-// Unmarshal returns an InvalidUnmarshalError.
+// Unmarshal returns an [InvalidUnmarshalError].
 //
 // Unmarshal uses the inverse of the encodings that
-// Marshal uses, allocating maps, slices, and pointers as necessary,
+// [Marshal] uses, allocating maps, slices, and pointers as necessary,
 // with the following additional rules:
 //
 // To unmarshal JSON into a pointer, Unmarshal first handles the case of
@@ -33,28 +34,28 @@ import (
 // the value pointed at by the pointer. If the pointer is nil, Unmarshal
 // allocates a new value for it to point to.
 //
-// To unmarshal JSON into a value implementing the Unmarshaler interface,
+// To unmarshal JSON into a value implementing [Unmarshaler],
-// Unmarshal calls that value's UnmarshalJSON method, including
+// Unmarshal calls that value's [Unmarshaler.UnmarshalJSON] method, including
 // when the input is a JSON null.
-// Otherwise, if the value implements encoding.TextUnmarshaler
+// Otherwise, if the value implements [encoding.TextUnmarshaler]
-// and the input is a JSON quoted string, Unmarshal calls that value's
+// and the input is a JSON quoted string, Unmarshal calls
-// UnmarshalText method with the unquoted form of the string.
+// [encoding.TextUnmarshaler.UnmarshalText] with the unquoted form of the string.
 //
 // To unmarshal JSON into a struct, Unmarshal matches incoming object
-// keys to the keys used by Marshal (either the struct field name or its tag),
+// keys to the keys used by [Marshal] (either the struct field name or its tag),
 // preferring an exact match but also accepting a case-insensitive match. By
 // default, object keys which don't have a corresponding struct field are
-// ignored (see Decoder.DisallowUnknownFields for an alternative).
+// ignored (see [Decoder.DisallowUnknownFields] for an alternative).
 //
 // To unmarshal JSON into an interface value,
 // Unmarshal stores one of these in the interface value:
 //
-//	bool, for JSON booleans
+//   - bool, for JSON booleans
-//	float64, for JSON numbers
+//   - float64, for JSON numbers
-//	string, for JSON strings
+//   - string, for JSON strings
-//	[]interface{}, for JSON arrays
+//   - []interface{}, for JSON arrays
-//	map[string]interface{}, for JSON objects
+//   - map[string]interface{}, for JSON objects
-//	nil for JSON null
+//   - nil for JSON null
 //
 // To unmarshal a JSON array into a slice, Unmarshal resets the slice length
 // to zero and then appends each element to the slice.
@@ -72,16 +73,15 @@ import (
 // use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
 // reuses the existing map, keeping existing entries. Unmarshal then stores
 // key-value pairs from the JSON object into the map. The map's key type must
-// either be any string type, an integer, implement json.Unmarshaler, or
+// either be any string type, an integer, or implement [encoding.TextUnmarshaler].
-// implement encoding.TextUnmarshaler.
 //
-// If the JSON-encoded data contain a syntax error, Unmarshal returns a SyntaxError.
+// If the JSON-encoded data contain a syntax error, Unmarshal returns a [SyntaxError].
 //
 // If a JSON value is not appropriate for a given target type,
 // or if a JSON number overflows the target type, Unmarshal
 // skips that field and completes the unmarshaling as best it can.
 // If no more serious errors are encountered, Unmarshal returns
-// an UnmarshalTypeError describing the earliest such error. In any
+// an [UnmarshalTypeError] describing the earliest such error. In any
 // case, it's not guaranteed that all the remaining fields following
 // the problematic one will be unmarshaled into the target object.
 //
@@ -114,7 +114,7 @@ func Unmarshal(data []byte, v any) error {
 // a JSON value. UnmarshalJSON must copy the JSON data
 // if it wishes to retain the data after returning.
 //
-// By convention, to approximate the behavior of Unmarshal itself,
+// By convention, to approximate the behavior of [Unmarshal] itself,
 // Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.
 type Unmarshaler interface {
 	UnmarshalJSON([]byte) error
@@ -151,8 +151,8 @@ func (e *UnmarshalFieldError) Error() string {
 	return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String()
 }
 
-// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
+// An InvalidUnmarshalError describes an invalid argument passed to [Unmarshal].
-// (The argument to Unmarshal must be a non-nil pointer.)
+// (The argument to [Unmarshal] must be a non-nil pointer.)
 type InvalidUnmarshalError struct {
 	Type reflect.Type
 }
@@ -217,6 +217,7 @@ type decodeState struct {
 	savedError            error
 	useNumber             bool
 	disallowUnknownFields bool
+	tagkey                *string
 }
 
 // readIndex returns the position of the last byte read.
@@ -540,17 +541,10 @@ func (d *decodeState) array(v reflect.Value) error {
 			break
 		}
 
-		// Get element of array, growing if necessary.
+		// Expand slice length, growing the slice if necessary.
 		if v.Kind() == reflect.Slice {
-			// Grow slice if necessary
 			if i >= v.Cap() {
-				newcap := v.Cap() + v.Cap()/2
+				v.Grow(1)
-				if newcap < 4 {
-					newcap = 4
-				}
-				newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
-				reflect.Copy(newv, v)
-				v.Set(newv)
 			}
 			if i >= v.Len() {
 				v.SetLen(i + 1)
@@ -584,13 +578,11 @@ func (d *decodeState) array(v reflect.Value) error {
 
 	if i < v.Len() {
 		if v.Kind() == reflect.Array {
-			// Array. Zero the rest.
-			z := reflect.Zero(v.Type().Elem())
 			for ; i < v.Len(); i++ {
-				v.Index(i).Set(z)
+				v.Index(i).SetZero() // zero remainder of array
 			}
 		} else {
-			v.SetLen(i)
+			v.SetLen(i) // truncate the slice
 		}
 	}
 	if i == 0 && v.Kind() == reflect.Slice {
@@ -600,7 +592,7 @@ func (d *decodeState) array(v reflect.Value) error {
 }
 
 var nullLiteral = []byte("null")
-var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+var textUnmarshalerType = reflect.TypeFor[encoding.TextUnmarshaler]()
 
 // object consumes an object from d.data[d.off-1:], decoding into v.
 // The first byte ('{') of the object has been read already.
@@ -652,7 +644,11 @@ func (d *decodeState) object(v reflect.Value) error {
 			v.Set(reflect.MakeMap(t))
 		}
 	case reflect.Struct:
-		fields = cachedTypeFields(t)
+		tagkey := "json"
+		if d.tagkey != nil {
+			tagkey = *d.tagkey
+		}
+		fields = cachedTypeFields(t, tagkey)
 		// ok
 	default:
 		d.saveError(&UnmarshalTypeError{Value: "object", Type: t, Offset: int64(d.off)})
@@ -695,24 +691,13 @@ func (d *decodeState) object(v reflect.Value) error {
 			if !mapElem.IsValid() {
 				mapElem = reflect.New(elemType).Elem()
 			} else {
-				mapElem.Set(reflect.Zero(elemType))
+				mapElem.SetZero()
 			}
 			subv = mapElem
 		} else {
-			var f *field
+			f := fields.byExactName[string(key)]
-			if i, ok := fields.nameIndex[string(key)]; ok {
+			if f == nil {
-				// Found an exact name match.
+				f = fields.byFoldedName[string(foldName(key))]
-				f = &fields.list[i]
-			} else {
-				// Fall back to the expensive case-insensitive
-				// linear search.
-				for i := range fields.list {
-					ff := &fields.list[i]
-					if ff.equalFold(ff.nameBytes, key) {
-						f = ff
-						break
-					}
-				}
 			}
 			if f != nil {
 				subv = v
@@ -782,33 +767,35 @@ func (d *decodeState) object(v reflect.Value) error {
 		if v.Kind() == reflect.Map {
 			kt := t.Key()
 			var kv reflect.Value
-			switch {
+			if reflect.PointerTo(kt).Implements(textUnmarshalerType) {
-			case reflect.PointerTo(kt).Implements(textUnmarshalerType):
 				kv = reflect.New(kt)
 				if err := d.literalStore(item, kv, true); err != nil {
 					return err
 				}
 				kv = kv.Elem()
-			case kt.Kind() == reflect.String:
+			} else {
-				kv = reflect.ValueOf(key).Convert(kt)
-			default:
 				switch kt.Kind() {
+				case reflect.String:
+					kv = reflect.New(kt).Elem()
+					kv.SetString(string(key))
 				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 					s := string(key)
 					n, err := strconv.ParseInt(s, 10, 64)
-					if err != nil || reflect.Zero(kt).OverflowInt(n) {
+					if err != nil || kt.OverflowInt(n) {
 						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
 						break
 					}
-					kv = reflect.ValueOf(n).Convert(kt)
+					kv = reflect.New(kt).Elem()
+					kv.SetInt(n)
 				case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 					s := string(key)
 					n, err := strconv.ParseUint(s, 10, 64)
-					if err != nil || reflect.Zero(kt).OverflowUint(n) {
+					if err != nil || kt.OverflowUint(n) {
 						d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: kt, Offset: int64(start + 1)})
 						break
 					}
-					kv = reflect.ValueOf(n).Convert(kt)
+					kv = reflect.New(kt).Elem()
+					kv.SetUint(n)
 				default:
 					panic("json: Unexpected key type") // should never occur
 				}
@@ -847,12 +834,12 @@ func (d *decodeState) convertNumber(s string) (any, error) {
 	}
 	f, err := strconv.ParseFloat(s, 64)
 	if err != nil {
-		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
+		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeFor[float64](), Offset: int64(d.off)}
 	}
 	return f, nil
 }
 
-var numberType = reflect.TypeOf(Number(""))
+var numberType = reflect.TypeFor[Number]()
 
 // literalStore decodes a literal stored in item into v.
 //
@@ -862,7 +849,7 @@ var numberType = reflect.TypeOf(Number(""))
 func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
 	// Check for unmarshaler.
 	if len(item) == 0 {
-		//Empty string given
+		// Empty string given.
 		d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
 		return nil
 	}
@@ -909,7 +896,7 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool
 		}
 		switch v.Kind() {
 		case reflect.Interface, reflect.Pointer, reflect.Map, reflect.Slice:
-			v.Set(reflect.Zero(v.Type()))
+			v.SetZero()
 			// otherwise, ignore null for primitives/string
 		}
 	case 't', 'f': // true, false
@@ -961,10 +948,11 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool
 			}
 			v.SetBytes(b[:n])
 		case reflect.String:
-			if v.Type() == numberType && !isValidNumber(string(s)) {
+			t := string(s)
+			if v.Type() == numberType && !isValidNumber(t) {
 				return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
 			}
-			v.SetString(string(s))
+			v.SetString(t)
 		case reflect.Interface:
 			if v.NumMethod() == 0 {
 				v.Set(reflect.ValueOf(string(s)))
@@ -980,13 +968,12 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool
 			}
 			panic(phasePanicMsg)
 		}
-		s := string(item)
 		switch v.Kind() {
 		default:
 			if v.Kind() == reflect.String && v.Type() == numberType {
 				// s must be a valid number, because it's
 				// already been tokenized.
-				v.SetString(s)
+				v.SetString(string(item))
 				break
 			}
 			if fromQuoted {
@@ -994,7 +981,7 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool
 			}
 			d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
 		case reflect.Interface:
-			n, err := d.convertNumber(s)
+			n, err := d.convertNumber(string(item))
 			if err != nil {
 				d.saveError(err)
 				break
@@ -1006,25 +993,25 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool
 			v.Set(reflect.ValueOf(n))
 
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			n, err := strconv.ParseInt(s, 10, 64)
+			n, err := strconv.ParseInt(string(item), 10, 64)
 			if err != nil || v.OverflowInt(n) {
-				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
+				d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
 				break
 			}
 			v.SetInt(n)
 
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-			n, err := strconv.ParseUint(s, 10, 64)
+			n, err := strconv.ParseUint(string(item), 10, 64)
 			if err != nil || v.OverflowUint(n) {
-				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
+				d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
 				break
 			}
 			v.SetUint(n)
 
 		case reflect.Float32, reflect.Float64:
-			n, err := strconv.ParseFloat(s, v.Type().Bits())
+			n, err := strconv.ParseFloat(string(item), v.Type().Bits())
 			if err != nil || v.OverflowFloat(n) {
-				d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
+				d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
 				break
 			}
 			v.SetFloat(n)
@@ -1196,6 +1183,15 @@ func unquote(s []byte) (t string, ok bool) {
 	return
 }
 
+// unquoteBytes should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/bytedance/sonic
+//
+// Do not remove or change the type signature.
+// See go.dev/issue/67401.
+//
+//go:linkname unquoteBytes
 func unquoteBytes(s []byte) (t []byte, ok bool) {
 	if len(s) < 2 || s[0] != '"' || s[len(s)-1] != '"' {
 		return

gojson/encode_test.go

@@ -15,7 +15,6 @@ import (
 	"runtime/debug"
 	"strconv"
 	"testing"
-	"unicode"
 )
 
 type Optionals struct {
@@ -45,7 +44,8 @@ type Optionals struct {
 	Sto struct{} `json:"sto,omitempty"`
 }
 
-var optionalsExpected = `{
+func TestOmitEmpty(t *testing.T) {
+	var want = `{
  "sr": "",
  "omitempty": 0,
  "slr": null,
@@ -56,8 +56,6 @@ var optionalsExpected = `{
  "str": {},
  "sto": {}
 }`
-
-func TestOmitEmpty(t *testing.T) {
 	var o Optionals
 	o.Sw = "something"
 	o.Mr = map[string]any{}
@@ -65,10 +63,10 @@ func TestOmitEmpty(t *testing.T) {
 
 	got, err := MarshalIndent(&o, "", " ")
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("MarshalIndent error: %v", err)
 	}
-	if got := string(got); got != optionalsExpected {
+	if got := string(got); got != want {
-		t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected)
+		t.Errorf("MarshalIndent:\n\tgot:  %s\n\twant: %s\n", indentNewlines(got), indentNewlines(want))
 	}
 }
 
@@ -82,12 +80,11 @@ type StringTag struct {
 
 func TestRoundtripStringTag(t *testing.T) {
 	tests := []struct {
-		name string
+		CaseName
 		in   StringTag
 		want string // empty to just test that we roundtrip
-	}{
+	}{{
-		{
+		CaseName: Name("AllTypes"),
-			name: "AllTypes",
 		in: StringTag{
 			BoolStr:    true,
 			IntStr:     42,
@@ -101,11 +98,10 @@ func TestRoundtripStringTag(t *testing.T) {
 	"UintptrStr": "44",
 	"StrStr": "\"xzbit\"",
 	"NumberStr": "46"
-			}`,
+}`,
-		},
+	}, {
-		{
 		// See golang.org/issues/38173.
-			name: "StringDoubleEscapes",
+		CaseName: Name("StringDoubleEscapes"),
 		in: StringTag{
 			StrStr:    "\b\f\n\r\t\"\\",
 			NumberStr: "0", // just to satisfy the roundtrip
@@ -114,30 +110,27 @@ func TestRoundtripStringTag(t *testing.T) {
 	"BoolStr": "false",
 	"IntStr": "0",
 	"UintptrStr": "0",
-				"StrStr": "\"\\u0008\\u000c\\n\\r\\t\\\"\\\\\"",
+	"StrStr": "\"\\b\\f\\n\\r\\t\\\"\\\\\"",
 	"NumberStr": "0"
-			}`,
+}`,
-		},
+	}}
-	}
+	for _, tt := range tests {
-	for _, test := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
-		t.Run(test.name, func(t *testing.T) {
+			got, err := MarshalIndent(&tt.in, "", "\t")
-			// Indent with a tab prefix to make the multi-line string
-			// literals in the table nicer to read.
-			got, err := MarshalIndent(&test.in, "\t\t\t", "\t")
 			if err != nil {
-				t.Fatal(err)
+				t.Fatalf("%s: MarshalIndent error: %v", tt.Where, err)
 			}
-			if got := string(got); got != test.want {
+			if got := string(got); got != tt.want {
-				t.Fatalf(" got: %s\nwant: %s\n", got, test.want)
+				t.Fatalf("%s: MarshalIndent:\n\tgot:  %s\n\twant: %s", tt.Where, stripWhitespace(got), stripWhitespace(tt.want))
 			}
 
 			// Verify that it round-trips.
 			var s2 StringTag
 			if err := Unmarshal(got, &s2); err != nil {
-				t.Fatalf("Decode: %v", err)
+				t.Fatalf("%s: Decode error: %v", tt.Where, err)
 			}
-			if !reflect.DeepEqual(test.in, s2) {
+			if !reflect.DeepEqual(s2, tt.in) {
-				t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", test.in, string(got), s2)
+				t.Fatalf("%s: Decode:\n\tinput: %s\n\tgot:  %#v\n\twant: %#v", tt.Where, indentNewlines(string(got)), s2, tt.in)
 			}
 		})
 	}
@@ -150,21 +143,21 @@ type renamedRenamedByteSlice []renamedByte
 
 func TestEncodeRenamedByteSlice(t *testing.T) {
 	s := renamedByteSlice("abc")
-	result, err := Marshal(s)
+	got, err := Marshal(s)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("Marshal error: %v", err)
 	}
-	expect := `"YWJj"`
+	want := `"YWJj"`
-	if string(result) != expect {
+	if string(got) != want {
-		t.Errorf(" got %s want %s", result, expect)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 	r := renamedRenamedByteSlice("abc")
-	result, err = Marshal(r)
+	got, err = Marshal(r)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("Marshal error: %v", err)
 	}
-	if string(result) != expect {
+	if string(got) != want {
-		t.Errorf(" got %s want %s", result, expect)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -213,36 +206,40 @@ func init() {
 
 func TestSamePointerNoCycle(t *testing.T) {
 	if _, err := Marshal(samePointerNoCycle); err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 }
 
 func TestSliceNoCycle(t *testing.T) {
 	if _, err := Marshal(sliceNoCycle); err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 }
 
-var unsupportedValues = []any{
-	math.NaN(),
-	math.Inf(-1),
-	math.Inf(1),
-	pointerCycle,
-	pointerCycleIndirect,
-	mapCycle,
-	sliceCycle,
-	recursiveSliceCycle,
-}
-
 func TestUnsupportedValues(t *testing.T) {
-	for _, v := range unsupportedValues {
+	tests := []struct {
-		if _, err := Marshal(v); err != nil {
+		CaseName
+		in any
+	}{
+		{Name(""), math.NaN()},
+		{Name(""), math.Inf(-1)},
+		{Name(""), math.Inf(1)},
+		{Name(""), pointerCycle},
+		{Name(""), pointerCycleIndirect},
+		{Name(""), mapCycle},
+		{Name(""), sliceCycle},
+		{Name(""), recursiveSliceCycle},
+	}
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			if _, err := Marshal(tt.in); err != nil {
 				if _, ok := err.(*UnsupportedValueError); !ok {
-				t.Errorf("for %v, got %T want UnsupportedValueError", v, err)
+					t.Errorf("%s: Marshal error:\n\tgot:  %T\n\twant: %T", tt.Where, err, new(UnsupportedValueError))
 				}
 			} else {
-			t.Errorf("for %v, expected error", v)
+				t.Errorf("%s: Marshal error: got nil, want non-nil", tt.Where)
 			}
+		})
 	}
 }
 
@@ -254,11 +251,11 @@ func TestMarshalTextFloatMap(t *testing.T) {
 	}
 	got, err := Marshal(m)
 	if err != nil {
-		t.Errorf("Marshal() error: %v", err)
+		t.Errorf("Marshal error: %v", err)
 	}
 	want := `{"TF:NaN":"1","TF:NaN":"1"}`
 	if string(got) != want {
-		t.Errorf("Marshal() = %s, want %s", got, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -323,10 +320,10 @@ func TestRefValMarshal(t *testing.T) {
 	const want = `{"R0":"ref","R1":"ref","R2":"\"ref\"","R3":"\"ref\"","V0":"val","V1":"val","V2":"\"val\"","V3":"\"val\""}`
 	b, err := Marshal(&s)
 	if err != nil {
-		t.Fatalf("Marshal: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	if got := string(b); got != want {
-		t.Errorf("got %q, want %q", got, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -349,33 +346,33 @@ func TestMarshalerEscaping(t *testing.T) {
 	want := `"\u003c\u0026\u003e"`
 	b, err := Marshal(c)
 	if err != nil {
-		t.Fatalf("Marshal(c): %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	if got := string(b); got != want {
-		t.Errorf("Marshal(c) = %#q, want %#q", got, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 
 	var ct CText
 	want = `"\"\u003c\u0026\u003e\""`
 	b, err = Marshal(ct)
 	if err != nil {
-		t.Fatalf("Marshal(ct): %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	if got := string(b); got != want {
-		t.Errorf("Marshal(ct) = %#q, want %#q", got, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
 func TestAnonymousFields(t *testing.T) {
 	tests := []struct {
-		label     string     // Test name
+		CaseName
 		makeInput func() any // Function to create input value
 		want      string     // Expected JSON output
 	}{{
 		// Both S1 and S2 have a field named X. From the perspective of S,
 		// it is ambiguous which one X refers to.
 		// This should not serialize either field.
-		label: "AmbiguousField",
+		CaseName: Name("AmbiguousField"),
 		makeInput: func() any {
 			type (
 				S1 struct{ x, X int }
@@ -389,7 +386,7 @@ func TestAnonymousFields(t *testing.T) {
 		},
 		want: `{}`,
 	}, {
-		label: "DominantField",
+		CaseName: Name("DominantField"),
 		// Both S1 and S2 have a field named X, but since S has an X field as
 		// well, it takes precedence over S1.X and S2.X.
 		makeInput: func() any {
@@ -407,7 +404,7 @@ func TestAnonymousFields(t *testing.T) {
 		want: `{"X":6}`,
 	}, {
 		// Unexported embedded field of non-struct type should not be serialized.
-		label: "UnexportedEmbeddedInt",
+		CaseName: Name("UnexportedEmbeddedInt"),
 		makeInput: func() any {
 			type (
 				myInt int
@@ -418,7 +415,7 @@ func TestAnonymousFields(t *testing.T) {
 		want: `{}`,
 	}, {
 		// Exported embedded field of non-struct type should be serialized.
-		label: "ExportedEmbeddedInt",
+		CaseName: Name("ExportedEmbeddedInt"),
 		makeInput: func() any {
 			type (
 				MyInt int
@@ -430,7 +427,7 @@ func TestAnonymousFields(t *testing.T) {
 	}, {
 		// Unexported embedded field of pointer to non-struct type
 		// should not be serialized.
-		label: "UnexportedEmbeddedIntPointer",
+		CaseName: Name("UnexportedEmbeddedIntPointer"),
 		makeInput: func() any {
 			type (
 				myInt int
@@ -444,7 +441,7 @@ func TestAnonymousFields(t *testing.T) {
 	}, {
 		// Exported embedded field of pointer to non-struct type
 		// should be serialized.
-		label: "ExportedEmbeddedIntPointer",
+		CaseName: Name("ExportedEmbeddedIntPointer"),
 		makeInput: func() any {
 			type (
 				MyInt int
@@ -459,7 +456,7 @@ func TestAnonymousFields(t *testing.T) {
 		// Exported fields of embedded structs should have their
 		// exported fields be serialized regardless of whether the struct types
 		// themselves are exported.
-		label: "EmbeddedStruct",
+		CaseName: Name("EmbeddedStruct"),
 		makeInput: func() any {
 			type (
 				s1 struct{ x, X int }
@@ -476,7 +473,7 @@ func TestAnonymousFields(t *testing.T) {
 		// Exported fields of pointers to embedded structs should have their
 		// exported fields be serialized regardless of whether the struct types
 		// themselves are exported.
-		label: "EmbeddedStructPointer",
+		CaseName: Name("EmbeddedStructPointer"),
 		makeInput: func() any {
 			type (
 				s1 struct{ x, X int }
@@ -492,7 +489,7 @@ func TestAnonymousFields(t *testing.T) {
 	}, {
 		// Exported fields on embedded unexported structs at multiple levels
 		// of nesting should still be serialized.
-		label: "NestedStructAndInts",
+		CaseName: Name("NestedStructAndInts"),
 		makeInput: func() any {
 			type (
 				MyInt1 int
@@ -519,7 +516,7 @@ func TestAnonymousFields(t *testing.T) {
 		// If an anonymous struct pointer field is nil, we should ignore
 		// the embedded fields behind it. Not properly doing so may
 		// result in the wrong output or reflect panics.
-		label: "EmbeddedFieldBehindNilPointer",
+		CaseName: Name("EmbeddedFieldBehindNilPointer"),
 		makeInput: func() any {
 			type (
 				S2 struct{ Field string }
@@ -531,13 +528,13 @@ func TestAnonymousFields(t *testing.T) {
 	}}
 
 	for _, tt := range tests {
-		t.Run(tt.label, func(t *testing.T) {
+		t.Run(tt.Name, func(t *testing.T) {
 			b, err := Marshal(tt.makeInput())
 			if err != nil {
-				t.Fatalf("Marshal() = %v, want nil error", err)
+				t.Fatalf("%s: Marshal error: %v", tt.Where, err)
 			}
 			if string(b) != tt.want {
-				t.Fatalf("Marshal() = %q, want %q", b, tt.want)
+				t.Fatalf("%s: Marshal:\n\tgot:  %s\n\twant: %s", tt.Where, b, tt.want)
 			}
 		})
 	}
@@ -589,31 +586,34 @@ func (nm *nilTextMarshaler) MarshalText() ([]byte, error) {
 
 // See golang.org/issue/16042 and golang.org/issue/34235.
 func TestNilMarshal(t *testing.T) {
-	testCases := []struct {
+	tests := []struct {
-		v    any
+		CaseName
+		in   any
 		want string
 	}{
-		{v: nil, want: `null`},
+		{Name(""), nil, `null`},
-		{v: new(float64), want: `0`},
+		{Name(""), new(float64), `0`},
-		{v: []any(nil), want: `null`},
+		{Name(""), []any(nil), `null`},
-		{v: []string(nil), want: `null`},
+		{Name(""), []string(nil), `null`},
-		{v: map[string]string(nil), want: `null`},
+		{Name(""), map[string]string(nil), `null`},
-		{v: []byte(nil), want: `null`},
+		{Name(""), []byte(nil), `null`},
-		{v: struct{ M string }{"gopher"}, want: `{"M":"gopher"}`},
+		{Name(""), struct{ M string }{"gopher"}, `{"M":"gopher"}`},
-		{v: struct{ M Marshaler }{}, want: `{"M":null}`},
+		{Name(""), struct{ M Marshaler }{}, `{"M":null}`},
-		{v: struct{ M Marshaler }{(*nilJSONMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
+		{Name(""), struct{ M Marshaler }{(*nilJSONMarshaler)(nil)}, `{"M":"0zenil0"}`},
-		{v: struct{ M any }{(*nilJSONMarshaler)(nil)}, want: `{"M":null}`},
+		{Name(""), struct{ M any }{(*nilJSONMarshaler)(nil)}, `{"M":null}`},
-		{v: struct{ M encoding.TextMarshaler }{}, want: `{"M":null}`},
+		{Name(""), struct{ M encoding.TextMarshaler }{}, `{"M":null}`},
-		{v: struct{ M encoding.TextMarshaler }{(*nilTextMarshaler)(nil)}, want: `{"M":"0zenil0"}`},
+		{Name(""), struct{ M encoding.TextMarshaler }{(*nilTextMarshaler)(nil)}, `{"M":"0zenil0"}`},
-		{v: struct{ M any }{(*nilTextMarshaler)(nil)}, want: `{"M":null}`},
+		{Name(""), struct{ M any }{(*nilTextMarshaler)(nil)}, `{"M":null}`},
 	}
-
+	for _, tt := range tests {
-	for _, tt := range testCases {
+		t.Run(tt.Name, func(t *testing.T) {
-		out, err := Marshal(tt.v)
+			switch got, err := Marshal(tt.in); {
-		if err != nil || string(out) != tt.want {
+			case err != nil:
-			t.Errorf("Marshal(%#v) = %#q, %#v, want %#q, nil", tt.v, out, err, tt.want)
+				t.Fatalf("%s: Marshal error: %v", tt.Where, err)
-			continue
+			case string(got) != tt.want:
+				t.Fatalf("%s: Marshal:\n\tgot:  %s\n\twant: %s", tt.Where, got, tt.want)
 			}
+		})
 	}
 }
 
@@ -625,12 +625,12 @@ func TestEmbeddedBug(t *testing.T) {
 	}
 	b, err := Marshal(v)
 	if err != nil {
-		t.Fatal("Marshal:", err)
+		t.Fatal("Marshal error:", err)
 	}
 	want := `{"S":"B"}`
 	got := string(b)
 	if got != want {
-		t.Fatalf("Marshal: got %s want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 	// Now check that the duplicate field, S, does not appear.
 	x := BugX{
@@ -638,12 +638,12 @@ func TestEmbeddedBug(t *testing.T) {
 	}
 	b, err = Marshal(x)
 	if err != nil {
-		t.Fatal("Marshal:", err)
+		t.Fatal("Marshal error:", err)
 	}
 	want = `{"A":23}`
 	got = string(b)
 	if got != want {
-		t.Fatalf("Marshal: got %s want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -665,12 +665,12 @@ func TestTaggedFieldDominates(t *testing.T) {
 	}
 	b, err := Marshal(v)
 	if err != nil {
-		t.Fatal("Marshal:", err)
+		t.Fatal("Marshal error:", err)
 	}
 	want := `{"S":"BugD"}`
 	got := string(b)
 	if got != want {
-		t.Fatalf("Marshal: got %s want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -692,60 +692,12 @@ func TestDuplicatedFieldDisappears(t *testing.T) {
 	}
 	b, err := Marshal(v)
 	if err != nil {
-		t.Fatal("Marshal:", err)
+		t.Fatal("Marshal error:", err)
 	}
 	want := `{}`
 	got := string(b)
 	if got != want {
-		t.Fatalf("Marshal: got %s want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
-	}
-}
-
-func TestStringBytes(t *testing.T) {
-	t.Parallel()
-	// Test that encodeState.stringBytes and encodeState.string use the same encoding.
-	var r []rune
-	for i := '\u0000'; i <= unicode.MaxRune; i++ {
-		if testing.Short() && i > 1000 {
-			i = unicode.MaxRune
-		}
-		r = append(r, i)
-	}
-	s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too
-
-	for _, escapeHTML := range []bool{true, false} {
-		es := &encodeState{}
-		es.string(s, escapeHTML)
-
-		esBytes := &encodeState{}
-		esBytes.stringBytes([]byte(s), escapeHTML)
-
-		enc := es.Buffer.String()
-		encBytes := esBytes.Buffer.String()
-		if enc != encBytes {
-			i := 0
-			for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] {
-				i++
-			}
-			enc = enc[i:]
-			encBytes = encBytes[i:]
-			i = 0
-			for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] {
-				i++
-			}
-			enc = enc[:len(enc)-i]
-			encBytes = encBytes[:len(encBytes)-i]
-
-			if len(enc) > 20 {
-				enc = enc[:20] + "..."
-			}
-			if len(encBytes) > 20 {
-				encBytes = encBytes[:20] + "..."
-			}
-
-			t.Errorf("with escapeHTML=%t, encodings differ at %#q vs %#q",
-				escapeHTML, enc, encBytes)
-		}
 	}
 }
 
@@ -755,9 +707,8 @@ func TestIssue10281(t *testing.T) {
 	}
 	x := Foo{Number(`invalid`)}
 
-	b, err := Marshal(&x)
+	if _, err := Marshal(&x); err == nil {
-	if err == nil {
+		t.Fatalf("Marshal error: got nil, want non-nil")
-		t.Errorf("Marshal(&x) = %#q; want error", b)
 	}
 }
 
@@ -773,26 +724,26 @@ func TestMarshalErrorAndReuseEncodeState(t *testing.T) {
 	}
 	dummy := Dummy{Name: "Dummy"}
 	dummy.Next = &dummy
-	if b, err := Marshal(dummy); err == nil {
+	if _, err := Marshal(dummy); err == nil {
-		t.Errorf("Marshal(dummy) = %#q; want error", b)
+		t.Errorf("Marshal error: got nil, want non-nil")
 	}
 
 	type Data struct {
 		A string
 		I int
 	}
-	data := Data{A: "a", I: 1}
+	want := Data{A: "a", I: 1}
-	b, err := Marshal(data)
+	b, err := Marshal(want)
 	if err != nil {
-		t.Errorf("Marshal(%v) = %v", data, err)
+		t.Errorf("Marshal error: %v", err)
 	}
 
-	var data2 Data
+	var got Data
-	if err := Unmarshal(b, &data2); err != nil {
+	if err := Unmarshal(b, &got); err != nil {
-		t.Errorf("Unmarshal(%v) = %v", data2, err)
+		t.Errorf("Unmarshal error: %v", err)
 	}
-	if data2 != data {
+	if got != want {
-		t.Errorf("expect: %v, but get: %v", data, data2)
+		t.Errorf("Unmarshal:\n\tgot:  %v\n\twant: %v", got, want)
 	}
 }
 
@@ -802,7 +753,7 @@ func TestHTMLEscape(t *testing.T) {
 	want.Write([]byte(`{"M":"\u003chtml\u003efoo \u0026\u2028 \u2029\u003c/html\u003e"}`))
 	HTMLEscape(&b, []byte(m))
 	if !bytes.Equal(b.Bytes(), want.Bytes()) {
-		t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes())
+		t.Errorf("HTMLEscape:\n\tgot:  %s\n\twant: %s", b.Bytes(), want.Bytes())
 	}
 }
 
@@ -814,21 +765,19 @@ func TestEncodePointerString(t *testing.T) {
 	var n int64 = 42
 	b, err := Marshal(stringPointer{N: &n})
 	if err != nil {
-		t.Fatalf("Marshal: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	if got, want := string(b), `{"n":"42"}`; got != want {
-		t.Errorf("Marshal = %s, want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 	var back stringPointer
-	err = Unmarshal(b, &back)
+	switch err = Unmarshal(b, &back); {
-	if err != nil {
+	case err != nil:
-		t.Fatalf("Unmarshal: %v", err)
+		t.Fatalf("Unmarshal error: %v", err)
-	}
+	case back.N == nil:
-	if back.N == nil {
+		t.Fatalf("Unmarshal: back.N = nil, want non-nil")
-		t.Fatalf("Unmarshaled nil N field")
+	case *back.N != 42:
-	}
+		t.Fatalf("Unmarshal: *back.N = %d, want 42", *back.N)
-	if *back.N != 42 {
-		t.Fatalf("*N = %d; want 42", *back.N)
 	}
 }
 
@@ -844,11 +793,11 @@ var encodeStringTests = []struct {
 	{"\x05", `"\u0005"`},
 	{"\x06", `"\u0006"`},
 	{"\x07", `"\u0007"`},
-	{"\x08", `"\u0008"`},
+	{"\x08", `"\b"`},
 	{"\x09", `"\t"`},
 	{"\x0a", `"\n"`},
 	{"\x0b", `"\u000b"`},
-	{"\x0c", `"\u000c"`},
+	{"\x0c", `"\f"`},
 	{"\x0d", `"\r"`},
 	{"\x0e", `"\u000e"`},
 	{"\x0f", `"\u000f"`},
@@ -874,7 +823,7 @@ func TestEncodeString(t *testing.T) {
 	for _, tt := range encodeStringTests {
 		b, err := Marshal(tt.in)
 		if err != nil {
-			t.Errorf("Marshal(%q): %v", tt.in, err)
+			t.Errorf("Marshal(%q) error: %v", tt.in, err)
 			continue
 		}
 		out := string(b)
@@ -912,65 +861,67 @@ func (f textfloat) MarshalText() ([]byte, error) { return tenc(`TF:%0.2f`, f) }
 
 // Issue 13783
 func TestEncodeBytekind(t *testing.T) {
-	testdata := []struct {
+	tests := []struct {
-		data any
+		CaseName
+		in   any
 		want string
 	}{
-		{byte(7), "7"},
+		{Name(""), byte(7), "7"},
-		{jsonbyte(7), `{"JB":7}`},
+		{Name(""), jsonbyte(7), `{"JB":7}`},
-		{textbyte(4), `"TB:4"`},
+		{Name(""), textbyte(4), `"TB:4"`},
-		{jsonint(5), `{"JI":5}`},
+		{Name(""), jsonint(5), `{"JI":5}`},
-		{textint(1), `"TI:1"`},
+		{Name(""), textint(1), `"TI:1"`},
-		{[]byte{0, 1}, `"AAE="`},
+		{Name(""), []byte{0, 1}, `"AAE="`},
-		{[]jsonbyte{0, 1}, `[{"JB":0},{"JB":1}]`},
+		{Name(""), []jsonbyte{0, 1}, `[{"JB":0},{"JB":1}]`},
-		{[][]jsonbyte{{0, 1}, {3}}, `[[{"JB":0},{"JB":1}],[{"JB":3}]]`},
+		{Name(""), [][]jsonbyte{{0, 1}, {3}}, `[[{"JB":0},{"JB":1}],[{"JB":3}]]`},
-		{[]textbyte{2, 3}, `["TB:2","TB:3"]`},
+		{Name(""), []textbyte{2, 3}, `["TB:2","TB:3"]`},
-		{[]jsonint{5, 4}, `[{"JI":5},{"JI":4}]`},
+		{Name(""), []jsonint{5, 4}, `[{"JI":5},{"JI":4}]`},
-		{[]textint{9, 3}, `["TI:9","TI:3"]`},
+		{Name(""), []textint{9, 3}, `["TI:9","TI:3"]`},
-		{[]int{9, 3}, `[9,3]`},
+		{Name(""), []int{9, 3}, `[9,3]`},
-		{[]textfloat{12, 3}, `["TF:12.00","TF:3.00"]`},
+		{Name(""), []textfloat{12, 3}, `["TF:12.00","TF:3.00"]`},
 	}
-	for _, d := range testdata {
+	for _, tt := range tests {
-		js, err := Marshal(d.data)
+		t.Run(tt.Name, func(t *testing.T) {
+			b, err := Marshal(tt.in)
 			if err != nil {
-			t.Error(err)
+				t.Errorf("%s: Marshal error: %v", tt.Where, err)
-			continue
 			}
-		got, want := string(js), d.want
+			got, want := string(b), tt.want
 			if got != want {
-			t.Errorf("got %s, want %s", got, want)
+				t.Errorf("%s: Marshal:\n\tgot:  %s\n\twant: %s", tt.Where, got, want)
 			}
+		})
 	}
 }
 
 func TestTextMarshalerMapKeysAreSorted(t *testing.T) {
-	b, err := Marshal(map[unmarshalerText]int{
+	got, err := Marshal(map[unmarshalerText]int{
 		{"x", "y"}: 1,
 		{"y", "x"}: 2,
 		{"a", "z"}: 3,
 		{"z", "a"}: 4,
 	})
 	if err != nil {
-		t.Fatalf("Failed to Marshal text.Marshaler: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	const want = `{"a:z":3,"x:y":1,"y:x":2,"z:a":4}`
-	if string(b) != want {
+	if string(got) != want {
-		t.Errorf("Marshal map with text.Marshaler keys: got %#q, want %#q", b, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
 // https://golang.org/issue/33675
 func TestNilMarshalerTextMapKey(t *testing.T) {
-	b, err := Marshal(map[*unmarshalerText]int{
+	got, err := Marshal(map[*unmarshalerText]int{
 		(*unmarshalerText)(nil): 1,
 		{"A", "B"}:              2,
 	})
 	if err != nil {
-		t.Fatalf("Failed to Marshal *text.Marshaler: %v", err)
+		t.Fatalf("Marshal error: %v", err)
 	}
 	const want = `{"":1,"A:B":2}`
-	if string(b) != want {
+	if string(got) != want {
-		t.Errorf("Marshal map with *text.Marshaler keys: got %#q, want %#q", b, want)
+		t.Errorf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
@@ -1009,7 +960,7 @@ func TestMarshalFloat(t *testing.T) {
 		}
 		bout, err := Marshal(vf)
 		if err != nil {
-			t.Errorf("Marshal(%T(%g)): %v", vf, vf, err)
+			t.Errorf("Marshal(%T(%g)) error: %v", vf, vf, err)
 			nfail++
 			return
 		}
@@ -1018,12 +969,12 @@ func TestMarshalFloat(t *testing.T) {
 		// result must convert back to the same float
 		g, err := strconv.ParseFloat(out, bits)
 		if err != nil {
-			t.Errorf("Marshal(%T(%g)) = %q, cannot parse back: %v", vf, vf, out, err)
+			t.Errorf("ParseFloat(%q) error: %v", out, err)
 			nfail++
 			return
 		}
 		if f != g || fmt.Sprint(f) != fmt.Sprint(g) { // fmt.Sprint handles ±0
-			t.Errorf("Marshal(%T(%g)) = %q (is %g, not %g)", vf, vf, out, float32(g), vf)
+			t.Errorf("ParseFloat(%q):\n\tgot:  %g\n\twant: %g", out, float32(g), vf)
 			nfail++
 			return
 		}
@@ -1034,7 +985,7 @@ func TestMarshalFloat(t *testing.T) {
 		}
 		for _, re := range bad {
 			if re.MatchString(out) {
-				t.Errorf("Marshal(%T(%g)) = %q, must not match /%s/", vf, vf, out, re)
+				t.Errorf("Marshal(%T(%g)) = %q; must not match /%s/", vf, vf, out, re)
 				nfail++
 				return
 			}
@@ -1098,87 +1049,90 @@ func TestMarshalRawMessageValue(t *testing.T) {
 	)
 
 	tests := []struct {
+		CaseName
 		in   any
 		want string
 		ok   bool
 	}{
 		// Test with nil RawMessage.
-		{rawNil, "null", true},
+		{Name(""), rawNil, "null", true},
-		{&rawNil, "null", true},
+		{Name(""), &rawNil, "null", true},
-		{[]any{rawNil}, "[null]", true},
+		{Name(""), []any{rawNil}, "[null]", true},
-		{&[]any{rawNil}, "[null]", true},
+		{Name(""), &[]any{rawNil}, "[null]", true},
-		{[]any{&rawNil}, "[null]", true},
+		{Name(""), []any{&rawNil}, "[null]", true},
-		{&[]any{&rawNil}, "[null]", true},
+		{Name(""), &[]any{&rawNil}, "[null]", true},
-		{struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
+		{Name(""), struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
-		{&struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
+		{Name(""), &struct{ M RawMessage }{rawNil}, `{"M":null}`, true},
-		{struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
+		{Name(""), struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
-		{&struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
+		{Name(""), &struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true},
-		{map[string]any{"M": rawNil}, `{"M":null}`, true},
+		{Name(""), map[string]any{"M": rawNil}, `{"M":null}`, true},
-		{&map[string]any{"M": rawNil}, `{"M":null}`, true},
+		{Name(""), &map[string]any{"M": rawNil}, `{"M":null}`, true},
-		{map[string]any{"M": &rawNil}, `{"M":null}`, true},
+		{Name(""), map[string]any{"M": &rawNil}, `{"M":null}`, true},
-		{&map[string]any{"M": &rawNil}, `{"M":null}`, true},
+		{Name(""), &map[string]any{"M": &rawNil}, `{"M":null}`, true},
-		{T1{rawNil}, "{}", true},
+		{Name(""), T1{rawNil}, "{}", true},
-		{T2{&rawNil}, `{"M":null}`, true},
+		{Name(""), T2{&rawNil}, `{"M":null}`, true},
-		{&T1{rawNil}, "{}", true},
+		{Name(""), &T1{rawNil}, "{}", true},
-		{&T2{&rawNil}, `{"M":null}`, true},
+		{Name(""), &T2{&rawNil}, `{"M":null}`, true},
 
 		// Test with empty, but non-nil, RawMessage.
-		{rawEmpty, "", false},
+		{Name(""), rawEmpty, "", false},
-		{&rawEmpty, "", false},
+		{Name(""), &rawEmpty, "", false},
-		{[]any{rawEmpty}, "", false},
+		{Name(""), []any{rawEmpty}, "", false},
-		{&[]any{rawEmpty}, "", false},
+		{Name(""), &[]any{rawEmpty}, "", false},
-		{[]any{&rawEmpty}, "", false},
+		{Name(""), []any{&rawEmpty}, "", false},
-		{&[]any{&rawEmpty}, "", false},
+		{Name(""), &[]any{&rawEmpty}, "", false},
-		{struct{ X RawMessage }{rawEmpty}, "", false},
+		{Name(""), struct{ X RawMessage }{rawEmpty}, "", false},
-		{&struct{ X RawMessage }{rawEmpty}, "", false},
+		{Name(""), &struct{ X RawMessage }{rawEmpty}, "", false},
-		{struct{ X *RawMessage }{&rawEmpty}, "", false},
+		{Name(""), struct{ X *RawMessage }{&rawEmpty}, "", false},
-		{&struct{ X *RawMessage }{&rawEmpty}, "", false},
+		{Name(""), &struct{ X *RawMessage }{&rawEmpty}, "", false},
-		{map[string]any{"nil": rawEmpty}, "", false},
+		{Name(""), map[string]any{"nil": rawEmpty}, "", false},
-		{&map[string]any{"nil": rawEmpty}, "", false},
+		{Name(""), &map[string]any{"nil": rawEmpty}, "", false},
-		{map[string]any{"nil": &rawEmpty}, "", false},
+		{Name(""), map[string]any{"nil": &rawEmpty}, "", false},
-		{&map[string]any{"nil": &rawEmpty}, "", false},
+		{Name(""), &map[string]any{"nil": &rawEmpty}, "", false},
-		{T1{rawEmpty}, "{}", true},
+		{Name(""), T1{rawEmpty}, "{}", true},
-		{T2{&rawEmpty}, "", false},
+		{Name(""), T2{&rawEmpty}, "", false},
-		{&T1{rawEmpty}, "{}", true},
+		{Name(""), &T1{rawEmpty}, "{}", true},
-		{&T2{&rawEmpty}, "", false},
+		{Name(""), &T2{&rawEmpty}, "", false},
 
 		// Test with RawMessage with some text.
 		//
 		// The tests below marked with Issue6458 used to generate "ImZvbyI=" instead "foo".
 		// This behavior was intentionally changed in Go 1.8.
 		// See https://golang.org/issues/14493#issuecomment-255857318
-		{rawText, `"foo"`, true}, // Issue6458
+		{Name(""), rawText, `"foo"`, true}, // Issue6458
-		{&rawText, `"foo"`, true},
+		{Name(""), &rawText, `"foo"`, true},
-		{[]any{rawText}, `["foo"]`, true},  // Issue6458
+		{Name(""), []any{rawText}, `["foo"]`, true},  // Issue6458
-		{&[]any{rawText}, `["foo"]`, true}, // Issue6458
+		{Name(""), &[]any{rawText}, `["foo"]`, true}, // Issue6458
-		{[]any{&rawText}, `["foo"]`, true},
+		{Name(""), []any{&rawText}, `["foo"]`, true},
-		{&[]any{&rawText}, `["foo"]`, true},
+		{Name(""), &[]any{&rawText}, `["foo"]`, true},
-		{struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458
+		{Name(""), struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458
-		{&struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true},
+		{Name(""), &struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true},
-		{struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
+		{Name(""), struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
-		{&struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
+		{Name(""), &struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true},
-		{map[string]any{"M": rawText}, `{"M":"foo"}`, true},  // Issue6458
+		{Name(""), map[string]any{"M": rawText}, `{"M":"foo"}`, true},  // Issue6458
-		{&map[string]any{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458
+		{Name(""), &map[string]any{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458
-		{map[string]any{"M": &rawText}, `{"M":"foo"}`, true},
+		{Name(""), map[string]any{"M": &rawText}, `{"M":"foo"}`, true},
-		{&map[string]any{"M": &rawText}, `{"M":"foo"}`, true},
+		{Name(""), &map[string]any{"M": &rawText}, `{"M":"foo"}`, true},
-		{T1{rawText}, `{"M":"foo"}`, true}, // Issue6458
+		{Name(""), T1{rawText}, `{"M":"foo"}`, true}, // Issue6458
-		{T2{&rawText}, `{"M":"foo"}`, true},
+		{Name(""), T2{&rawText}, `{"M":"foo"}`, true},
-		{&T1{rawText}, `{"M":"foo"}`, true},
+		{Name(""), &T1{rawText}, `{"M":"foo"}`, true},
-		{&T2{&rawText}, `{"M":"foo"}`, true},
+		{Name(""), &T2{&rawText}, `{"M":"foo"}`, true},
 	}
 
-	for i, tt := range tests {
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
 			b, err := Marshal(tt.in)
 			if ok := (err == nil); ok != tt.ok {
 				if err != nil {
-				t.Errorf("test %d, unexpected failure: %v", i, err)
+					t.Errorf("%s: Marshal error: %v", tt.Where, err)
 				} else {
-				t.Errorf("test %d, unexpected success", i)
+					t.Errorf("%s: Marshal error: got nil, want non-nil", tt.Where)
 				}
 			}
 			if got := string(b); got != tt.want {
-			t.Errorf("test %d, Marshal(%#v) = %q, want %q", i, tt.in, got, tt.want)
+				t.Errorf("%s: Marshal:\n\tinput: %#v\n\tgot:  %s\n\twant: %s", tt.Where, tt.in, got, tt.want)
 			}
+		})
 	}
 }
 
@@ -1202,38 +1156,66 @@ func TestMarshalUncommonFieldNames(t *testing.T) {
 	}{}
 	b, err := Marshal(v)
 	if err != nil {
-		t.Fatal("Marshal:", err)
+		t.Fatal("Marshal error:", err)
 	}
 	want := `{"A0":0,"À":0,"Aβ":0}`
 	got := string(b)
 	if got != want {
-		t.Fatalf("Marshal: got %s want %s", got, want)
+		t.Fatalf("Marshal:\n\tgot:  %s\n\twant: %s", got, want)
 	}
 }
 
 func TestMarshalerError(t *testing.T) {
 	s := "test variable"
 	st := reflect.TypeOf(s)
-	errText := "json: test error"
+	const errText = "json: test error"
 
 	tests := []struct {
+		CaseName
 		err  *MarshalerError
 		want string
-	}{
+	}{{
-		{
+		Name(""),
 		&MarshalerError{st, fmt.Errorf(errText), ""},
 		"json: error calling MarshalJSON for type " + st.String() + ": " + errText,
-		},
+	}, {
-		{
+		Name(""),
 		&MarshalerError{st, fmt.Errorf(errText), "TestMarshalerError"},
 		"json: error calling TestMarshalerError for type " + st.String() + ": " + errText,
-		},
+	}}
-	}
 
-	for i, tt := range tests {
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
 			got := tt.err.Error()
 			if got != tt.want {
-			t.Errorf("MarshalerError test %d, got: %s, want: %s", i, got, tt.want)
+				t.Errorf("%s: Error:\n\tgot:  %s\n\twant: %s", tt.Where, got, tt.want)
+			}
+		})
+	}
+}
+
+type marshaledValue string
+
+func (v marshaledValue) MarshalJSON() ([]byte, error) {
+	return []byte(v), nil
+}
+
+func TestIssue63379(t *testing.T) {
+	for _, v := range []string{
+		"[]<",
+		"[]>",
+		"[]&",
+		"[]\u2028",
+		"[]\u2029",
+		"{}<",
+		"{}>",
+		"{}&",
+		"{}\u2028",
+		"{}\u2029",
+	} {
+		_, err := Marshal(marshaledValue(v))
+		if err == nil {
+			t.Errorf("expected error for %q", v)
 		}
 	}
 }
@@ -1253,6 +1235,10 @@ func TestMarshalSafeCollections(t *testing.T) {
 		nilMapStruct struct {
 			NilMap map[string]interface{} `json:"nil_map"`
 		}
+		testWithFilter struct {
+			Test1 string `json:"test1" jsonfilter:"FILTERONE"`
+			Test2 string `json:"test2" jsonfilter:"FILTERTWO"`
+		}
 	)
 
 	tests := []struct {
@@ -1271,10 +1257,12 @@ func TestMarshalSafeCollections(t *testing.T) {
 		{map[string]interface{}{"1": 1, "2": 2, "3": 3}, "{\"1\":1,\"2\":2,\"3\":3}"},
 		{pNilMap, "null"},
 		{nilMapStruct{}, "{\"nil_map\":{}}"},
+		{testWithFilter{}, "{\"test1\":\"\"}"},
 	}
 
+	filter := "FILTERONE"
 	for i, tt := range tests {
-		b, err := MarshalSafeCollections(tt.in, true, true, nil)
+		b, err := MarshalSafeCollections(tt.in, true, true, nil, &filter)
 		if err != nil {
 			t.Errorf("test %d, unexpected failure: %v", i, err)
 		}