v0.0.362

.gitea/workflows/tests.yml

@@ -6,7 +6,12 @@
 name: Build Docker and Deploy
 run-name: Build & Deploy ${{ gitea.ref }} on ${{ gitea.actor }}
 
-on: [push]
+on:
+  push:
+    branches:
+      - '*'
+      - '**'
+
 
 jobs:
   run_tests:
@@ -34,3 +39,17 @@ jobs:
       - 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/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>

README.md

@@ -41,3 +41,5 @@ 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                                                                                           |
+|             |            |                                                                                                               |

bfcodegen/csid-generate.go

@@ -70,9 +70,9 @@ func GenerateCharsetIDSpecs(sourceDir string, destFile string) error {
 	newChecksum := cryptext.BytesSha256([]byte(newChecksumStr))
 
 	if newChecksum != oldChecksum {
-		fmt.Printf("[IDGenerate] Checksum has changed ( %s -> %s ), will generate new file\n\n", oldChecksum, newChecksum)
+		fmt.Printf("[CSIDGenerate] 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)
+		fmt.Printf("[CSIDGenerate] Checksum unchanged ( %s ), nothing to do\n", oldChecksum)
 		return nil
 	}
 

bfcodegen/csid-generate_test.go

@@ -12,8 +12,8 @@ import (
 	"time"
 )
 
-//go:embed _test_example.tgz
-var CSIDExampleModels []byte
+//go:embed _test_example_1.tgz
+var CSIDExampleModels1 []byte
 
 func TestGenerateCSIDSpecs(t *testing.T) {
 
@@ -21,7 +21,7 @@ func TestGenerateCSIDSpecs(t *testing.T) {
 
 	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
 
-	err := os.WriteFile(tmpFile, CSIDExampleModels, 0o777)
+	err := os.WriteFile(tmpFile, CSIDExampleModels1, 0o777)
 	tst.AssertNoErr(t, err)
 
 	t.Cleanup(func() { _ = os.Remove(tmpFile) })

bfcodegen/enum-generate.go

@@ -3,6 +3,7 @@ package bfcodegen
 import (
 	"bytes"
 	_ "embed"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"go/format"
@@ -14,6 +15,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
 	"text/template"
@@ -23,6 +25,8 @@ type EnumDefVal struct {
 	VarName     string
 	Value       string
 	Description *string
+	Data        *map[string]any
+	RawComment  *string
 }
 
 type EnumDef struct {
@@ -37,7 +41,7 @@ var rexEnumPackage = rext.W(regexp.MustCompile(`^package\s+(?P<name>[A-Za-z0-9_]
 
 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 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<descr>.*))?.*$`))
+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>.*))?.*$`))
 
 var rexEnumChecksumConst = rext.W(regexp.MustCompile(`const ChecksumEnumGenerator = "(?P<cs>[A-Za-z0-9_]*)"`))
 
@@ -46,11 +50,6 @@ var templateEnumGenerateText string
 
 func GenerateEnumSpecs(sourceDir string, destFile string) error {
 
-	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)
@@ -62,6 +61,30 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 		}
 	}
 
+	gocode, _, changed, err := _generateEnumSpecs(sourceDir, destFile, oldChecksum, true)
+	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) (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") })
@@ -71,7 +94,7 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 	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)
 	}
@@ -82,7 +105,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)
@@ -93,7 +116,7 @@ func GenerateEnumSpecs(sourceDir string, destFile string) error {
 		fmt.Printf("========= %s =========\n\n", f.Name())
 		fileEnums, pn, err := processEnumFile(sourceDir, path.Join(sourceDir, f.Name()))
 		if err != nil {
-			return err
+			return "", "", false, err
 		}
 
 		fmt.Printf("\n")
@@ -106,20 +129,21 @@ 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")
 	}
 
-	fdata, err := format.Source([]byte(fmtEnumOutput(newChecksum, allEnums, pkgname)))
+	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
 	}
 
-	err = os.WriteFile(destFile, fdata, 0o755)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return string(fdata), newChecksum, true, nil
 }
 
 func processEnumFile(basedir string, fn string) ([]EnumDef, string, error) {
@@ -171,10 +195,34 @@ func processEnumFile(basedir string, fn string) ([]EnumDef, string, error) {
 
 		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
@@ -199,6 +247,41 @@ func processEnumFile(basedir string, fn string) ([]EnumDef, string, error) {
 	return enums, pkgname, nil
 }
 
+func tryParseDataComment(s string) (map[string]any, bool) {
+
+	r := make(map[string]any)
+
+	err := json.Unmarshal([]byte(s), &r)
+	if err != nil {
+		return nil, false
+	}
+
+	for _, v := range r {
+
+		rv := reflect.ValueOf(v)
+
+		if rv.Kind() == reflect.Ptr && rv.IsNil() {
+			continue
+		}
+		if rv.Kind() == reflect.Bool {
+			continue
+		}
+		if rv.Kind() == reflect.String {
+			continue
+		}
+		if rv.Kind() == reflect.Int64 {
+			continue
+		}
+		if rv.Kind() == reflect.Float64 {
+			continue
+		}
+
+		return nil, false
+	}
+
+	return r, true
+}
+
 func fmtEnumOutput(cs string, enums []EnumDef, pkgname string) string {
 
 	templ := template.New("enum-generate")
@@ -211,6 +294,47 @@ func fmtEnumOutput(cs string, enums []EnumDef, pkgname string) string {
 		"hasDescr": func(v EnumDef) bool {
 			return langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Description != nil })
 		},
+		"hasData": func(v EnumDef) bool {
+			return len(v.Values) > 0 && langext.ArrAll(v.Values, func(val EnumDefVal) bool { return val.Data != nil })
+		},
+		"gostr": func(v any) string {
+			return fmt.Sprintf("%#+v", v)
+		},
+		"goobj": func(name string, v any) string {
+			return fmt.Sprintf("%#+v", v)
+		},
+		"godatakey": func(v string) string {
+			return strings.ToUpper(v[0:1]) + v[1:]
+		},
+		"godatavalue": func(v any) string {
+			return fmt.Sprintf("%#+v", v)
+		},
+		"godatatype": func(v any) string {
+			return fmt.Sprintf("%T", v)
+		},
+		"mapindex": func(v map[string]any, k string) any {
+			return v[k]
+		},
+		"generalDataKeys": func(v EnumDef) map[string]string {
+			r0 := make(map[string]int)
+
+			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))

bfcodegen/enum-generate.template

@@ -11,21 +11,38 @@ const ChecksumEnumGenerator = "{{.Checksum}}" // GoExtVersion: {{.GoextVersion}}
 
 {{ $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}}", {{end}}
+	{{.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}}
 
@@ -64,6 +81,15 @@ func (e {{.EnumTypeName}}) Description() string {
 }
 {{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
@@ -75,6 +101,12 @@ 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 {
@@ -94,4 +126,12 @@ func {{.EnumTypeName}}ValuesMeta() []enums.EnumMetaValue {
 	}
 }
 
+{{if $hasDescr}}
+func {{.EnumTypeName}}ValuesDescriptionMeta() []enums.EnumDescriptionMetaValue {
+	return []enums.EnumDescriptionMetaValue{ {{range .Values}}
+            {{.VarName}}.DescriptionMeta(), {{end}}
+	}
+}
+{{end}}
+
 {{end}}

bfcodegen/enum-generate_test.go

@@ -12,8 +12,11 @@ import (
 	"time"
 )
 
-//go:embed _test_example.tgz
-var EnumExampleModels []byte
+//go:embed _test_example_1.tgz
+var EnumExampleModels1 []byte
+
+//go:embed _test_example_2.tgz
+var EnumExampleModels2 []byte
 
 func TestGenerateEnumSpecs(t *testing.T) {
 
@@ -21,7 +24,7 @@ func TestGenerateEnumSpecs(t *testing.T) {
 
 	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
 
-	err := os.WriteFile(tmpFile, EnumExampleModels, 0o777)
+	err := os.WriteFile(tmpFile, EnumExampleModels1, 0o777)
 	tst.AssertNoErr(t, err)
 
 	t.Cleanup(func() { _ = os.Remove(tmpFile) })
@@ -34,17 +37,53 @@ func TestGenerateEnumSpecs(t *testing.T) {
 	_, err = cmdext.Runner("tar").Arg("-xvzf").Arg(tmpFile).Arg("-C").Arg(tmpDir).FailOnExitCode().FailOnTimeout().Timeout(time.Minute).Run()
 	tst.AssertNoErr(t, err)
 
-	err = GenerateEnumSpecs(tmpDir, tmpDir+"/enums_gen.go")
+	s1, cs1, _, err := _generateEnumSpecs(tmpDir, "", "N/A", true)
 	tst.AssertNoErr(t, err)
 
-	err = GenerateEnumSpecs(tmpDir, tmpDir+"/enums_gen.go")
+	s2, cs2, _, err := _generateEnumSpecs(tmpDir, "", "N/A", 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(string(tst.Must(os.ReadFile(tmpDir + "/enums_gen.go"))(t)))
+	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)
+	tst.AssertNoErr(t, err)
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Println()
+	fmt.Println("=====================================================================================================")
+	fmt.Println(s1)
 	fmt.Println("=====================================================================================================")
 	fmt.Println()
 	fmt.Println()

bfcodegen/id-generate_test.go

@@ -12,8 +12,8 @@ import (
 	"time"
 )
 
-//go:embed _test_example.tgz
-var IDExampleModels []byte
+//go:embed _test_example_1.tgz
+var IDExampleModels1 []byte
 
 func TestGenerateIDSpecs(t *testing.T) {
 
@@ -21,7 +21,7 @@ func TestGenerateIDSpecs(t *testing.T) {
 
 	tmpDir := filepath.Join(t.TempDir(), langext.MustHexUUID())
 
-	err := os.WriteFile(tmpFile, IDExampleModels, 0o777)
+	err := os.WriteFile(tmpFile, IDExampleModels1, 0o777)
 	tst.AssertNoErr(t, err)
 
 	t.Cleanup(func() { _ = os.Remove(tmpFile) })

dataext/syncMap.go

@@ -0,0 +1,113 @@
+package dataext
+
+import "sync"
+
+type SyncMap[TKey comparable, TData any] struct {
+	data 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]) 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]) 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]) 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
+}

enums/enum.go

@@ -15,10 +15,17 @@ type StringEnum interface {
 type DescriptionEnum interface {
 	Enum
 	Description() string
+	DescriptionMeta() EnumDescriptionMetaValue
 }
 
 type EnumMetaValue struct {
 	VarName     string  `json:"varName"`
-	Value       any     `json:"value"`
+	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

@@ -70,6 +70,7 @@ func init() {
 type Builder struct {
 	errorData       *ExErr
 	containsGinData bool
+	noLog           bool
 }
 
 func Get(err error) *Builder {
@@ -190,6 +191,13 @@ func (b *Builder) System() *Builder {
 
 // ----------------------------------------------------------------------------
 
+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))
 }
@@ -401,16 +409,18 @@ func extractHeader(header map[string][]string) []string {
 
 // Build creates a new error, ready to pass up the stack
 // If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
+// Can be gloablly configured with ZeroLogErrTraces and ZeroLogAllTraces
+// Can be locally suppressed with Builder.NoLog()
 func (b *Builder) Build() error {
 	warnOnPkgConfigNotInitialized()
 
-	if pkgconfig.ZeroLogErrTraces && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
+	if pkgconfig.ZeroLogErrTraces && !b.noLog && (b.errorData.Severity == SevErr || b.errorData.Severity == SevFatal) {
 		b.errorData.ShortLog(stackSkipLogger.Error())
-	} else if pkgconfig.ZeroLogAllTraces {
+	} else if pkgconfig.ZeroLogAllTraces && !b.noLog {
 		b.errorData.ShortLog(stackSkipLogger.Error())
 	}
 
-	b.CallListener(MethodBuild)
+	b.errorData.CallListener(MethodBuild)
 
 	return b.errorData
 }
@@ -432,7 +442,7 @@ func (b *Builder) Output(ctx context.Context, g *gin.Context) {
 		b.errorData.Log(stackSkipLogger.Warn())
 	}
 
-	b.CallListener(MethodOutput)
+	b.errorData.CallListener(MethodOutput)
 }
 
 // Print prints the error
@@ -444,7 +454,7 @@ func (b *Builder) Print() {
 		b.errorData.ShortLog(stackSkipLogger.Warn())
 	}
 
-	b.CallListener(MethodPrint)
+	b.errorData.CallListener(MethodPrint)
 }
 
 func (b *Builder) Format(level LogPrintLevel) string {
@@ -457,7 +467,7 @@ func (b *Builder) Fatal() {
 	b.errorData.Severity = SevFatal
 	b.errorData.Log(stackSkipLogger.WithLevel(zerolog.FatalLevel))
 
-	b.CallListener(MethodFatal)
+	b.errorData.CallListener(MethodFatal)
 
 	os.Exit(1)
 }

exerr/data.go

@@ -48,6 +48,9 @@ var (
 	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))
+
 	TypeWrap = NewType("Wrap", nil)
 
 	TypeBindFailURI      = NewType("BINDFAIL_URI", langext.Ptr(400))
@@ -59,21 +62,27 @@ var (
 	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))
 
-	// other values come the used package
+	// other values come from the downstream application that uses goext
 )
 
-var registeredTypes = dataext.SyncSet[string]{}
+var registeredTypes = dataext.SyncMap[string, ErrorType]{}
 
 func NewType(key string, defStatusCode *int) ErrorType {
-	insertOkay := registeredTypes.Add(key)
-	if !insertOkay {
-		panic("Cannot register same ErrType ('" + key + "') more than once")
-	}
+	et := ErrorType{key, defStatusCode}
 
-	return ErrorType{key, defStatusCode}
+	registeredTypes.Set(key, et)
+
+	return et
+}
+
+func ListRegisteredTypes() []ErrorType {
+	return registeredTypes.GetAllValues()
 }
 
 type LogPrintLevel string

exerr/errinit.go

@@ -68,6 +68,10 @@ func Init(cfg ErrorPackageConfigInit) {
 	initialized = true
 }
 
+func Initialized() bool {
+	return initialized
+}
+
 func warnOnPkgConfigNotInitialized() {
 	if !initialized {
 		fmt.Printf("\n")

exerr/exerr.go

@@ -169,14 +169,32 @@ func (ee *ExErr) ShortLog(evt *zerolog.Event) {
 
 // RecursiveMessage returns the message to show
 // = first error (top-down) that is not wrapping/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 != CatWrap && curr.Category != CatForeign {
 			return curr.Message
 		}
 	}
 
-	// fallback to self
+	// ==== [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
 }
 
@@ -240,6 +258,73 @@ func (ee *ExErr) Depth() int {
 	}
 }
 
+// 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
+}
+
 // 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 {

exerr/gin.go

@@ -57,6 +57,19 @@ func (ee *ExErr) toJson(depth int, applyExtendListener bool, outputMeta bool) la
 	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)
 //

exerr/listener.go

@@ -25,13 +25,11 @@ func RegisterListener(l Listener) {
 	listener = append(listener, l)
 }
 
-func (b *Builder) CallListener(m Method) {
-	valErr := b.errorData
-
+func (ee *ExErr) CallListener(m Method) {
 	listenerLock.Lock()
 	defer listenerLock.Unlock()
 
 	for _, v := range listener {
-		v(m, valErr)
+		v(m, ee)
 	}
 }

ginext/engine.go

@@ -6,8 +6,10 @@ import (
 	"github.com/rs/zerolog/log"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"gogs.mikescher.com/BlackForestBytes/goext/rext"
 	"net"
 	"net/http"
+	"regexp"
 	"strings"
 	"time"
 )
@@ -16,10 +18,12 @@ type GinWrapper struct {
 	engine          *gin.Engine
 	SuppressGinLogs bool
 
-	allowCors      bool
-	ginDebug       bool
-	bufferBody     bool
-	requestTimeout time.Duration
+	allowCors             bool
+	ginDebug              bool
+	bufferBody            bool
+	requestTimeout        time.Duration
+	listenerBeforeRequest []func(g *gin.Context)
+	listenerAfterRequest  []func(g *gin.Context, resp HTTPResponse)
 
 	routeSpecs []ginRouteSpec
 }
@@ -31,35 +35,41 @@ type ginRouteSpec struct {
 	Handler     string
 }
 
+type Options struct {
+	AllowCors             *bool                                     // Add cors handler to allow all CORS requests on the default http methods
+	GinDebug              *bool                                     // Set gin.debug to true (adds more logs)
+	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
+}
+
 // NewEngine creates a new (wrapped) ginEngine
-// Parameters are:
-// - [allowCors]    Add cors handler to allow all CORS requests on the default http methods
-// - [ginDebug]     Set gin.debug to true (adds more logs)
-// - [bufferBody]   Buffers the input body stream, this way the ginext error handler can later include the whole request body
-// - [timeout]      The default handler timeout
-func NewEngine(allowCors bool, ginDebug bool, bufferBody bool, timeout time.Duration) *GinWrapper {
+func NewEngine(opt Options) *GinWrapper {
 	engine := gin.New()
 
 	wrapper := &GinWrapper{
-		engine:          engine,
-		SuppressGinLogs: false,
-		allowCors:       allowCors,
-		ginDebug:        ginDebug,
-		bufferBody:      bufferBody,
-		requestTimeout:  timeout,
+		engine:                engine,
+		SuppressGinLogs:       false,
+		allowCors:             langext.Coalesce(opt.AllowCors, false),
+		ginDebug:              langext.Coalesce(opt.GinDebug, true),
+		bufferBody:            langext.Coalesce(opt.BufferBody, false),
+		requestTimeout:        langext.Coalesce(opt.Timeout, 24*time.Hour),
+		listenerBeforeRequest: opt.ListenerBeforeRequest,
+		listenerAfterRequest:  opt.ListenerAfterRequest,
 	}
 
 	engine.RedirectFixedPath = false
 	engine.RedirectTrailingSlash = false
 
-	if allowCors {
+	if wrapper.allowCors {
 		engine.Use(CorsMiddleware())
 	}
 
 	// do not debug-print routes
 	gin.DebugPrintRouteFunc = func(_, _, _ string, _ int) {}
 
-	if !ginDebug {
+	if !wrapper.ginDebug {
 		gin.SetMode(gin.ReleaseMode)
 
 		ginlogger := gin.Logger()
@@ -126,8 +136,8 @@ func (w *GinWrapper) DebugPrintRoutes() {
 		line := [4]string{
 			spec.Method,
 			spec.URL,
-			strings.Join(spec.Middlewares, " -> "),
-			spec.Handler,
+			strings.Join(langext.ArrMap(spec.Middlewares, w.cleanMiddlewareName), " -> "),
+			w.cleanMiddlewareName(spec.Handler),
 		}
 
 		lines = append(lines, line)
@@ -138,12 +148,40 @@ func (w *GinWrapper) DebugPrintRoutes() {
 		pad[3] = mathext.Max(pad[3], len(line[3]))
 	}
 
+	fmt.Printf("Gin-Routes:\n")
+	fmt.Printf("{\n")
 	for _, line := range lines {
 
-		fmt.Printf("Gin-Route: %s  %s  -->  %s  -->  %s\n",
+		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):]
+		}
+	}
+
+	return fname
 }

ginext/funcWrapper.go

@@ -14,7 +14,17 @@ func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
 
 		reqctx := g.Request.Context()
 
-		wrap, stackTrace, panicObj := callPanicSafe(fn, PreContext{wrapper: w, ginCtx: g})
+		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)
@@ -32,6 +42,17 @@ func Wrap(w *GinWrapper, fn WHandlerFunc) gin.HandlerFunc {
 			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/preContext.go

@@ -15,15 +15,20 @@ import (
 )
 
 type PreContext struct {
-	ginCtx  *gin.Context
-	wrapper *GinWrapper
-	uri     any
-	query   any
-	body    any
-	rawbody *[]byte
-	form    any
-	header  any
-	timeout *time.Duration
+	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
+}
+
+type preContextData struct {
+	sessionObj SessionObject
 }
 
 func (pctx *PreContext) URI(uri any) *PreContext {
@@ -61,6 +66,11 @@ func (pctx *PreContext) WithTimeout(to time.Duration) *PreContext {
 	return pctx
 }
 
+func (pctx *PreContext) WithSession(sessionObj SessionObject) *PreContext {
+	pctx.persistantData.sessionObj = sessionObj
+	return pctx
+}
+
 func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	if pctx.uri != nil {
 		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
@@ -152,6 +162,15 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	}
 
 	ictx, cancel := context.WithTimeout(context.Background(), langext.Coalesce(pctx.timeout, pctx.wrapper.requestTimeout))
+
+	if pctx.persistantData.sessionObj != nil {
+		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, ictx)
+		if err != nil {
+			cancel()
+			return nil, nil, langext.Ptr(Error(exerr.Wrap(err, "Failed to init session").Build()))
+		}
+	}
+
 	actx := CreateAppContext(pctx.ginCtx, ictx, cancel)
 
 	return actx, pctx.ginCtx, nil

ginext/response.go

@@ -5,6 +5,8 @@ import (
 	"github.com/gin-gonic/gin"
 	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"os"
 )
 
 type headerval struct {
@@ -15,6 +17,16 @@ type headerval struct {
 type HTTPResponse interface {
 	Write(g *gin.Context)
 	WithHeader(k string, v string) HTTPResponse
+	IsSuccess() bool
+}
+
+type InspectableHTTPResponse interface {
+	HTTPResponse
+
+	Statuscode() int
+	BodyString(g *gin.Context) *string
+	ContentType() string
+	Headers() []string
 }
 
 type jsonHTTPResponse struct {
@@ -23,15 +35,19 @@ type jsonHTTPResponse struct {
 	headers    []headerval
 }
 
-func (j jsonHTTPResponse) Write(g *gin.Context) {
-	for _, v := range j.headers {
-		g.Header(v.Key, v.Val)
-	}
+func (j jsonHTTPResponse) jsonRenderer(g *gin.Context) json.GoJsonRender {
 	var f *string
 	if jsonfilter := g.GetString("goext.jsonfilter"); jsonfilter != "" {
 		f = &jsonfilter
 	}
-	g.Render(j.statusCode, json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true, Filter: f})
+	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)
+	}
+	g.Render(j.statusCode, j.jsonRenderer(g))
 }
 
 func (j jsonHTTPResponse) WithHeader(k string, v string) HTTPResponse {
@@ -39,6 +55,30 @@ func (j jsonHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type emptyHTTPResponse struct {
 	statusCode int
 	headers    []headerval
@@ -56,6 +96,26 @@ func (j emptyHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type textHTTPResponse struct {
 	statusCode int
 	data       string
@@ -74,6 +134,26 @@ func (j textHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type dataHTTPResponse struct {
 	statusCode  int
 	data        []byte
@@ -93,6 +173,26 @@ func (j dataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type fileHTTPResponse struct {
 	mimetype string
 	filepath string
@@ -117,6 +217,30 @@ func (j fileHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type downloadDataHTTPResponse struct {
 	statusCode int
 	mimetype   string
@@ -142,6 +266,26 @@ func (j downloadDataHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type redirectHTTPResponse struct {
 	statusCode int
 	url        string
@@ -157,6 +301,26 @@ func (j redirectHTTPResponse) WithHeader(k string, v string) HTTPResponse {
 	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 })
+}
+
 type jsonAPIErrResponse struct {
 	err     *exerr.ExErr
 	headers []headerval
@@ -164,6 +328,8 @@ type jsonAPIErrResponse struct {
 
 func (j jsonAPIErrResponse) Write(g *gin.Context) {
 	j.err.Output(g)
+
+	j.err.CallListener(exerr.MethodOutput)
 }
 
 func (j jsonAPIErrResponse) WithHeader(k string, v string) HTTPResponse {
@@ -171,6 +337,34 @@ func (j jsonAPIErrResponse) WithHeader(k string, v string) HTTPResponse {
 	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 Status(sc int) HTTPResponse {
 	return &emptyHTTPResponse{statusCode: sc}
 }

ginext/routes.go

@@ -3,11 +3,9 @@ package ginext
 import (
 	"github.com/gin-gonic/gin"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
-	"gogs.mikescher.com/BlackForestBytes/goext/rext"
 	"net/http"
 	"path"
 	"reflect"
-	"regexp"
 	"runtime"
 	"strings"
 )
@@ -196,12 +194,6 @@ func nameOfFunction(f any) string {
 		fname = fname[:len(fname)-len("-fm")]
 	}
 
-	suffix := rext.W(regexp.MustCompile(`\.func[0-9]+(?:\.[0-9]+)*$`))
-
-	if match, ok := suffix.MatchFirst(fname); ok {
-		fname = fname[:len(fname)-match.FullMatch().Length()]
-	}
-
 	return fname
 }
 

ginext/session.go

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

go.mod

@@ -1,22 +1,24 @@
 module gogs.mikescher.com/BlackForestBytes/goext
 
-go 1.19
+go 1.21
 
 require (
 	github.com/gin-gonic/gin v1.9.1
 	github.com/jmoiron/sqlx v1.3.5
 	github.com/rs/xid v1.5.0
 	github.com/rs/zerolog v1.31.0
-	go.mongodb.org/mongo-driver v1.13.0
-	golang.org/x/crypto v0.15.0
-	golang.org/x/sys v0.14.0
-	golang.org/x/term v0.14.0
+	go.mongodb.org/mongo-driver v1.13.1
+	golang.org/x/crypto v0.17.0
+	golang.org/x/sys v0.16.0
+	golang.org/x/term v0.16.0
+	github.com/glebarez/go-sqlite  v1.22.0 // only needed for tests -.-
 )
 
 require (
 	github.com/bytedance/sonic v1.10.2 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.1 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
@@ -24,8 +26,9 @@ require (
 	github.com/go-playground/validator/v10 v10.16.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/uuid v1.5.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.17.2 // indirect
+	github.com/klauspost/compress v1.17.4 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.6 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
@@ -33,17 +36,22 @@ require (
 	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/pelletier/go-toml/v2 v2.1.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.1 // 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.2.11 // indirect
+	github.com/ugorji/go/codec v1.2.12 // 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
-	golang.org/x/arch v0.6.0 // indirect
-	golang.org/x/net v0.18.0 // indirect
-	golang.org/x/sync v0.5.0 // indirect
+	golang.org/x/arch v0.7.0 // indirect
+	golang.org/x/net v0.19.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
+	google.golang.org/protobuf v1.32.0 // 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

@@ -6,7 +6,6 @@ github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
-github.com/chenzhuoyu/iasm v0.9.0 h1:9fhXjVzq5hUy2gkhhgHl95zG2cEAhw9OSGs8toWWAwo=
 github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
 github.com/chenzhuoyu/iasm v0.9.1 h1:tUHQJXo3NhBqw6s33wkGn9SP3bvrWLdlVIJ3hQBL7P0=
 github.com/chenzhuoyu/iasm v0.9.1/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
@@ -14,21 +13,22 @@ github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV
 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/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
-github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
 github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 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-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
 github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+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.15.5 h1:LEBecTWb/1j5TNY1YYG2RcOUN3R7NLylN+x8TTueE24=
-github.com/go-playground/validator/v10 v10.15.5/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-playground/validator/v10 v10.16.0 h1:x+plE831WK4vaKHO/jpgUGsvLKIqRRkz6M78GuJAfGE=
 github.com/go-playground/validator/v10 v10.16.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
@@ -36,7 +36,6 @@ github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LB
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -44,20 +43,18 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
 github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.17.0 h1:Rnbp4K9EjcDuVuHtd0dgA4qNuv9yKDYKK1ulpJwgrqM=
-github.com/klauspost/compress v1.17.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/klauspost/compress v1.17.1 h1:NE3C767s2ak2bweCZo3+rdP4U/HoyVXLv/X9f2gPS5g=
-github.com/klauspost/compress v1.17.1/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
-github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4=
+github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
-github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
 github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
@@ -68,12 +65,12 @@ github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 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-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
 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.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg=
 github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+github.com/mattn/go-sqlite3 v1.14.19 h1:fhGleo2h1p8tVChob4I9HpmVFIAkKGpiukdrgQbWfGI=
+github.com/mattn/go-sqlite3 v1.14.19/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 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=
@@ -82,11 +79,13 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
 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/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
-github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
+github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 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 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
@@ -104,8 +103,8 @@ github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcU
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 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.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
-github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+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/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.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
@@ -116,41 +115,29 @@ github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7Jul
 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.12.1 h1:nLkghSU8fQNaK7oUmDhQFsnrtcoNy7Z6LVFKsEecqgE=
-go.mongodb.org/mongo-driver v1.12.1/go.mod h1:/rGBTebI3XYboVmgz+Wv3Bcbl3aD0QF9zl6kDDw18rQ=
-go.mongodb.org/mongo-driver v1.13.0 h1:67DgFFjYOCMWdtTEmKFpV3ffWlFnh+CYZ8ZS/tXWUfY=
-go.mongodb.org/mongo-driver v1.13.0/go.mod h1:/rGBTebI3XYboVmgz+Wv3Bcbl3aD0QF9zl6kDDw18rQ=
+go.mongodb.org/mongo-driver v1.13.1 h1:YIc7HTYsKndGK4RFzJ3covLz1byri52x0IoMB0Pt/vk=
+go.mongodb.org/mongo-driver v1.13.1/go.mod h1:wcDf1JBCXy2mOW0bWHwO/IOYqdca1MPCwDtFu/Z9+eo=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.5.0 h1:jpGode6huXQxcskEIpOCvrU+tzo81b6+oFLUYXWtH/Y=
-golang.org/x/arch v0.5.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.6.0 h1:S0JTfE48HbRj80+4tbvZDYsJ3tGv6BUU3XxyZ7CirAc=
-golang.org/x/arch v0.6.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.7.0 h1:pskyeJh/3AmoQ8CPE95vxHLqp1G1GfGNXTmcl9NEKTc=
+golang.org/x/arch v0.7.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 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.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
-golang.org/x/crypto v0.15.0 h1:frVn1TEaCEaZcn3Tmd7Y2b5KKPaZ+I32Q2OA3kYp5TA=
-golang.org/x/crypto v0.15.0/go.mod h1:4ChreQoLWfG3xLDer1WdlH5NdlQ3+mwnQq1YTKY+72g=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 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.16.0 h1:7eBu7KsSvFDtSXUIDbh3aqlK4DPsZ1rByC8PFfBThos=
-golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/net v0.18.0 h1:mIYleuAkSbHh0tCv7RvjL3F6ZVbLjq4+R7zbOn3Kokg=
-golang.org/x/net v0.18.0/go.mod h1:/czyP5RqHAH4odGYxBJ1qz0+CE5WZ+2j1YgoEo8F2jQ=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/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.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
-golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=
-golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 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=
@@ -162,39 +149,41 @@ golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
-golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 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.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
-golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
-golang.org/x/term v0.14.0 h1:LGK9IlZ8T9jvdy6cTdfKUCltatMFOehAQo9SRC46UQ8=
-golang.org/x/term v0.14.0/go.mod h1:TySc+nGkYR6qt8km8wUhuFRTVSMIX3XPR58y2lC8vww=
+golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
 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.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 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=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 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/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=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.309"
+const GoextVersion = "0.0.362"
 
-const GoextVersionTimestamp = "2023-11-09T10:17:29+0100"
+const GoextVersionTimestamp = "2024-01-07T04:18:03+0100"

gojson/gionic.go

@@ -37,6 +37,14 @@ func (r GoJsonRender) Render(w http.ResponseWriter) error {
 	return nil
 }
 
+func (r GoJsonRender) RenderString() (string, error) {
+	jsonBytes, err := MarshalSafeCollections(r.Data, r.NilSafeSlices, r.NilSafeMaps, r.Indent, r.Filter)
+	if err != nil {
+		panic(err)
+	}
+	return string(jsonBytes), nil
+}
+
 func (r GoJsonRender) WriteContentType(w http.ResponseWriter) {
 	header := w.Header()
 	if val := header["Content-Type"]; len(val) == 0 {

googleapi/README.md

@@ -0,0 +1,54 @@
+
+Google OAuth Setup (to send mails)
+==================================
+
+
+ - Login @ https://console.cloud.google.com
+
+ - GMail API akivieren: https://console.cloud.google.com/apis/library/gmail.googleapis.com?
+
+ - Create new Project (aka 'BackendMailAPI') @ https://console.cloud.google.com/projectcreate
+   User Type: Intern
+   Anwendungsname: 'BackendMailAPI'
+   Support-Email: ...
+   Authorisierte Domains: 'heydyno.de' (or project domain)
+   Kontakt-Email: ...
+   
+
+ - Unter "Anmeldedaten" neuer OAuth Client erstellen @ https://console.cloud.google.com/apis/credentials
+   Anwendungstyp: Web
+   Name: 'BackendMailOAuth'
+   Redirect-Uri: 'http://localhost/oauth'
+   Client-ID und Client-Key merken
+
+ - Open in Browser:
+   https://accounts.google.com/o/oauth2/v2/auth?redirect_uri=http://localhost/oauth&prompt=consent&response_type=code&client_id={...}&scope=https://www.googleapis.com/auth/gmail.send&access_type=offline
+   Code aus redirected URI merken
+
+ - Code via request einlösen (und refresh_roken merken):
+
+```
+curl --request POST \
+  --url https://oauth2.googleapis.com/token \
+  --data code={...} \
+  --data redirect_uri=http://localhost/oauth \
+  --data client_id={...} \
+  --data client_secret={...} \
+  --data grant_type=authorization_code \
+  --data scope=https://www.googleapis.com/auth/gmail.send
+```
+
+ - Fertig, mit `client_id`, `client_secret` und `refresh_token` kann das package benutzt werden
+
+
+
+
+
+
+
+
+
+
+
+
+

googleapi/attachment.go

@@ -0,0 +1,46 @@
+package googleapi
+
+import (
+	"encoding/base64"
+	"fmt"
+)
+
+type MailAttachment struct {
+	IsInline    bool
+	ContentType string
+	Filename    string
+	Data        []byte
+}
+
+func (a MailAttachment) dump() []string {
+	res := make([]string, 0, 4)
+
+	if a.ContentType != "" {
+		res = append(res, "Content-Type: "+a.ContentType+"; charset=UTF-8")
+	}
+
+	res = append(res, "Content-Transfer-Encoding: base64")
+
+	if a.IsInline {
+		if a.Filename != "" {
+			res = append(res, fmt.Sprintf("Content-Disposition: inline;filename=\"%s\"", a.Filename))
+		} else {
+			res = append(res, "Content-Disposition: inline")
+		}
+	} else {
+		if a.Filename != "" {
+			res = append(res, fmt.Sprintf("Content-Disposition: attachment;filename=\"%s\"", a.Filename))
+		} else {
+			res = append(res, "Content-Disposition: attachment")
+		}
+	}
+
+	b64 := base64.StdEncoding.EncodeToString(a.Data)
+	for i := 0; i < len(b64); i += 80 {
+		res = append(res, b64[i:min(i+80, len(b64))])
+	}
+
+	res = append(res)
+
+	return res
+}

googleapi/body.go

@@ -0,0 +1,6 @@
+package googleapi
+
+type MailBody struct {
+	Plain string
+	HTML  string
+}

googleapi/mimeMessage.go

@@ -0,0 +1,224 @@
+package googleapi
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"mime"
+	"strings"
+	"time"
+)
+
+// https://datatracker.ietf.org/doc/html/rfc2822
+func encodeMimeMail(from string, recipients []string, cc []string, bcc []string, subject string, body MailBody, attachments []MailAttachment) string {
+
+	data := make([]string, 0, 32)
+
+	data = append(data, "Date: "+time.Now().Format(time.RFC1123Z))
+	data = append(data, "MIME-Version: 1.0")
+	data = append(data, "From: "+mime.QEncoding.Encode("UTF-8", from))
+	data = append(data, "To: "+strings.Join(langext.ArrMap(recipients, func(v string) string { return mime.QEncoding.Encode("UTF-8", v) }), ", "))
+	if len(cc) > 0 {
+		data = append(data, "To: "+strings.Join(langext.ArrMap(cc, func(v string) string { return mime.QEncoding.Encode("UTF-8", v) }), ", "))
+	}
+	if len(bcc) > 0 {
+		data = append(data, "Bcc: "+strings.Join(langext.ArrMap(bcc, func(v string) string { return mime.QEncoding.Encode("UTF-8", v) }), ", "))
+	}
+	data = append(data, "Subject: "+mime.QEncoding.Encode("UTF-8", subject))
+
+	hasInlineAttachments := langext.ArrAny(attachments, func(v MailAttachment) bool { return v.IsInline })
+	hasNormalAttachments := langext.ArrAny(attachments, func(v MailAttachment) bool { return !v.IsInline })
+	hasPlain := body.Plain != ""
+	hasHTML := body.HTML != ""
+
+	mixedBoundary := langext.MustRawHexUUID()
+	relatedBoundary := langext.MustRawHexUUID()
+	altBoundary := langext.MustRawHexUUID()
+
+	inlineAttachments := langext.ArrFilter(attachments, func(v MailAttachment) bool { return v.IsInline })
+	normalAttachments := langext.ArrFilter(attachments, func(v MailAttachment) bool { return !v.IsInline })
+
+	if hasInlineAttachments && hasNormalAttachments {
+		// "mixed+related"
+
+		data = append(data, "Content-Type: multipart/mixed; boundary="+mixedBoundary)
+		data = append(data, "")
+		data = append(data, "--"+mixedBoundary)
+
+		data = append(data, "Content-Type: multipart/related; boundary="+relatedBoundary)
+		data = append(data, "")
+
+		data = append(data, dumpMailBody(body, hasInlineAttachments, hasNormalAttachments, relatedBoundary, altBoundary)...)
+		data = append(data, "")
+
+		for i, attachment := range inlineAttachments {
+			data = append(data, "--"+relatedBoundary)
+			data = append(data, attachment.dump()...)
+
+			if i < len(inlineAttachments)-1 {
+				data = append(data, "")
+			}
+		}
+
+		data = append(data, "--"+relatedBoundary+"--")
+
+		for i, attachment := range normalAttachments {
+			data = append(data, "--"+mixedBoundary)
+			data = append(data, attachment.dump()...)
+
+			if i < len(normalAttachments)-1 {
+				data = append(data, "")
+			}
+		}
+
+		data = append(data, "--"+mixedBoundary+"--")
+
+	} else if hasNormalAttachments {
+		// "mixed"
+
+		data = append(data, "Content-Type: multipart/mixed; boundary="+mixedBoundary)
+		data = append(data, "")
+
+		data = append(data, dumpMailBody(body, hasInlineAttachments, hasNormalAttachments, mixedBoundary, altBoundary)...)
+		if hasPlain && hasHTML {
+			data = append(data, "")
+		}
+
+		for i, attachment := range normalAttachments {
+			data = append(data, "--"+mixedBoundary)
+			data = append(data, attachment.dump()...)
+
+			if i < len(normalAttachments)-1 {
+				data = append(data, "")
+			}
+		}
+
+		data = append(data, "--"+mixedBoundary+"--")
+
+	} else if hasInlineAttachments {
+		// "related"
+
+		data = append(data, "Content-Type: multipart/related; boundary="+relatedBoundary)
+		data = append(data, "")
+
+		data = append(data, dumpMailBody(body, hasInlineAttachments, hasNormalAttachments, relatedBoundary, altBoundary)...)
+		data = append(data, "")
+
+		for i, attachment := range inlineAttachments {
+			data = append(data, "--"+relatedBoundary)
+			data = append(data, attachment.dump()...)
+
+			if i < len(inlineAttachments)-1 {
+				data = append(data, "")
+			}
+		}
+
+		data = append(data, "--"+relatedBoundary+"--")
+
+	} else if hasPlain && hasHTML {
+		// "alternative"
+
+		data = append(data, "Content-Type: multipart/alternative; boundary="+altBoundary)
+		data = append(data, "")
+
+		data = append(data, dumpMailBody(body, hasInlineAttachments, hasNormalAttachments, altBoundary, altBoundary)...)
+		data = append(data, "")
+
+		data = append(data, "--"+altBoundary+"--")
+
+	} else if hasPlain {
+		// "plain"
+
+		data = append(data, "Content-Type: text/plain; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.Plain)
+
+	} else if hasHTML {
+		// "plain"
+
+		data = append(data, "Content-Type: text/html; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.HTML)
+
+	} else {
+		// "empty??"
+
+	}
+
+	return strings.Join(data, "\r\n")
+}
+
+func dumpMailBody(body MailBody, hasInlineAttachments bool, hasNormalAttachments bool, boundary string, boundaryAlt string) []string {
+
+	if body.HTML != "" && body.Plain != "" && !hasInlineAttachments && hasNormalAttachments {
+		data := make([]string, 0, 16)
+		data = append(data, "--"+boundary)
+		data = append(data, "Content-Type: multipart/alternative; boundary="+boundaryAlt)
+		data = append(data, "")
+		data = append(data, "--"+boundaryAlt)
+		data = append(data, "Content-Type: text/plain; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.Plain)
+		data = append(data, "")
+		data = append(data, "--"+boundaryAlt)
+		data = append(data, "Content-Type: text/html; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.HTML)
+		data = append(data, "")
+		data = append(data, "--"+boundaryAlt+"--")
+		return data
+	}
+
+	if body.HTML != "" && body.Plain != "" && hasInlineAttachments {
+		data := make([]string, 0, 2)
+		data = append(data, "--"+boundary)
+		data = append(data, body.HTML)
+		return data
+	}
+
+	if body.HTML != "" && body.Plain != "" {
+		data := make([]string, 0, 8)
+		data = append(data, "--"+boundary)
+		data = append(data, "Content-Type: text/plain; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.Plain)
+		data = append(data, "")
+		data = append(data, "--"+boundary)
+		data = append(data, "Content-Type: text/html; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.HTML)
+		return data
+	}
+
+	if body.HTML != "" {
+		data := make([]string, 0, 2)
+		data = append(data, "--"+boundary)
+		data = append(data, "Content-Type: text/html; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.HTML)
+		return data
+	}
+
+	if body.Plain != "" {
+		data := make([]string, 0, 2)
+		data = append(data, "--"+boundary)
+		data = append(data, "Content-Type: text/plain; charset=UTF-8")
+		data = append(data, "Content-Transfer-Encoding: 7bit")
+		data = append(data, "")
+		data = append(data, body.Plain)
+		return data
+	}
+
+	data := make([]string, 0, 16)
+	data = append(data, "--"+boundary)
+	data = append(data, "Content-Type: text/plain; charset=UTF-8")
+	data = append(data, "Content-Transfer-Encoding: 7bit")
+	data = append(data, "")
+	data = append(data, "") // no content ?!?
+	return data
+}

googleapi/mimeMessage_test.go

@@ -0,0 +1,80 @@
+package googleapi
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"os"
+	"testing"
+)
+
+func TestEncodeMimeMail(t *testing.T) {
+
+	mail := encodeMimeMail(
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail",
+		MailBody{Plain: "Plain Text"},
+		nil)
+
+	verifyMime(mail)
+}
+
+func TestEncodeMimeMail2(t *testing.T) {
+
+	mail := encodeMimeMail(
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (alternative)",
+		MailBody{
+			Plain: "Plain Text",
+			HTML:  "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		nil)
+
+	verifyMime(mail)
+}
+
+func TestEncodeMimeMail3(t *testing.T) {
+
+	mail := encodeMimeMail(
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (alternative)",
+		MailBody{
+			HTML: "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		[]MailAttachment{
+			{Data: []byte("HelloWorld"), Filename: "test.txt", IsInline: false, ContentType: "text/plain"},
+		})
+
+	verifyMime(mail)
+}
+
+func TestEncodeMimeMail4(t *testing.T) {
+
+	b := tst.Must(os.ReadFile("test_placeholder.png"))(t)
+
+	mail := encodeMimeMail(
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (inline)",
+		MailBody{
+			HTML: "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		[]MailAttachment{
+			{Data: b, Filename: "img.png", IsInline: true, ContentType: "image/png"},
+		})
+
+	verifyMime(mail)
+}
+
+func verifyMime(mail string) {
+	//fmt.Printf("%s\n\n", mail)
+}

googleapi/oAuth.go

@@ -0,0 +1,91 @@
+package googleapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"io"
+	"net/http"
+	"sync"
+	"time"
+)
+
+type GoogleOAuth interface {
+	AccessToken() (string, error)
+}
+
+type oauth struct {
+	clientID     string
+	clientSecret string
+	refreshToken string
+
+	lock        sync.RWMutex
+	accessToken *string
+	expiryDate  *time.Time
+}
+
+func NewGoogleOAuth(clientid string, clientsecret, refreshtoken string) GoogleOAuth {
+	return &oauth{
+		clientID:     clientid,
+		clientSecret: clientsecret,
+		refreshToken: refreshtoken,
+	}
+}
+
+func (c *oauth) AccessToken() (string, error) {
+	c.lock.RLock()
+	if c.accessToken != nil && c.expiryDate != nil && (*c.expiryDate).After(time.Now()) {
+		c.lock.RUnlock()
+		return *c.accessToken, nil // still valid
+	}
+	c.lock.RUnlock()
+
+	httpclient := http.Client{}
+
+	url := fmt.Sprintf("https://oauth2.googleapis.com/token?client_id=%s&client_secret=%s&grant_type=%s&refresh_token=%s",
+		c.clientID,
+		c.clientSecret,
+		"refresh_token",
+		c.refreshToken)
+
+	req, err := http.NewRequest(http.MethodPost, url, nil)
+	if err != nil {
+		return "", err
+	}
+
+	reqStartTime := time.Now()
+
+	res, err := httpclient.Do(req)
+
+	type response struct {
+		AccessToken string `json:"access_token"`
+		ExpiresIn   int    `json:"expires_in"`
+		Scope       string `json:"scope"`
+		TokenType   string `json:"token_type"`
+	}
+
+	var r response
+
+	data, err := io.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+
+	err = json.Unmarshal(data, &r)
+	if err != nil {
+		return "", err
+	}
+
+	if r.ExpiresIn == 0 || r.AccessToken == "" {
+		return "", exerr.New(exerr.TypeGoogleResponse, "google oauth returned no response").Str("body", string(data)).Build()
+	}
+
+	c.lock.Lock()
+	c.expiryDate = langext.Ptr(reqStartTime.Add(timeext.FromSeconds(r.ExpiresIn - 10)))
+	c.accessToken = langext.Ptr(r.AccessToken)
+	c.lock.Unlock()
+
+	return r.AccessToken, nil
+}

googleapi/sendMail.go

@@ -0,0 +1,69 @@
+package googleapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"io"
+	"net/http"
+)
+
+type MailRef struct {
+	ID       string   `json:"id"`
+	ThreadID string   `json:"threadId"`
+	LabelIDs []string `json:"labelIds"`
+}
+
+func (c *client) SendMail(ctx context.Context, from string, recipients []string, cc []string, bcc []string, subject string, body MailBody, attachments []MailAttachment) (MailRef, error) {
+
+	mm := encodeMimeMail(from, recipients, cc, bcc, subject, body, attachments)
+
+	tok, err := c.oauth.AccessToken()
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Build()
+	}
+
+	url := fmt.Sprintf("https://gmail.googleapis.com/gmail/v1/users/%s/messages/send?alt=json&prettyPrint=false", "me")
+
+	msgbody, err := json.Marshal(langext.H{"raw": base64.URLEncoding.EncodeToString([]byte(mm))})
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Build()
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(msgbody))
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Build()
+	}
+
+	req.Header.Add("Authorization", "Bearer "+tok)
+	req.Header.Add("X-Goog-Api-Client", "blackforestbytes-goext/"+goext.GoextVersion)
+	req.Header.Add("User-Agent", "blackforestbytes-goext/"+goext.GoextVersion)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Build()
+	}
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Build()
+	}
+
+	if resp.StatusCode != 200 {
+		return MailRef{}, exerr.New(exerr.TypeGoogleStatuscode, "gmail returned non-200 statuscode").Int("sc", resp.StatusCode).Str("body", string(respBody)).Build()
+	}
+
+	var respObj MailRef
+	err = json.Unmarshal(respBody, &respObj)
+	if err != nil {
+		return MailRef{}, exerr.Wrap(err, "").Str("body", string(respBody)).Build()
+	}
+
+	return respObj, nil
+}

googleapi/sendMail_test.go

@@ -0,0 +1,151 @@
+package googleapi
+
+import (
+	"context"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"os"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	if !exerr.Initialized() {
+		exerr.Init(exerr.ErrorPackageConfigInit{ZeroLogErrTraces: langext.PFalse, ZeroLogAllTraces: langext.PFalse})
+	}
+	os.Exit(m.Run())
+}
+
+func TestSendMail1(t *testing.T) {
+	t.Skip()
+	return
+
+	auth := NewGoogleOAuth(
+		"554617284247-8di0j6s5dcmlk4lmk4hdf9kdn8scss54.apps.googleusercontent.com",
+		"TODO",
+		"TODO")
+
+	ctx := context.Background()
+
+	gclient := NewGoogleClient(auth)
+
+	mail, err := gclient.SendMail(
+		ctx,
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail",
+		MailBody{Plain: "Plain Text"},
+		nil)
+
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("mail.ID        := %s\n", mail.ID)
+	fmt.Printf("mail.ThreadID  := %s\n", mail.ThreadID)
+	fmt.Printf("mail.LabelIDs  := %v\n", mail.LabelIDs)
+}
+
+func TestSendMail2(t *testing.T) {
+	t.Skip()
+	return
+
+	auth := NewGoogleOAuth(
+		"554617284247-8di0j6s5dcmlk4lmk4hdf9kdn8scss54.apps.googleusercontent.com",
+		"TODO",
+		"TODO")
+
+	ctx := context.Background()
+
+	gclient := NewGoogleClient(auth)
+
+	mail, err := gclient.SendMail(
+		ctx,
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (alternative)",
+		MailBody{
+			Plain: "Plain Text",
+			HTML:  "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		nil)
+
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("mail.ID        := %s\n", mail.ID)
+	fmt.Printf("mail.ThreadID  := %s\n", mail.ThreadID)
+	fmt.Printf("mail.LabelIDs  := %v\n", mail.LabelIDs)
+}
+
+func TestSendMail3(t *testing.T) {
+	t.Skip()
+	return
+
+	auth := NewGoogleOAuth(
+		"554617284247-8di0j6s5dcmlk4lmk4hdf9kdn8scss54.apps.googleusercontent.com",
+		"TODO",
+		"TODO")
+
+	ctx := context.Background()
+
+	gclient := NewGoogleClient(auth)
+
+	mail, err := gclient.SendMail(
+		ctx,
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (attach)",
+		MailBody{
+			HTML: "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		[]MailAttachment{
+			{Data: []byte("HelloWorld"), Filename: "test.txt", IsInline: false, ContentType: "text/plain"},
+		})
+
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("mail.ID        := %s\n", mail.ID)
+	fmt.Printf("mail.ThreadID  := %s\n", mail.ThreadID)
+	fmt.Printf("mail.LabelIDs  := %v\n", mail.LabelIDs)
+}
+
+func TestSendMail4(t *testing.T) {
+	t.Skip()
+	return
+
+	auth := NewGoogleOAuth(
+		"554617284247-8di0j6s5dcmlk4lmk4hdf9kdn8scss54.apps.googleusercontent.com",
+		"TODO",
+		"TODO")
+
+	ctx := context.Background()
+
+	gclient := NewGoogleClient(auth)
+
+	b := tst.Must(os.ReadFile("test_placeholder.png"))(t)
+
+	mail, err := gclient.SendMail(
+		ctx,
+		"noreply@heydyno.de",
+		[]string{"trash@mikescher.de"},
+		nil,
+		nil,
+		"Hello Test Mail (inline)",
+		MailBody{
+			HTML: "<html><body><u>Non</u> Pl<i>ai</i>n T<b>ex</b>t</body></html>",
+		},
+		[]MailAttachment{
+			{Data: b, Filename: "img.png", IsInline: true, ContentType: "image/png"},
+		})
+
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("mail.ID        := %s\n", mail.ID)
+	fmt.Printf("mail.ThreadID  := %s\n", mail.ThreadID)
+	fmt.Printf("mail.LabelIDs  := %v\n", mail.LabelIDs)
+}

googleapi/service.go

@@ -0,0 +1,22 @@
+package googleapi
+
+import (
+	"context"
+	"net/http"
+)
+
+type GoogleClient interface {
+	SendMail(ctx context.Context, from string, recipients []string, cc []string, bcc []string, subject string, body MailBody, attachments []MailAttachment) (MailRef, error)
+}
+
+type client struct {
+	oauth GoogleOAuth
+	http  http.Client
+}
+
+func NewGoogleClient(oauth GoogleOAuth) GoogleClient {
+	return &client{
+		oauth: oauth,
+		http:  http.Client{},
+	}
+}

langext/maps.go

@@ -29,6 +29,14 @@ func ArrToMap[T comparable, V any](a []V, keyfunc func(V) T) map[T]V {
 	return result
 }
 
+func ArrToKVMap[T any, K comparable, V any](a []T, keyfunc func(T) K, valfunc func(T) V) map[K]V {
+	result := make(map[K]V, len(a))
+	for _, v := range a {
+		result[keyfunc(v)] = valfunc(v)
+	}
+	return result
+}
+
 func ArrToSet[T comparable](a []T) map[T]bool {
 	result := make(map[T]bool, len(a))
 	for _, v := range a {

langext/pointer.go

@@ -10,10 +10,23 @@ var PTrue = Ptr(true)
 // PFalse := &false
 var PFalse = Ptr(false)
 
+// PNil := &nil
+var PNil = Ptr[any](nil)
+
 func Ptr[T any](v T) *T {
 	return &v
 }
 
+func DblPtr[T any](v T) **T {
+	v_ := &v
+	return &v_
+}
+
+func DblPtrNil[T any]() **T {
+	var v *T = nil
+	return &v
+}
+
 func PtrInt32(v int32) *int32 {
 	return &v
 }
@@ -35,7 +48,7 @@ func IsNil(i interface{}) bool {
 		return true
 	}
 	switch reflect.TypeOf(i).Kind() {
-	case reflect.Ptr, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice:
+	case reflect.Ptr, reflect.Map, reflect.Chan, reflect.Slice, reflect.Func, reflect.UnsafePointer:
 		return reflect.ValueOf(i).IsNil()
 	}
 	return false

mongoext/registry.go

@@ -5,6 +5,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
 	"reflect"
 )
@@ -18,9 +19,21 @@ func CreateGoExtBsonRegistry() *bsoncodec.Registry {
 	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
 	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.RFC3339NanoTime{}), rfctime.RFC3339NanoTime{})
 
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixTime{}), rfctime.UnixTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixTime{}), rfctime.UnixTime{})
+
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixMilliTime{}), rfctime.UnixMilliTime{})
+
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
+	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.UnixNanoTime{}), rfctime.UnixNanoTime{})
+
 	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.Date{}), rfctime.Date{})
 	rb.RegisterTypeDecoder(reflect.TypeOf(&rfctime.Date{}), rfctime.Date{})
 
+	rb.RegisterTypeDecoder(reflect.TypeOf(rfctime.SecondsF64(0)), rfctime.SecondsF64(0))
+	rb.RegisterTypeDecoder(reflect.TypeOf(langext.Ptr(rfctime.SecondsF64(0))), rfctime.SecondsF64(0))
+
 	bsoncodec.DefaultValueEncoders{}.RegisterDefaultEncoders(rb)
 	bsoncodec.DefaultValueDecoders{}.RegisterDefaultDecoders(rb)
 

pagination/pagination.go

@@ -1,16 +1,19 @@
 package pagination
 
 type Pagination struct {
-	Page             int `json:"page"`            // page (first page == 1)
-	Limit            int `json:"limit"`           // max-page-size
-	TotalPages       int `json:"totalPages"`      // total page-count
-	TotalItems       int `json:"totalItems"`      // total items-count
-	CurrentPageCount int `json:"currntPageCount"` // item-count in current page ( == len(data) )
+	Page             int `json:"page"`             // page (first page == 1)
+	Limit            int `json:"limit"`            // max-page-size
+	TotalPages       int `json:"totalPages"`       // total page-count
+	TotalItems       int `json:"totalItems"`       // total items-count
+	CurrentPageCount int `json:"currentPageCount"` // item-count in current page ( == len(data) )
 }
 
 func CalcPaginationTotalPages(totalItems int, limit int) int {
 	if totalItems == 0 {
 		return 0
 	}
+	if limit == 0 {
+		return 0
+	}
 	return 1 + (totalItems-1)/limit
 }

rfctime/seconds.go

@@ -2,7 +2,14 @@ package rfctime
 
 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"
 	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"reflect"
 	"time"
 )
 
@@ -54,6 +61,63 @@ func (d SecondsF64) MarshalJSON() ([]byte, error) {
 	return json.Marshal(secs)
 }
 
+func (d *SecondsF64) 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
+		*d = SecondsF64(0)
+		return nil
+	}
+	if bt != bson.TypeDouble {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into SecondsF64", bt))
+	}
+	var secValue float64
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&secValue)
+	if err != nil {
+		return err
+	}
+	*d = SecondsF64(int64(secValue * float64(time.Second)))
+	return nil
+}
+
+func (d SecondsF64) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(d.Seconds())
+}
+
+func (d SecondsF64) 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 = d.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&d))
+	} else {
+		val.Set(reflect.ValueOf(d))
+	}
+
+	return nil
+}
+
 func NewSecondsF64(t time.Duration) SecondsF64 {
 	return SecondsF64(t)
 }

rfctime/unix.go

@@ -2,6 +2,13 @@ package rfctime
 
 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"
 	"strconv"
 	"time"
 )
@@ -59,6 +66,63 @@ func (t *UnixTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
+func (t *UnixTime) 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
+		*t = UnixTime{}
+		return nil
+	}
+	if bt != bson.TypeDateTime {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixTime", bt))
+	}
+	var tt time.Time
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*t = UnixTime(tt)
+	return nil
+}
+
+func (t UnixTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(time.Time(t))
+}
+
+func (t UnixTime) 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 = t.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&t))
+	} else {
+		val.Set(reflect.ValueOf(t))
+	}
+
+	return nil
+}
+
 func (t UnixTime) Serialize() string {
 	return strconv.FormatInt(t.Time().Unix(), 10)
 }

rfctime/unixMilli.go

@@ -2,6 +2,13 @@ package rfctime
 
 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"
 	"strconv"
 	"time"
 )
@@ -59,6 +66,63 @@ func (t *UnixMilliTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
+func (t *UnixMilliTime) 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
+		*t = UnixMilliTime{}
+		return nil
+	}
+	if bt != bson.TypeDateTime {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixMilliTime", bt))
+	}
+	var tt time.Time
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*t = UnixMilliTime(tt)
+	return nil
+}
+
+func (t UnixMilliTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(time.Time(t))
+}
+
+func (t UnixMilliTime) 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 = t.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&t))
+	} else {
+		val.Set(reflect.ValueOf(t))
+	}
+
+	return nil
+}
+
 func (t UnixMilliTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixMilli(), 10)
 }

rfctime/unixNano.go

@@ -2,6 +2,13 @@ package rfctime
 
 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"
 	"strconv"
 	"time"
 )
@@ -59,6 +66,63 @@ func (t *UnixNanoTime) UnmarshalText(data []byte) error {
 	return nil
 }
 
+func (t *UnixNanoTime) 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
+		*t = UnixNanoTime{}
+		return nil
+	}
+	if bt != bson.TypeDateTime {
+		return errors.New(fmt.Sprintf("cannot unmarshal %v into UnixNanoTime", bt))
+	}
+	var tt time.Time
+	err := bson.RawValue{Type: bt, Value: data}.Unmarshal(&tt)
+	if err != nil {
+		return err
+	}
+	*t = UnixNanoTime(tt)
+	return nil
+}
+
+func (t UnixNanoTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(time.Time(t))
+}
+
+func (t UnixNanoTime) 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 = t.UnmarshalBSONValue(tp, src)
+	if err != nil {
+		return err
+	}
+
+	if val.Kind() == reflect.Ptr {
+		val.Set(reflect.ValueOf(&t))
+	} else {
+		val.Set(reflect.ValueOf(t))
+	}
+
+	return nil
+}
+
 func (t UnixNanoTime) Serialize() string {
 	return strconv.FormatInt(t.Time().UnixNano(), 10)
 }

scn/scn.go

@@ -0,0 +1,13 @@
+package scn
+
+type Connection struct {
+	uid   string
+	token string
+}
+
+func New(userid string, token string) *Connection {
+	return &Connection{
+		uid:   userid,
+		token: token,
+	}
+}

scn/send.go

@@ -0,0 +1,171 @@
+package scn
+
+import (
+	"bytes"
+	"context"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	json "gogs.mikescher.com/BlackForestBytes/goext/gojson"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"io"
+	"net/http"
+	"time"
+)
+
+var (
+	ErrAuthFailed        = exerr.NewType("GOEXT_SCN_AUTHFAILED", nil)
+	ErrQuota             = exerr.NewType("GOEXT_SCN_QUOTAEXCEEDED", nil)
+	ErrBadRequest        = exerr.NewType("GOEXT_SCN_BADREQUEST", nil)
+	ErrInternalServerErr = exerr.NewType("GOEXT_SCN_INTERNALSERVER", nil)
+	ErrOther             = exerr.NewType("GOEXT_SCN_OTHER", nil)
+)
+
+type MessageResponse struct {
+	ErrHighlight int    `json:"errhighlight"`
+	Error        int    `json:"error"`
+	IsPro        bool   `json:"is_pro"`
+	Message      string `json:"message"`
+	Messagecount int    `json:"messagecount"`
+	Quota        int    `json:"quota"`
+	QuotaMax     int    `json:"quota_max"`
+	SCNMessageID string `json:"scn_msg_id"`
+	Success      bool   `json:"success"`
+	SuppressSend bool   `json:"suppress_send"`
+}
+
+type MessageErrResponse struct {
+	Errhighlight int    `json:"errhighlight"`
+	Error        int    `json:"error"`
+	Message      string `json:"message"`
+	Success      bool   `json:"success"`
+}
+
+type MessageBuilder struct {
+	conn       *Connection
+	title      string
+	content    *string
+	channel    *string
+	time       *time.Time
+	sendername *string
+	priority   *int
+}
+
+func (c *Connection) Message(title string) *MessageBuilder {
+	return &MessageBuilder{conn: c, title: title}
+}
+
+func (c *MessageBuilder) Channel(channel string) *MessageBuilder {
+	c.channel = &channel
+	return c
+}
+
+func (c *MessageBuilder) Content(content string) *MessageBuilder {
+	c.content = &content
+	return c
+}
+
+func (c *MessageBuilder) Time(t time.Time) *MessageBuilder {
+	c.time = &t
+	return c
+}
+
+func (c *MessageBuilder) SenderName(sn string) *MessageBuilder {
+	c.sendername = &sn
+	return c
+}
+
+func (c *MessageBuilder) Priority(p int) *MessageBuilder {
+	c.priority = &p
+	return c
+}
+
+func (c *MessageBuilder) Send(ctx context.Context) (MessageResponse, error) {
+	client := http.Client{Timeout: 5 * time.Second}
+
+	body := langext.H{}
+
+	body["user_id"] = c.conn.uid
+	body["key"] = c.conn.token
+
+	if c.channel != nil {
+		body["channel"] = *c.channel
+	}
+
+	body["title"] = c.title
+
+	if c.content != nil {
+		body["content"] = *c.content
+	}
+
+	if c.sendername != nil {
+		body["content"] = *c.sendername
+	}
+
+	if c.time != nil {
+		body["timestamp"] = c.time.Unix()
+	}
+
+	if c.priority != nil {
+		body["priority"] = *c.priority
+	}
+
+	body["msg_id"] = langext.MustHexUUID()
+
+	rawbody, err := json.Marshal(body)
+	if err != nil {
+		return MessageResponse{}, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", "https://simplecloudnotifier.de/", bytes.NewBuffer(rawbody))
+	if err != nil {
+		return MessageResponse{}, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return MessageResponse{}, err
+	}
+
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+
+		raw, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return MessageResponse{}, err
+		}
+
+		var mr MessageResponse
+		err = json.Unmarshal(raw, &mr)
+		if err != nil {
+			return MessageResponse{}, err
+		}
+
+		return mr, nil
+	} else {
+		errMessage := resp.Status
+
+		if raw, err := io.ReadAll(resp.Body); err == nil {
+			var mr MessageErrResponse
+			if err = json.Unmarshal(raw, &mr); err == nil {
+				errMessage = mr.Message
+			}
+		}
+
+		if resp.StatusCode == 400 {
+			return MessageResponse{}, exerr.New(ErrBadRequest, errMessage).Build()
+		}
+		if resp.StatusCode == 401 {
+			return MessageResponse{}, exerr.New(ErrAuthFailed, errMessage).Build()
+		}
+		if resp.StatusCode == 403 {
+			return MessageResponse{}, exerr.New(ErrQuota, errMessage).Build()
+		}
+		if resp.StatusCode == 500 {
+			return MessageResponse{}, exerr.New(ErrInternalServerErr, errMessage).Build()
+		}
+
+		return MessageResponse{}, exerr.New(ErrOther, errMessage).Build()
+	}
+
+}

scn/send_test.go

@@ -0,0 +1,24 @@
+package scn
+
+import (
+	"context"
+	"fmt"
+	"testing"
+)
+
+func TestSendSCN(t *testing.T) {
+	t.Skip()
+	return
+
+	mr, err := New("TODO", "TODO").
+		Message("Hello Test").
+		Content("This is a test / goext").
+		Send(context.Background())
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("%+v\n", mr)
+
+}

sq/builder.go

@@ -0,0 +1,71 @@
+package sq
+
+import (
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"reflect"
+	"strings"
+)
+
+func BuildUpdateStatement(q Queryable, tableName string, obj any, idColumn string) (string, PP, error) {
+	rval := reflect.ValueOf(obj)
+	rtyp := rval.Type()
+
+	params := PP{}
+
+	setClauses := make([]string, 0)
+
+	matchClause := ""
+
+	for i := 0; i < rtyp.NumField(); i++ {
+
+		rsfield := rtyp.Field(i)
+		rvfield := rval.Field(i)
+
+		if !rsfield.IsExported() {
+			continue
+		}
+
+		columnName := rsfield.Tag.Get("db")
+		if columnName == "" || columnName == "-" {
+			continue
+		}
+
+		if idColumn == columnName {
+			idValue, err := convertValueToDB(q, rvfield.Interface())
+			if err != nil {
+				return "", nil, err
+			}
+
+			matchClause = fmt.Sprintf("(%s = :%s)", columnName, params.Add(idValue))
+
+			continue
+		}
+
+		if rsfield.Type.Kind() == reflect.Ptr && rvfield.IsNil() {
+
+			setClauses = append(setClauses, fmt.Sprintf("%s = NULL", columnName))
+
+		} else {
+
+			val, err := convertValueToDB(q, rvfield.Interface())
+			if err != nil {
+				return "", nil, err
+			}
+
+			setClauses = append(setClauses, fmt.Sprintf("(%s = :%s)", columnName, params.Add(val)))
+
+		}
+	}
+
+	if len(setClauses) == 0 {
+		return "", nil, exerr.New(exerr.TypeSQLBuild, "no updates clauses found in object").Build()
+	}
+
+	if matchClause == "" {
+		return "", nil, exerr.New(exerr.TypeSQLBuild, "id column not found in object").Build()
+	}
+
+	//goland:noinspection SqlNoDataSourceInspection
+	return fmt.Sprintf("UPDATE %s SET %s WHERE %s", tableName, strings.Join(setClauses, ", "), matchClause), params, nil
+}

sq/builder_test.go

@@ -0,0 +1,87 @@
+package sq
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"github.com/glebarez/go-sqlite"
+	"github.com/jmoiron/sqlx"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"path/filepath"
+	"testing"
+)
+
+type dummyQueryable struct {
+}
+
+func (d dummyQueryable) Exec(ctx context.Context, sql string, prep PP) (sql.Result, error) {
+	return nil, errors.New("err")
+}
+
+func (d dummyQueryable) Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error) {
+	return nil, errors.New("err")
+}
+
+func (d dummyQueryable) ListConverter() []DBTypeConverter {
+	return nil
+}
+
+func TestCreateUpdateStatement(t *testing.T) {
+
+	type request struct {
+		ID        string  `json:"id"        db:"id"`
+		Timestamp int     `json:"timestamp" db:"timestamp"`
+		StrVal    string  `json:"strVal"    db:"str_val"`
+		FloatVal  float64 `json:"floatVal"    db:"float_val"`
+		Dummy     bool    `json:"dummyBool" db:"dummy_bool"`
+		JsonVal   JsonObj `json:"jsonVal" db:"json_val"`
+	}
+
+	if !langext.InArray("sqlite3", sql.Drivers()) {
+		sqlite.RegisterAsSQLITE3()
+	}
+
+	ctx := context.Background()
+
+	dbdir := t.TempDir()
+	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
+
+	url := fmt.Sprintf("file:%s?_pragma=journal_mode(%s)&_pragma=timeout(%d)&_pragma=foreign_keys(%s)&_pragma=busy_timeout(%d)", dbfile1, "DELETE", 1000, "true", 1000)
+
+	xdb := tst.Must(sqlx.Open("sqlite", url))(t)
+
+	db := NewDB(xdb)
+	db.RegisterDefaultConverter()
+
+	_, err := db.Exec(ctx, "CREATE TABLE `requests` ( id TEXT NOT NULL, timestamp INTEGER NOT NULL, PRIMARY KEY (id) ) STRICT", PP{})
+	tst.AssertNoErr(t, err)
+
+	sqlStr, pp, err := BuildUpdateStatement(db, "requests", request{
+		ID:        "9927",
+		Timestamp: 12321,
+		StrVal:    "hello world",
+		Dummy:     true,
+		FloatVal:  3.14159,
+		JsonVal: JsonObj{
+			"firs":   1,
+			"second": true,
+		},
+	}, "id")
+
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("\n\n")
+
+	fmt.Printf("######## PP:\n")
+	for k, v := range pp {
+		fmt.Printf("['%s']       =>       %+v\n", k, v)
+	}
+	fmt.Printf("\n\n")
+
+	fmt.Printf("######## SQL:\n%+v\n\n", sqlStr)
+
+	fmt.Printf("\n\n")
+
+}

sq/converter.go

@@ -1,20 +1,16 @@
 package sq
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
+	"reflect"
 	"time"
 )
 
-//TODO UNFINISHED
-// this is not finished
-// idea was that we can register converter in the database struct
-// they get inherited from the transactions
-// and when marshallingunmarshaling (sq.Query | sq.QueryAll)
-// or marshaling (sq.InsertSingle)
-// the types get converter automatically...
-
 type DBTypeConverter interface {
 	ModelTypeString() string
 	DBTypeString() string
@@ -40,16 +36,108 @@ var ConverterTimeToUnixMillis = NewDBTypeConverter[time.Time, int64](func(v time
 	return time.UnixMilli(v), nil
 })
 
-var ConverterOptTimeToUnixMillis = NewDBTypeConverter[*time.Time, *int64](func(v *time.Time) (*int64, error) {
-	if v == nil {
-		return nil, nil
+var ConverterRFCUnixMilliTimeToUnixMillis = NewDBTypeConverter[rfctime.UnixMilliTime, int64](func(v rfctime.UnixMilliTime) (int64, error) {
+	return v.UnixMilli(), nil
+}, func(v int64) (rfctime.UnixMilliTime, error) {
+	return rfctime.NewUnixMilli(time.UnixMilli(v)), nil
+})
+
+var ConverterRFCUnixNanoTimeToUnixNanos = NewDBTypeConverter[rfctime.UnixNanoTime, int64](func(v rfctime.UnixNanoTime) (int64, error) {
+	return v.UnixNano(), nil
+}, func(v int64) (rfctime.UnixNanoTime, error) {
+	return rfctime.NewUnixNano(time.Unix(0, v)), nil
+})
+
+var ConverterRFCUnixTimeToUnixSeconds = NewDBTypeConverter[rfctime.UnixTime, int64](func(v rfctime.UnixTime) (int64, error) {
+	return v.Unix(), nil
+}, func(v int64) (rfctime.UnixTime, error) {
+	return rfctime.NewUnix(time.Unix(v, 0)), nil
+})
+
+// ConverterRFC339TimeToString
+// Does not really use RFC339 - but sqlite does not understand timezones and the `T` delimiter
+var ConverterRFC339TimeToString = NewDBTypeConverter[rfctime.RFC3339Time, string](func(v rfctime.RFC3339Time) (string, error) {
+	return v.Time().In(time.UTC).Format("2006-01-02 15:04:05"), nil
+}, func(v string) (rfctime.RFC3339Time, error) {
+	t, err := time.Parse("2006-01-02 15:04:05", v)
+	if err != nil {
+		return rfctime.RFC3339Time{}, err
 	}
-	return langext.Ptr(v.UnixMilli()), nil
-}, func(v *int64) (*time.Time, error) {
-	if v == nil {
-		return nil, nil
+	return rfctime.NewRFC3339(t), nil
+})
+
+// ConverterRFC339NanoTimeToString
+// Does not really use RFC339 - but sqlite does not understand timezones and the `T` delimiter
+var ConverterRFC339NanoTimeToString = NewDBTypeConverter[rfctime.RFC3339NanoTime, string](func(v rfctime.RFC3339NanoTime) (string, error) {
+	return v.Time().In(time.UTC).Format("2006-01-02 15:04:05.999999999"), nil
+}, func(v string) (rfctime.RFC3339NanoTime, error) {
+	t, err := time.ParseInLocation("2006-01-02 15:04:05.999999999", v, time.UTC)
+	if err != nil {
+		return rfctime.RFC3339NanoTime{}, err
 	}
-	return langext.Ptr(time.UnixMilli(*v)), nil
+	return rfctime.NewRFC3339Nano(t), nil
+})
+
+var ConverterJsonObjToString = NewDBTypeConverter[JsonObj, string](func(v JsonObj) (string, error) {
+	mrsh, err := json.Marshal(v)
+	if err != nil {
+		return "", err
+	}
+	return string(mrsh), nil
+}, func(v string) (JsonObj, error) {
+	var mrsh JsonObj
+	if err := json.Unmarshal([]byte(v), &mrsh); err != nil {
+		return JsonObj{}, err
+	}
+	return mrsh, nil
+})
+
+var ConverterJsonArrToString = NewDBTypeConverter[JsonArr, string](func(v JsonArr) (string, error) {
+	mrsh, err := json.Marshal(v)
+	if err != nil {
+		return "", err
+	}
+	return string(mrsh), nil
+}, func(v string) (JsonArr, error) {
+	var mrsh JsonArr
+	if err := json.Unmarshal([]byte(v), &mrsh); err != nil {
+		return JsonArr{}, err
+	}
+	return mrsh, nil
+})
+
+var ConverterExErrCategoryToString = NewDBTypeConverter[exerr.ErrorCategory, string](func(v exerr.ErrorCategory) (string, error) {
+	return v.Category, nil
+}, func(v string) (exerr.ErrorCategory, error) {
+	for _, cat := range exerr.AllCategories {
+		if cat.Category == v {
+			return cat, nil
+		}
+	}
+	return exerr.CatUser, errors.New("failed to convert '" + v + "' to exerr.ErrorCategory")
+})
+
+var ConverterExErrSeverityToString = NewDBTypeConverter[exerr.ErrorSeverity, string](func(v exerr.ErrorSeverity) (string, error) {
+	return v.Severity, nil
+}, func(v string) (exerr.ErrorSeverity, error) {
+	for _, sev := range exerr.AllSeverities {
+		if sev.Severity == v {
+			return sev, nil
+		}
+	}
+	return exerr.SevErr, errors.New("failed to convert '" + v + "' to exerr.ErrorSeverity")
+})
+
+var ConverterExErrTypeToString = NewDBTypeConverter[exerr.ErrorType, string](func(v exerr.ErrorType) (string, error) {
+	return v.Key, nil
+}, func(v string) (exerr.ErrorType, error) {
+	for _, etp := range exerr.ListRegisteredTypes() {
+		if etp.Key == v {
+			return etp, nil
+		}
+	}
+
+	return exerr.NewType(v, nil), nil
 })
 
 type dbTypeConverterImpl[TModelData any, TDBData any] struct {
@@ -89,3 +177,36 @@ func NewDBTypeConverter[TModelData any, TDBData any](todb func(v TModelData) (TD
 		tomodel:         tomodel,
 	}
 }
+
+func convertValueToDB(q Queryable, value any) (any, error) {
+	modelTypeStr := fmt.Sprintf("%T", value)
+
+	for _, conv := range q.ListConverter() {
+		if conv.ModelTypeString() == modelTypeStr {
+			return conv.ModelToDB(value)
+		}
+	}
+
+	if value != nil && reflect.TypeOf(value).Kind() == reflect.Ptr {
+		vof := reflect.ValueOf(value)
+		if vof.IsNil() {
+			return nil, nil
+		} else {
+			return convertValueToDB(q, vof.Elem().Interface())
+		}
+	}
+
+	return value, nil
+}
+
+func convertValueToModel(q Queryable, value any, destinationType string) (any, error) {
+	dbTypeString := fmt.Sprintf("%T", value)
+
+	for _, conv := range q.ListConverter() {
+		if conv.ModelTypeString() == destinationType && conv.DBTypeString() == dbTypeString {
+			return conv.DBToModel(value)
+		}
+	}
+
+	return value, nil
+}

sq/database.go

@@ -4,16 +4,19 @@ import (
 	"context"
 	"database/sql"
 	"github.com/jmoiron/sqlx"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"sync"
 )
 
 type DB interface {
-	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
-	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
+	Queryable
+
 	Ping(ctx context.Context) error
 	BeginTransaction(ctx context.Context, iso sql.IsolationLevel) (Tx, error)
 	AddListener(listener Listener)
 	Exit() error
+	RegisterConverter(DBTypeConverter)
+	RegisterDefaultConverter()
 }
 
 type database struct {
@@ -21,6 +24,7 @@ type database struct {
 	txctr uint16
 	lock  sync.Mutex
 	lstr  []Listener
+	conv  []DBTypeConverter
 }
 
 func NewDB(db *sqlx.DB) DB {
@@ -120,9 +124,33 @@ func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel
 		v.PostTxBegin(txid, err)
 	}
 
-	return NewTransaction(xtx, txid, db.lstr), nil
+	return NewTransaction(xtx, txid, db), nil
 }
 
 func (db *database) Exit() error {
 	return db.db.Close()
 }
+
+func (db *database) ListConverter() []DBTypeConverter {
+	return db.conv
+}
+
+func (db *database) RegisterConverter(conv DBTypeConverter) {
+	db.conv = langext.ArrFilter(db.conv, func(v DBTypeConverter) bool { return v.ModelTypeString() != conv.ModelTypeString() })
+	db.conv = append(db.conv, conv)
+}
+
+func (db *database) RegisterDefaultConverter() {
+	db.RegisterConverter(ConverterBoolToBit)
+	db.RegisterConverter(ConverterTimeToUnixMillis)
+	db.RegisterConverter(ConverterRFCUnixMilliTimeToUnixMillis)
+	db.RegisterConverter(ConverterRFCUnixNanoTimeToUnixNanos)
+	db.RegisterConverter(ConverterRFCUnixTimeToUnixSeconds)
+	db.RegisterConverter(ConverterRFC339TimeToString)
+	db.RegisterConverter(ConverterRFC339NanoTimeToString)
+	db.RegisterConverter(ConverterJsonObjToString)
+	db.RegisterConverter(ConverterJsonArrToString)
+	db.RegisterConverter(ConverterExErrCategoryToString)
+	db.RegisterConverter(ConverterExErrSeverityToString)
+	db.RegisterConverter(ConverterExErrTypeToString)
+}

sq/hasher.go

@@ -13,7 +13,9 @@ import (
 	"strings"
 )
 
-func HashSqliteSchema(ctx context.Context, schemaStr string) (string, error) {
+// HashMattnSqliteSchema
+// use if github.com/glebarez/go-sqlite
+func HashMattnSqliteSchema(ctx context.Context, schemaStr string) (string, error) {
 	dbdir := os.TempDir()
 	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
 
@@ -39,6 +41,34 @@ func HashSqliteSchema(ctx context.Context, schemaStr string) (string, error) {
 	return HashSqliteDatabase(ctx, db)
 }
 
+// HashGoSqliteSchema
+// use if mattn/go-sqlite3
+func HashGoSqliteSchema(ctx context.Context, schemaStr string) (string, error) {
+	dbdir := os.TempDir()
+	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
+
+	err := os.MkdirAll(dbdir, os.ModePerm)
+	if err != nil {
+		return "", err
+	}
+
+	url := fmt.Sprintf("file:%s?_pragma=journal_mode(%s)&_pragma=timeout(%d)&_pragma=foreign_keys(%s)&_pragma=busy_timeout(%d)", dbfile1, "DELETE", 1000, "true", 1000)
+
+	xdb, err := sqlx.Open("sqlite", url)
+	if err != nil {
+		return "", err
+	}
+
+	db := NewDB(xdb)
+
+	_, err = db.Exec(ctx, schemaStr, PP{})
+	if err != nil {
+		return "", err
+	}
+
+	return HashSqliteDatabase(ctx, db)
+}
+
 func HashSqliteDatabase(ctx context.Context, db Queryable) (string, error) {
 	ss, err := CreateSqliteDatabaseSchemaString(ctx, db)
 	if err != nil {
@@ -91,7 +121,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 	if err != nil {
 		return "", err
 	}
-	tableList, err := ScanAll[tabInfo](rowsTableList, SModeFast, Unsafe, true)
+	tableList, err := ScanAll[tabInfo](ctx, db, rowsTableList, SModeFast, Unsafe, true)
 	if err != nil {
 		return "", err
 	}
@@ -113,7 +143,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 				return "", err
 			}
 
-			columnList, err := ScanAll[colInfo](rowsColumnList, SModeFast, Unsafe, true)
+			columnList, err := ScanAll[colInfo](ctx, db, rowsColumnList, SModeFast, Unsafe, true)
 			if err != nil {
 				return "", err
 			}
@@ -128,7 +158,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 			if err != nil {
 				return "", err
 			}
-			idxList, err := ScanAll[idxInfo](rowsIdxList, SModeFast, Unsafe, true)
+			idxList, err := ScanAll[idxInfo](ctx, db, rowsIdxList, SModeFast, Unsafe, true)
 			if err != nil {
 				return "", err
 			}
@@ -143,7 +173,7 @@ func CreateSqliteDatabaseSchemaString(ctx context.Context, db Queryable) (string
 			if err != nil {
 				return "", err
 			}
-			fkyList, err := ScanAll[fkyInfo](rowsIdxList, SModeFast, Unsafe, true)
+			fkyList, err := ScanAll[fkyInfo](ctx, db, rowsIdxList, SModeFast, Unsafe, true)
 			if err != nil {
 				return "", err
 			}

sq/json.go

@@ -0,0 +1,5 @@
+package sq
+
+type JsonObj map[string]any
+
+type JsonArr []any

sq/params.go

@@ -1,5 +1,7 @@
 package sq
 
+import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+
 type PP map[string]any
 
 func Join(pps ...PP) PP {
@@ -11,3 +13,13 @@ func Join(pps ...PP) PP {
 	}
 	return r
 }
+
+func (pp *PP) Add(v any) string {
+	id := PPID()
+	(*pp)[id] = v
+	return id
+}
+
+func PPID() string {
+	return "p_" + langext.RandBase62(8)
+}

sq/queryable.go

@@ -9,4 +9,5 @@ import (
 type Queryable interface {
 	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
 	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
+	ListConverter() []DBTypeConverter
 }

sq/scanner.go

@@ -13,8 +13,8 @@ import (
 type StructScanMode string
 
 const (
-	SModeFast     StructScanMode = "FAST"
-	SModeExtended StructScanMode = "EXTENDED"
+	SModeFast     StructScanMode = "FAST"     // Use default sq.Scan, does not work with joined/resolved types and/or custom value converter
+	SModeExtended StructScanMode = "EXTENDED" // Fully featured perhaps (?) a tiny bit slower - default
 )
 
 type StructScanSafety string
@@ -51,7 +51,13 @@ func InsertSingle[TData any](ctx context.Context, q Queryable, tableName string,
 
 		columns = append(columns, "\""+columnName+"\"")
 		params = append(params, ":"+paramkey)
-		pp[paramkey] = rvfield.Interface()
+
+		val, err := convertValueToDB(q, rvfield.Interface())
+		if err != nil {
+			return nil, err
+		}
+
+		pp[paramkey] = val
 
 	}
 
@@ -71,7 +77,7 @@ func QuerySingle[TData any](ctx context.Context, q Queryable, sql string, pp PP,
 		return *new(TData), err
 	}
 
-	data, err := ScanSingle[TData](rows, mode, sec, true)
+	data, err := ScanSingle[TData](ctx, q, rows, mode, sec, true)
 	if err != nil {
 		return *new(TData), err
 	}
@@ -85,7 +91,7 @@ func QueryAll[TData any](ctx context.Context, q Queryable, sql string, pp PP, mo
 		return nil, err
 	}
 
-	data, err := ScanAll[TData](rows, mode, sec, true)
+	data, err := ScanAll[TData](ctx, q, rows, mode, sec, true)
 	if err != nil {
 		return nil, err
 	}
@@ -93,7 +99,7 @@ func QueryAll[TData any](ctx context.Context, q Queryable, sql string, pp PP, mo
 	return data, nil
 }
 
-func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) (TData, error) {
+func ScanSingle[TData any](ctx context.Context, q Queryable, rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) (TData, error) {
 	if rows.Next() {
 		var strscan *StructScanner
 
@@ -123,7 +129,7 @@ func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanS
 				return *new(TData), err
 			}
 		} else if mode == SModeExtended {
-			err := strscan.StructScanExt(&data)
+			err := strscan.StructScanExt(q, &data)
 			if err != nil {
 				return *new(TData), err
 			}
@@ -149,6 +155,10 @@ func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanS
 			return *new(TData), err
 		}
 
+		if err := ctx.Err(); err != nil {
+			return *new(TData), err
+		}
+
 		return data, nil
 
 	} else {
@@ -159,7 +169,7 @@ func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanS
 	}
 }
 
-func ScanAll[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) ([]TData, error) {
+func ScanAll[TData any](ctx context.Context, q Queryable, rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) ([]TData, error) {
 	var strscan *StructScanner
 
 	if sec == Safe {
@@ -182,6 +192,11 @@ func ScanAll[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafe
 
 	res := make([]TData, 0)
 	for rows.Next() {
+
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+
 		if mode == SModeFast {
 			var data TData
 			err := strscan.StructScanBase(&data)
@@ -191,7 +206,7 @@ func ScanAll[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafe
 			res = append(res, data)
 		} else if mode == SModeExtended {
 			var data TData
-			err := strscan.StructScanExt(&data)
+			err := strscan.StructScanExt(q, &data)
 			if err != nil {
 				return nil, err
 			}

sq/sq_test.go

@@ -0,0 +1,95 @@
+package sq
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"github.com/glebarez/go-sqlite"
+	"github.com/jmoiron/sqlx"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/rfctime"
+	"gogs.mikescher.com/BlackForestBytes/goext/tst"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestTypeConverter1(t *testing.T) {
+	type RequestData struct {
+		ID        string    `db:"id"`
+		Timestamp time.Time `db:"timestamp"`
+	}
+
+	if !langext.InArray("sqlite3", sql.Drivers()) {
+		sqlite.RegisterAsSQLITE3()
+	}
+
+	ctx := context.Background()
+
+	dbdir := t.TempDir()
+	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
+
+	tst.AssertNoErr(t, os.MkdirAll(dbdir, os.ModePerm))
+
+	url := fmt.Sprintf("file:%s?_pragma=journal_mode(%s)&_pragma=timeout(%d)&_pragma=foreign_keys(%s)&_pragma=busy_timeout(%d)", dbfile1, "DELETE", 1000, "true", 1000)
+
+	xdb := tst.Must(sqlx.Open("sqlite", url))(t)
+
+	db := NewDB(xdb)
+	db.RegisterDefaultConverter()
+
+	_, err := db.Exec(ctx, "CREATE TABLE `requests` ( id TEXT NOT NULL, timestamp INTEGER NOT NULL, PRIMARY KEY (id) ) STRICT", PP{})
+	tst.AssertNoErr(t, err)
+
+	_, err = InsertSingle(ctx, db, "requests", RequestData{
+		ID:        "001",
+		Timestamp: time.Date(2000, 06, 15, 12, 0, 0, 0, time.UTC),
+	})
+	tst.AssertNoErr(t, err)
+}
+
+func TestTypeConverter2(t *testing.T) {
+
+	if !langext.InArray("sqlite3", sql.Drivers()) {
+		sqlite.RegisterAsSQLITE3()
+	}
+
+	type RequestData struct {
+		ID        string                `db:"id"`
+		Timestamp rfctime.UnixMilliTime `db:"timestamp"`
+	}
+
+	ctx := context.Background()
+
+	dbdir := t.TempDir()
+	dbfile1 := filepath.Join(dbdir, langext.MustHexUUID()+".sqlite3")
+
+	tst.AssertNoErr(t, os.MkdirAll(dbdir, os.ModePerm))
+
+	url := fmt.Sprintf("file:%s?_pragma=journal_mode(%s)&_pragma=timeout(%d)&_pragma=foreign_keys(%s)&_pragma=busy_timeout(%d)", dbfile1, "DELETE", 1000, "true", 1000)
+
+	xdb := tst.Must(sqlx.Open("sqlite", url))(t)
+
+	db := NewDB(xdb)
+	db.RegisterDefaultConverter()
+
+	_, err := db.Exec(ctx, "CREATE TABLE `requests` ( id TEXT NOT NULL, timestamp INTEGER NOT NULL, PRIMARY KEY (id) ) STRICT", PP{})
+	tst.AssertNoErr(t, err)
+
+	t0 := rfctime.NewUnixMilli(time.Date(2012, 03, 01, 16, 0, 0, 0, time.UTC))
+
+	_, err = InsertSingle(ctx, db, "requests", RequestData{
+		ID:        "002",
+		Timestamp: t0,
+	})
+	tst.AssertNoErr(t, err)
+
+	r, err := QuerySingle[RequestData](ctx, db, "SELECT * FROM requests WHERE id = '002'", PP{}, SModeExtended, Safe)
+	tst.AssertNoErr(t, err)
+
+	fmt.Printf("%+v\n", r)
+
+	tst.AssertEqual(t, "002", r.ID)
+	tst.AssertEqual(t, t0.UnixNano(), r.Timestamp.UnixNano())
+}

sq/structscanner.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/jmoiron/sqlx"
 	"github.com/jmoiron/sqlx/reflectx"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"reflect"
 )
 
@@ -15,9 +16,10 @@ type StructScanner struct {
 	Mapper *reflectx.Mapper
 	unsafe bool
 
-	fields  [][]int
-	values  []any
-	columns []string
+	fields    [][]int
+	values    []any
+	converter []DBTypeConverter
+	columns   []string
 }
 
 func NewStructScanner(rows *sqlx.Rows, unsafe bool) *StructScanner {
@@ -47,13 +49,15 @@ func (r *StructScanner) Start(dest any) error {
 		return fmt.Errorf("missing destination name %s in %T", columns[f], dest)
 	}
 	r.values = make([]interface{}, len(columns))
+	r.converter = make([]DBTypeConverter, len(columns))
 
 	return nil
 }
 
 // StructScanExt forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
-// does also wok with nullabel structs (from LEFT JOIN's)
-func (r *StructScanner) StructScanExt(dest any) error {
+// does also work with nullabel structs (from LEFT JOIN's)
+// does also work with custom value converters
+func (r *StructScanner) StructScanExt(q Queryable, dest any) error {
 	v := reflect.ValueOf(dest)
 
 	if v.Kind() != reflect.Ptr {
@@ -64,7 +68,7 @@ func (r *StructScanner) StructScanExt(dest any) error {
 
 	v = v.Elem()
 
-	err := fieldsByTraversalExtended(v, r.fields, r.values)
+	err := fieldsByTraversalExtended(q, v, r.fields, r.values, r.converter)
 	if err != nil {
 		return err
 	}
@@ -131,7 +135,6 @@ func (r *StructScanner) StructScanExt(dest any) error {
 
 		val1 := reflect.ValueOf(r.values[i])
 		val2 := val1.Elem()
-		val3 := val2.Elem()
 
 		if val2.IsNil() {
 			if f.Kind() != reflect.Pointer {
@@ -140,7 +143,16 @@ func (r *StructScanner) StructScanExt(dest any) error {
 
 			f.Set(reflect.Zero(f.Type())) // set to nil
 		} else {
-			f.Set(val3)
+			if r.converter[i] != nil {
+				val3 := val2.Elem().Interface()
+				conv3, err := r.converter[i].DBToModel(val3)
+				if err != nil {
+					return err
+				}
+				f.Set(reflect.ValueOf(conv3))
+			} else {
+				f.Set(val2.Elem())
+			}
 		}
 
 	}
@@ -172,7 +184,7 @@ func (r *StructScanner) StructScanBase(dest any) error {
 }
 
 // fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
-func fieldsByTraversalExtended(v reflect.Value, traversals [][]int, values []interface{}) error {
+func fieldsByTraversalExtended(q Queryable, v reflect.Value, traversals [][]int, values []interface{}, converter []DBTypeConverter) error {
 	v = reflect.Indirect(v)
 	if v.Kind() != reflect.Struct {
 		return errors.New("argument not a struct")
@@ -185,7 +197,23 @@ func fieldsByTraversalExtended(v reflect.Value, traversals [][]int, values []int
 		}
 		f := reflectx.FieldByIndexes(v, traversal)
 
-		values[i] = reflect.New(reflect.PointerTo(f.Type())).Interface()
+		typeStr := f.Type().String()
+
+		foundConverter := false
+		for _, conv := range q.ListConverter() {
+			if conv.ModelTypeString() == typeStr {
+				_v := langext.Ptr[any](nil)
+				values[i] = _v
+				foundConverter = true
+				converter[i] = conv
+				break
+			}
+		}
+
+		if !foundConverter {
+			values[i] = reflect.New(reflect.PointerTo(f.Type())).Interface()
+			converter[i] = nil
+		}
 	}
 	return nil
 }

sq/transaction.go

@@ -17,35 +17,35 @@ const (
 )
 
 type Tx interface {
+	Queryable
+
 	Rollback() error
 	Commit() error
 	Status() TxStatus
-	Exec(ctx context.Context, sql string, prep PP) (sql.Result, error)
-	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
 }
 
 type transaction struct {
 	tx       *sqlx.Tx
 	id       uint16
-	lstr     []Listener
 	status   TxStatus
 	execCtr  int
 	queryCtr int
+	db       *database
 }
 
-func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
+func NewTransaction(xtx *sqlx.Tx, txid uint16, db *database) Tx {
 	return &transaction{
 		tx:       xtx,
 		id:       txid,
-		lstr:     lstr,
 		status:   TxStatusInitial,
 		execCtr:  0,
 		queryCtr: 0,
+		db:       db,
 	}
 }
 
 func (tx *transaction) Rollback() error {
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		err := v.PreTxRollback(tx.id)
 		if err != nil {
 			return err
@@ -58,7 +58,7 @@ func (tx *transaction) Rollback() error {
 		tx.status = TxStatusRollback
 	}
 
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		v.PostTxRollback(tx.id, result)
 	}
 
@@ -66,7 +66,7 @@ func (tx *transaction) Rollback() error {
 }
 
 func (tx *transaction) Commit() error {
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		err := v.PreTxCommit(tx.id)
 		if err != nil {
 			return err
@@ -79,7 +79,7 @@ func (tx *transaction) Commit() error {
 		tx.status = TxStatusComitted
 	}
 
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		v.PostTxRollback(tx.id, result)
 	}
 
@@ -88,7 +88,7 @@ func (tx *transaction) Commit() error {
 
 func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
 	origsql := sqlstr
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		err := v.PreExec(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
 		if err != nil {
 			return nil, err
@@ -101,7 +101,7 @@ func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Re
 		tx.status = TxStatusActive
 	}
 
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		v.PostExec(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
 
@@ -113,7 +113,7 @@ func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Re
 
 func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
 	origsql := sqlstr
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		err := v.PreQuery(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
 		if err != nil {
 			return nil, err
@@ -126,7 +126,7 @@ func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx
 		tx.status = TxStatusActive
 	}
 
-	for _, v := range tx.lstr {
+	for _, v := range tx.db.lstr {
 		v.PostQuery(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
 
@@ -140,6 +140,10 @@ func (tx *transaction) Status() TxStatus {
 	return tx.status
 }
 
+func (tx *transaction) ListConverter() []DBTypeConverter {
+	return tx.db.conv
+}
+
 func (tx *transaction) Traffic() (int, int) {
 	return tx.execCtr, tx.queryCtr
 }

syncext/atomic.go

@@ -1,33 +1,28 @@
 package syncext
 
 import (
-	"context"
-	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"sync"
-	"time"
 )
 
-type AtomicBool struct {
-	v        bool
-	listener map[string]chan bool
-	lock     sync.Mutex
+type Atomic[T any] struct {
+	v    T
+	lock sync.RWMutex
 }
 
-func NewAtomicBool(value bool) *AtomicBool {
-	return &AtomicBool{
-		v:        value,
-		listener: make(map[string]chan bool),
-		lock:     sync.Mutex{},
+func NewAtomic[T any](value T) *Atomic[T] {
+	return &Atomic[T]{
+		v:    value,
+		lock: sync.RWMutex{},
 	}
 }
 
-func (a *AtomicBool) Get() bool {
-	a.lock.Lock()
-	defer a.lock.Unlock()
+func (a *Atomic[T]) Get() T {
+	a.lock.RLock()
+	defer a.lock.RUnlock()
 	return a.v
 }
 
-func (a *AtomicBool) Set(value bool) bool {
+func (a *Atomic[T]) Set(value T) T {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
@@ -35,79 +30,5 @@ func (a *AtomicBool) Set(value bool) bool {
 
 	a.v = value
 
-	for k, v := range a.listener {
-		select {
-		case v <- value:
-			// message sent
-		default:
-			// no receiver on channel
-			delete(a.listener, k)
-		}
-	}
-
 	return oldValue
 }
-
-func (a *AtomicBool) Wait(waitFor bool) {
-	_ = a.WaitWithContext(context.Background(), waitFor)
-}
-
-func (a *AtomicBool) WaitWithTimeout(timeout time.Duration, waitFor bool) error {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	return a.WaitWithContext(ctx, waitFor)
-}
-
-func (a *AtomicBool) WaitWithContext(ctx context.Context, waitFor bool) error {
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-
-	if a.Get() == waitFor {
-		return nil
-	}
-
-	uuid, _ := langext.NewHexUUID()
-
-	waitchan := make(chan bool)
-
-	a.lock.Lock()
-	a.listener[uuid] = waitchan
-	a.lock.Unlock()
-	defer func() {
-		a.lock.Lock()
-		delete(a.listener, uuid)
-		a.lock.Unlock()
-	}()
-
-	for {
-		if err := ctx.Err(); err != nil {
-			return err
-		}
-
-		timeOut := 1024 * time.Millisecond
-
-		if dl, ok := ctx.Deadline(); ok {
-			timeOutMax := dl.Sub(time.Now())
-			if timeOutMax <= 0 {
-				timeOut = 0
-			} else if 0 < timeOutMax && timeOutMax < timeOut {
-				timeOut = timeOutMax
-			}
-		}
-
-		if v, ok := ReadChannelWithTimeout(waitchan, timeOut); ok {
-			if v == waitFor {
-				return nil
-			}
-		} else {
-			if err := ctx.Err(); err != nil {
-				return err
-			}
-
-			if a.Get() == waitFor {
-				return nil
-			}
-		}
-	}
-}

syncext/bool.go

@@ -0,0 +1,113 @@
+package syncext
+
+import (
+	"context"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"sync"
+	"time"
+)
+
+type AtomicBool struct {
+	v        bool
+	listener map[string]chan bool
+	lock     sync.Mutex
+}
+
+func NewAtomicBool(value bool) *AtomicBool {
+	return &AtomicBool{
+		v:        value,
+		listener: make(map[string]chan bool),
+		lock:     sync.Mutex{},
+	}
+}
+
+func (a *AtomicBool) Get() bool {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+	return a.v
+}
+
+func (a *AtomicBool) Set(value bool) bool {
+	a.lock.Lock()
+	defer a.lock.Unlock()
+
+	oldValue := a.v
+
+	a.v = value
+
+	for k, v := range a.listener {
+		select {
+		case v <- value:
+			// message sent
+		default:
+			// no receiver on channel
+			delete(a.listener, k)
+		}
+	}
+
+	return oldValue
+}
+
+func (a *AtomicBool) Wait(waitFor bool) {
+	_ = a.WaitWithContext(context.Background(), waitFor)
+}
+
+func (a *AtomicBool) WaitWithTimeout(timeout time.Duration, waitFor bool) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	return a.WaitWithContext(ctx, waitFor)
+}
+
+func (a *AtomicBool) WaitWithContext(ctx context.Context, waitFor bool) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
+	if a.Get() == waitFor {
+		return nil
+	}
+
+	uuid, _ := langext.NewHexUUID()
+
+	waitchan := make(chan bool)
+
+	a.lock.Lock()
+	a.listener[uuid] = waitchan
+	a.lock.Unlock()
+	defer func() {
+		a.lock.Lock()
+		delete(a.listener, uuid)
+		a.lock.Unlock()
+	}()
+
+	for {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		timeOut := 1024 * time.Millisecond
+
+		if dl, ok := ctx.Deadline(); ok {
+			timeOutMax := dl.Sub(time.Now())
+			if timeOutMax <= 0 {
+				timeOut = 0
+			} else if 0 < timeOutMax && timeOutMax < timeOut {
+				timeOut = timeOutMax
+			}
+		}
+
+		if v, ok := ReadChannelWithTimeout(waitchan, timeOut); ok {
+			if v == waitFor {
+				return nil
+			}
+		} else {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+
+			if a.Get() == waitFor {
+				return nil
+			}
+		}
+	}
+}

wmo/decoding.go

@@ -14,12 +14,12 @@ func (c *Coll[TData]) decodeSingle(ctx context.Context, dec Decodable) (TData, e
 	if c.customDecoder != nil {
 		res, err = (*c.customDecoder)(ctx, dec)
 		if err != nil {
-			return *new(TData), exerr.Wrap(err, "failed to decode single entity with custom-decoder").Type("decoder", *c.customDecoder).Build()
+			return *new(TData), exerr.Wrap(err, "failed to decode single entity with custom-decoder").Type("decoder", *c.customDecoder).NoLog().Build()
 		}
 	} else {
 		err = dec.Decode(&res)
 		if err != nil {
-			return *new(TData), exerr.Wrap(err, "failed to decode single entity").Type("target-type", res).Build()
+			return *new(TData), exerr.Wrap(err, "failed to decode single entity").Type("target-type", res).NoLog().Build()
 		}
 	}
 
@@ -75,12 +75,12 @@ func (c *Coll[TData]) decodeSingleOrRequery(ctx context.Context, dec Decodable)
 		var res genDoc
 		err := dec.Decode(&res)
 		if err != nil {
-			return *new(TData), exerr.Wrap(err, "failed to ID-decode entity").Build()
+			return *new(TData), exerr.Wrap(err, "failed to ID-decode entity").NoLog().Build()
 		}
 
 		v, err := c.findOneInternal(ctx, bson.M{"_id": res.ID}, false)
 		if err != nil {
-			return *new(TData), exerr.Wrap(err, "failed to re-query entity").Any("_id", res.ID).Build()
+			return *new(TData), exerr.Wrap(err, "failed to re-query entity").Any("_id", res.ID).NoLog().Build()
 		}
 
 		return *v, nil

wmo/queryFindOne.go

@@ -58,7 +58,7 @@ func (c *Coll[TData]) findOneInternal(ctx context.Context, filter bson.M, allowN
 			return nil, nil
 		}
 		if err != nil {
-			return nil, exerr.Wrap(err, "mongo-query[find-one] failed").Any("filter", filter).Str("collection", c.Name()).Build()
+			return nil, exerr.Wrap(err, "mongo-query[find-one] failed").Any("filter", filter).Str("collection", c.Name()).NoLog().Build()
 		}
 
 		return &res, nil
@@ -75,19 +75,19 @@ func (c *Coll[TData]) findOneInternal(ctx context.Context, filter bson.M, allowN
 
 		cursor, err := c.coll.Aggregate(ctx, pipeline)
 		if err != nil {
-			return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
+			return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
 		}
 
 		if cursor.Next(ctx) {
 			v, err := c.decodeSingle(ctx, cursor)
 			if err != nil {
-				return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
+				return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed to decode results").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
 			}
 			return &v, nil
 		} else if allowNull {
 			return nil, nil
 		} else {
-			return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
+			return nil, exerr.Wrap(mongo.ErrNoDocuments, "mongo-aggregation [find-one] returned no documents").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
 		}
 	}
 }

wmo/queryPaginate.go

@@ -40,10 +40,10 @@ func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.Filter, page int,
 	}
 
 	pipelineCount := mongo.Pipeline{}
-	pipelinePaginate = append(pipelinePaginate, bson.D{{Key: "$count", Value: "count"}})
+	pipelineCount = append(pipelineCount, bson.D{{Key: "$count", Value: "count"}})
 
-	pipelineList := langext.ArrConcat(mongo.Pipeline{}, pipelineFilter, pipelinePaginate, c.extraModPipeline)
-	pipelineTotalCount := langext.ArrConcat(mongo.Pipeline{}, pipelineFilter, pipelineCount)
+	pipelineList := langext.ArrConcat(pipelineFilter, pipelineSort, pipelinePaginate, c.extraModPipeline, pipelineSort)
+	pipelineTotalCount := langext.ArrConcat(pipelineFilter, pipelineCount)
 
 	cursorList, err := c.coll.Aggregate(ctx, pipelineList)
 	if err != nil {