v0.0.68

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +1,7 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="GoMixedReceiverTypes" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="LanguageDetectionInspection" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
       <option name="processCode" value="true" />

cmdext/builder.go

@@ -0,0 +1,56 @@
+package cmdext
+
+import (
+	"fmt"
+	"time"
+)
+
+type CommandRunner struct {
+	program string
+	args    []string
+	timeout *time.Duration
+	env     []string
+}
+
+func Runner(program string) *CommandRunner {
+	return &CommandRunner{
+		program: program,
+		args:    make([]string, 0),
+		timeout: nil,
+		env:     make([]string, 0),
+	}
+}
+
+func (r *CommandRunner) Arg(arg string) *CommandRunner {
+	r.args = append(r.args, arg)
+	return r
+}
+
+func (r *CommandRunner) Args(arg []string) *CommandRunner {
+	r.args = append(r.args, arg...)
+	return r
+}
+
+func (r *CommandRunner) Timeout(timeout time.Duration) *CommandRunner {
+	r.timeout = &timeout
+	return r
+}
+
+func (r *CommandRunner) Env(key, value string) *CommandRunner {
+	r.env = append(r.env, fmt.Sprintf("%s=%s", key, value))
+	return r
+}
+
+func (r *CommandRunner) RawEnv(env string) *CommandRunner {
+	r.env = append(r.env, env)
+	return r
+}
+
+func (r *CommandRunner) Envs(env []string) *CommandRunner {
+	r.env = append(r.env, env...)
+	return r
+}
+
+func (r *CommandRunner) Run() (CommandResult, error) {
+	return run(*r)
+}

cmdext/cmdrunner.go

@@ -0,0 +1,116 @@
+package cmdext
+
+import (
+	"bufio"
+	"os/exec"
+	"time"
+)
+
+type CommandResult struct {
+	StdOut          string
+	StdErr          string
+	StdCombined     string
+	ExitCode        int
+	CommandTimedOut bool
+}
+
+func run(opt CommandRunner) (CommandResult, error) {
+	cmd := exec.Command(opt.program, opt.args...)
+	cmd.Env = append(cmd.Env, opt.env)
+
+	stdoutPipe, err := cmd.StdoutPipe()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	stderrPipe, err := cmd.StderrPipe()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		return CommandResult{}, err
+	}
+
+	errch := make(chan error, 1)
+	go func() { errch <- cmd.Wait() }()
+
+	combch := make(chan string, 32)
+	stopCombch := make(chan bool)
+
+	stdout := ""
+	go func() {
+		scanner := bufio.NewScanner(stdoutPipe)
+		for scanner.Scan() {
+			txt := scanner.Text()
+			stdout += txt
+			combch <- txt
+		}
+	}()
+
+	stderr := ""
+	go func() {
+		scanner := bufio.NewScanner(stderrPipe)
+		for scanner.Scan() {
+			txt := scanner.Text()
+			stderr += txt
+			combch <- txt
+		}
+	}()
+
+	defer func() {
+		stopCombch <- true
+	}()
+
+	stdcombined := ""
+	go func() {
+		for {
+			select {
+			case txt := <-combch:
+				stdcombined += txt
+			case <-stopCombch:
+				return
+			}
+		}
+	}()
+
+	var timeoutChan <-chan time.Time = make(chan time.Time, 1)
+	if opt.timeout != nil {
+		timeoutChan = time.After(*opt.timeout)
+	}
+
+	select {
+
+	case <-timeoutChan:
+		_ = cmd.Process.Kill()
+		return CommandResult{
+			StdOut:          stdout,
+			StdErr:          stderr,
+			StdCombined:     stdcombined,
+			ExitCode:        -1,
+			CommandTimedOut: true,
+		}, nil
+
+	case err := <-errch:
+		if exiterr, ok := err.(*exec.ExitError); ok {
+			return CommandResult{
+				StdOut:          stdout,
+				StdErr:          stderr,
+				StdCombined:     stdcombined,
+				ExitCode:        exiterr.ExitCode(),
+				CommandTimedOut: false,
+			}, nil
+		} else if err != nil {
+			return CommandResult{}, err
+		} else {
+			return CommandResult{
+				StdOut:          stdout,
+				StdErr:          stderr,
+				StdCombined:     stdcombined,
+				ExitCode:        0,
+				CommandTimedOut: false,
+			}, nil
+		}
+	}
+}

cmdext/helper.go

@@ -0,0 +1,12 @@
+package cmdext
+
+import "time"
+
+func RunCommand(program string, args []string, timeout *time.Duration) (CommandResult, error) {
+	b := Runner(program)
+	b = b.Args(args)
+	if timeout != nil {
+		b = b.Timeout(*timeout)
+	}
+	return b.Run()
+}

confext/confParser.go

@@ -0,0 +1,172 @@
+package confext
+
+import (
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"math/bits"
+	"os"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// ApplyEnvOverrides overrides field values from environment variables
+//
+// fields must be tagged with `env:"env_key"`
+//
+// only works on exported fields
+//
+// fields without an env tag are ignored
+// fields with an `env:"-"` tag are ignore
+//
+// sub-structs are recursively parsed (if they have an env tag) and the env-variable keys are delimited by the delim parameter
+// sub-structs with `env:""` are also parsed, but the delimited is skipped (they are handled as if they were one level higher)
+func ApplyEnvOverrides[T any](c *T, delim string) error {
+	rval := reflect.ValueOf(c).Elem()
+
+	return processEnvOverrides(rval, delim, "")
+}
+
+func processEnvOverrides(rval reflect.Value, delim string, prefix string) error {
+	rtyp := rval.Type()
+
+	for i := 0; i < rtyp.NumField(); i++ {
+
+		rsfield := rtyp.Field(i)
+		rvfield := rval.Field(i)
+
+		if !rsfield.IsExported() {
+			continue
+		}
+
+		if rvfield.Kind() == reflect.Struct {
+
+			envkey, found := rsfield.Tag.Lookup("env")
+			if !found || envkey == "-" {
+				continue
+			}
+
+			subPrefix := prefix
+			if envkey != "" {
+				subPrefix = subPrefix + envkey + delim
+			}
+
+			err := processEnvOverrides(rvfield, delim, subPrefix)
+			if err != nil {
+				return err
+			}
+		}
+
+		envkey := rsfield.Tag.Get("env")
+		if envkey == "" || envkey == "-" {
+			continue
+		}
+
+		fullEnvKey := prefix + envkey
+
+		envval, efound := os.LookupEnv(fullEnvKey)
+		if !efound {
+			continue
+		}
+
+		if rvfield.Type() == reflect.TypeOf("") {
+
+			rvfield.Set(reflect.ValueOf(envval))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, bits.UintSize)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int64(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 64)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int64 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int64(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int32(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 32)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int32(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(int8(0)) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to int32 (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(int8(envint)))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, envval)
+
+		} else if rvfield.Type() == reflect.TypeOf(time.Duration(0)) {
+
+			dur, err := timeext.ParseDurationShortString(envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to duration (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(dur))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, dur.String())
+
+		} else if rvfield.Type() == reflect.TypeOf(time.UnixMilli(0)) {
+
+			tim, err := time.Parse(time.RFC3339Nano, envval)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to time.time (value := '%s')", fullEnvKey, envval))
+			}
+
+			rvfield.Set(reflect.ValueOf(tim))
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%s'\n", fullEnvKey, tim.String())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf(int(0))) {
+
+			envint, err := strconv.ParseInt(envval, 10, 8)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Failed to parse env-config variable '%s' to <%s, ,int> (value := '%s')", rvfield.Type().Name(), fullEnvKey, envval))
+			}
+
+			envcvl := reflect.ValueOf(envint).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", fullEnvKey, envcvl.Interface())
+
+		} else if rvfield.Type().ConvertibleTo(reflect.TypeOf("")) {
+
+			envcvl := reflect.ValueOf(envval).Convert(rvfield.Type())
+
+			rvfield.Set(envcvl)
+
+			fmt.Printf("[CONF] Overwrite config '%s' with '%v'\n", fullEnvKey, envcvl.Interface())
+
+		} else {
+			return errors.New(fmt.Sprintf("Unknown kind/type in config: [ %s | %s ]", rvfield.Kind().String(), rvfield.Type().String()))
+		}
+	}
+
+	return nil
+}

confext/confParser_test.go

@@ -0,0 +1,220 @@
+package confext
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/timeext"
+	"testing"
+	"time"
+)
+
+func TestApplyEnvOverridesNoop(t *testing.T) {
+
+	type aliasint int
+	type aliasstring string
+
+	type testdata struct {
+		V1 int           `env:"TEST_V1"`
+		VX string        ``
+		V2 string        `env:"TEST_V2"`
+		V3 int8          `env:"TEST_V3"`
+		V4 int32         `env:"TEST_V4"`
+		V5 int64         `env:"TEST_V5"`
+		V6 aliasint      `env:"TEST_V6"`
+		VY aliasint      ``
+		V7 aliasstring   `env:"TEST_V7"`
+		V8 time.Duration `env:"TEST_V8"`
+		V9 time.Time     `env:"TEST_V9"`
+	}
+
+	input := testdata{
+		V1: 1,
+		VX: "X",
+		V2: "2",
+		V3: 3,
+		V4: 4,
+		V5: 5,
+		V6: 6,
+		VY: 99,
+		V7: "7",
+		V8: 9,
+		V9: time.Unix(1671102873, 0),
+	}
+
+	output := input
+
+	err := ApplyEnvOverrides(&output, ".")
+	if err != nil {
+		t.Errorf("%v", err)
+		t.FailNow()
+	}
+
+	assertEqual(t, input, output)
+}
+
+func TestApplyEnvOverridesSimple(t *testing.T) {
+
+	type aliasint int
+	type aliasstring string
+
+	type testdata struct {
+		V1 int           `env:"TEST_V1"`
+		VX string        ``
+		V2 string        `env:"TEST_V2"`
+		V3 int8          `env:"TEST_V3"`
+		V4 int32         `env:"TEST_V4"`
+		V5 int64         `env:"TEST_V5"`
+		V6 aliasint      `env:"TEST_V6"`
+		VY aliasint      ``
+		V7 aliasstring   `env:"TEST_V7"`
+		V8 time.Duration `env:"TEST_V8"`
+		V9 time.Time     `env:"TEST_V9"`
+	}
+
+	data := testdata{
+		V1: 1,
+		VX: "X",
+		V2: "2",
+		V3: 3,
+		V4: 4,
+		V5: 5,
+		V6: 6,
+		VY: 99,
+		V7: "7",
+		V8: 9,
+		V9: time.Unix(1671102873, 0),
+	}
+
+	t.Setenv("TEST_V1", "846")
+	t.Setenv("TEST_V2", "hello_world")
+	t.Setenv("TEST_V3", "6")
+	t.Setenv("TEST_V4", "333")
+	t.Setenv("TEST_V5", "-937")
+	t.Setenv("TEST_V6", "070")
+	t.Setenv("TEST_V7", "AAAAAA")
+	t.Setenv("TEST_V8", "1min4s")
+	t.Setenv("TEST_V9", "2009-11-10T23:00:00Z")
+
+	err := ApplyEnvOverrides(&data, ".")
+	if err != nil {
+		t.Errorf("%v", err)
+		t.FailNow()
+	}
+
+	assertEqual(t, data.V1, 846)
+	assertEqual(t, data.V2, "hello_world")
+	assertEqual(t, data.V3, 6)
+	assertEqual(t, data.V4, 333)
+	assertEqual(t, data.V5, -937)
+	assertEqual(t, data.V6, 70)
+	assertEqual(t, data.V7, "AAAAAA")
+	assertEqual(t, data.V8, time.Second*64)
+	assertEqual(t, data.V9, time.Unix(1257894000, 0).UTC())
+}
+
+func TestApplyEnvOverridesRecursive(t *testing.T) {
+
+	type subdata struct {
+		V1 int           `env:"SUB_V1"`
+		VX string        ``
+		V2 string        `env:"SUB_V2"`
+		V8 time.Duration `env:"SUB_V3"`
+		V9 time.Time     `env:"SUB_V4"`
+	}
+
+	type testdata struct {
+		V1   int     `env:"TEST_V1"`
+		VX   string  ``
+		Sub1 subdata ``
+		Sub2 subdata `env:"TEST_V2"`
+		Sub3 subdata `env:"TEST_V3"`
+		Sub4 subdata `env:""`
+		V5   string  `env:"-"`
+	}
+
+	data := testdata{
+		V1: 1,
+		VX: "2",
+		V5: "no",
+		Sub1: subdata{
+			V1: 3,
+			VX: "4",
+			V2: "5",
+			V8: 6 * time.Second,
+			V9: time.Date(2000, 1, 7, 1, 1, 1, 0, time.UTC),
+		},
+		Sub2: subdata{
+			V1: 8,
+			VX: "9",
+			V2: "10",
+			V8: 11 * time.Second,
+			V9: time.Date(2000, 1, 12, 1, 1, 1, 0, timeext.TimezoneBerlin),
+		},
+		Sub3: subdata{
+			V1: 13,
+			VX: "14",
+			V2: "15",
+			V8: 16 * time.Second,
+			V9: time.Date(2000, 1, 17, 1, 1, 1, 0, timeext.TimezoneBerlin),
+		},
+		Sub4: subdata{
+			V1: 18,
+			VX: "19",
+			V2: "20",
+			V8: 21 * time.Second,
+			V9: time.Date(2000, 1, 22, 1, 1, 1, 0, timeext.TimezoneBerlin),
+		},
+	}
+
+	t.Setenv("TEST_V1", "999")
+	t.Setenv("-", "yes")
+
+	t.Setenv("TEST_V2_SUB_V1", "846")
+	t.Setenv("TEST_V2_SUB_V2", "222_hello_world")
+	t.Setenv("TEST_V2_SUB_V3", "1min4s")
+	t.Setenv("TEST_V2_SUB_V4", "2009-11-10T23:00:00Z")
+
+	t.Setenv("TEST_V3_SUB_V1", "33846")
+	t.Setenv("TEST_V3_SUB_V2", "33_hello_world")
+	t.Setenv("TEST_V3_SUB_V3", "33min4s")
+	t.Setenv("TEST_V3_SUB_V4", "2033-11-10T23:00:00Z")
+
+	t.Setenv("SUB_V1", "11")
+	t.Setenv("SUB_V2", "22")
+	t.Setenv("SUB_V3", "33min")
+	t.Setenv("SUB_V4", "2044-01-01T00:00:00Z")
+
+	err := ApplyEnvOverrides(&data, "_")
+	if err != nil {
+		t.Errorf("%v", err)
+		t.FailNow()
+	}
+
+	assertEqual(t, data.V1, 999)
+	assertEqual(t, data.VX, "2")
+	assertEqual(t, data.V5, "no")
+	assertEqual(t, data.Sub1.V1, 3)
+	assertEqual(t, data.Sub1.VX, "4")
+	assertEqual(t, data.Sub1.V2, "5")
+	assertEqual(t, data.Sub1.V8, time.Second*6)
+	assertEqual(t, data.Sub1.V9, time.Unix(947206861, 0).UTC())
+	assertEqual(t, data.Sub2.V1, 846)
+	assertEqual(t, data.Sub2.VX, "9")
+	assertEqual(t, data.Sub2.V2, "222_hello_world")
+	assertEqual(t, data.Sub2.V8, time.Second*64)
+	assertEqual(t, data.Sub2.V9, time.Unix(1257894000, 0).UTC())
+	assertEqual(t, data.Sub3.V1, 33846)
+	assertEqual(t, data.Sub3.VX, "14")
+	assertEqual(t, data.Sub3.V2, "33_hello_world")
+	assertEqual(t, data.Sub3.V8, time.Second*1984)
+	assertEqual(t, data.Sub3.V9, time.Unix(2015276400, 0).UTC())
+	assertEqual(t, data.Sub4.V1, 11)
+	assertEqual(t, data.Sub4.VX, "19")
+	assertEqual(t, data.Sub4.V2, "22")
+	assertEqual(t, data.Sub4.V8, time.Second*1980)
+	assertEqual(t, data.Sub4.V9, time.Unix(2335219200, 0).UTC())
+}
+
+func assertEqual[T comparable](t *testing.T, actual T, expected T) {
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
+}

cryptext/aes.go

@@ -0,0 +1,68 @@
+package cryptext
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"golang.org/x/crypto/scrypt"
+	"io"
+)
+
+// https://stackoverflow.com/a/18819040/1761622
+
+func EncryptAESSimple(password, text []byte) ([]byte, error) {
+
+	key, err := scrypt.Key(password, nil, 32768, 8, 1, 32) // this is not 100% correct, rounds too low and salt is missing
+	if err != nil {
+		return nil, err
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	b := base64.StdEncoding.EncodeToString(text)
+	ciphertext := make([]byte, aes.BlockSize+len(b))
+
+	iv := ciphertext[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return nil, err
+	}
+
+	cfb := cipher.NewCFBEncrypter(block, iv)
+	cfb.XORKeyStream(ciphertext[aes.BlockSize:], []byte(b))
+
+	return ciphertext, nil
+}
+
+func DecryptAESSimple(password, text []byte) ([]byte, error) {
+
+	key, err := scrypt.Key(password, nil, 32768, 8, 1, 32) // this is not 100% correct, rounds too low and salt is missing
+	if err != nil {
+		return nil, err
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(text) < aes.BlockSize {
+		return nil, errors.New("ciphertext too short")
+	}
+
+	iv := text[:aes.BlockSize]
+	text = text[aes.BlockSize:]
+	cfb := cipher.NewCFBDecrypter(block, iv)
+	cfb.XORKeyStream(text, text)
+
+	data, err := base64.StdEncoding.DecodeString(string(text))
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

cryptext/aes_test.go

@@ -0,0 +1,22 @@
+package cryptext
+
+import "testing"
+
+func TestEncryptAESSimple(t *testing.T) {
+
+	pw := []byte("hunter12")
+
+	str1 := []byte("Hello World")
+
+	str2, err := EncryptAESSimple(pw, str1)
+	if err != nil {
+		panic(err)
+	}
+
+	str3, err := DecryptAESSimple(pw, str2)
+	if err != nil {
+		panic(err)
+	}
+
+	assertEqual(t, string(str1), string(str3))
+}

cryptext/passHash.go

@@ -0,0 +1,365 @@
+package cryptext
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/totpext"
+	"golang.org/x/crypto/bcrypt"
+	"strconv"
+	"strings"
+)
+
+const LatestPassHashVersion = 4
+
+// PassHash
+// - [v0]: plaintext password ( `0|...` )
+// - [v1]: sha256(plaintext)
+// - [v2]: seed | sha256<seed>(plaintext)
+// - [v3]: seed | sha256<seed>(plaintext) | [hex(totp)]
+// - [v4]: bcrypt(plaintext) | [hex(totp)]
+type PassHash string
+
+func (ph PassHash) Valid() bool {
+	_, _, _, _, _, valid := ph.Data()
+	return valid
+}
+
+func (ph PassHash) HasTOTP() bool {
+	_, _, _, otp, _, _ := ph.Data()
+	return otp
+}
+
+func (ph PassHash) Data() (_version int, _seed []byte, _payload []byte, _totp bool, _totpsecret []byte, _valid bool) {
+
+	split := strings.Split(string(ph), "|")
+	if len(split) == 0 {
+		return -1, nil, nil, false, nil, false
+	}
+
+	version, err := strconv.ParseInt(split[0], 10, 32)
+	if err != nil {
+		return -1, nil, nil, false, nil, false
+	}
+
+	if version == 0 {
+		if len(split) != 2 {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), nil, []byte(split[1]), false, nil, true
+	}
+
+	if version == 1 {
+		if len(split) != 2 {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), nil, payload, false, nil, true
+	}
+
+	//
+	if version == 2 {
+		if len(split) != 3 {
+			return -1, nil, nil, false, nil, false
+		}
+		seed, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[2])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		return int(version), seed, payload, false, nil, true
+	}
+
+	if version == 3 {
+		if len(split) != 4 {
+			return -1, nil, nil, false, nil, false
+		}
+		seed, err := base64.RawStdEncoding.DecodeString(split[1])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		payload, err := base64.RawStdEncoding.DecodeString(split[2])
+		if err != nil {
+			return -1, nil, nil, false, nil, false
+		}
+		totp := false
+		totpsecret := make([]byte, 0)
+		if split[3] != "0" {
+			totpsecret, err = hex.DecodeString(split[3])
+			totp = true
+		}
+		return int(version), seed, payload, totp, totpsecret, true
+	}
+
+	if version == 4 {
+		if len(split) != 3 {
+			return -1, nil, nil, false, nil, false
+		}
+		payload := []byte(split[1])
+		totp := false
+		totpsecret := make([]byte, 0)
+		if split[2] != "0" {
+			totpsecret, err = hex.DecodeString(split[3])
+			totp = true
+		}
+		return int(version), nil, payload, totp, totpsecret, true
+	}
+
+	return -1, nil, nil, false, nil, false
+}
+
+func (ph PassHash) Verify(plainpass string, totp *string) bool {
+	version, seed, payload, hastotp, totpsecret, valid := ph.Data()
+	if !valid {
+		return false
+	}
+
+	if hastotp && totp == nil {
+		return false
+	}
+
+	if version == 0 {
+		return langext.ArrEqualsExact([]byte(plainpass), payload)
+	}
+
+	if version == 1 {
+		return langext.ArrEqualsExact(hash256(plainpass), payload)
+	}
+
+	if version == 2 {
+		return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload)
+	}
+
+	if version == 3 {
+		if !hastotp {
+			return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload)
+		} else {
+			return langext.ArrEqualsExact(hash256Seeded(plainpass, seed), payload) && totpext.Validate(totpsecret, *totp)
+		}
+	}
+
+	if version == 4 {
+		if !hastotp {
+			return bcrypt.CompareHashAndPassword(payload, []byte(plainpass)) == nil
+		} else {
+			return bcrypt.CompareHashAndPassword(payload, []byte(plainpass)) == nil && totpext.Validate(totpsecret, *totp)
+		}
+	}
+
+	return false
+}
+
+func (ph PassHash) NeedsPasswordUpgrade() bool {
+	version, _, _, _, _, valid := ph.Data()
+	return valid && version < LatestPassHashVersion
+}
+
+func (ph PassHash) Upgrade(plainpass string) (PassHash, error) {
+	version, _, _, hastotp, totpsecret, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid password")
+	}
+	if version == LatestPassHashVersion {
+		return ph, nil
+	}
+	if hastotp {
+		return HashPassword(plainpass, totpsecret)
+	} else {
+		return HashPassword(plainpass, nil)
+	}
+}
+
+func (ph PassHash) ClearTOTP() (PassHash, error) {
+	version, _, _, _, _, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid PassHash")
+	}
+
+	if version == 0 {
+		return ph, nil
+	}
+
+	if version == 1 {
+		return ph, nil
+	}
+
+	if version == 2 {
+		return ph, nil
+	}
+
+	if version == 3 {
+		split := strings.Split(string(ph), "|")
+		split[3] = "0"
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	if version == 4 {
+		split := strings.Split(string(ph), "|")
+		split[2] = "0"
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	return "", errors.New("unknown version")
+}
+
+func (ph PassHash) WithTOTP(totpSecret []byte) (PassHash, error) {
+	version, _, _, _, _, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid PassHash")
+	}
+
+	if version == 0 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 1 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 2 {
+		return "", errors.New("version does not support totp, needs upgrade")
+	}
+
+	if version == 3 {
+		split := strings.Split(string(ph), "|")
+		split[3] = hex.EncodeToString(totpSecret)
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	if version == 4 {
+		split := strings.Split(string(ph), "|")
+		split[2] = hex.EncodeToString(totpSecret)
+		return PassHash(strings.Join(split, "|")), nil
+	}
+
+	return "", errors.New("unknown version")
+}
+
+func (ph PassHash) Change(newPlainPass string) (PassHash, error) {
+	version, _, _, hastotp, totpsecret, valid := ph.Data()
+	if !valid {
+		return "", errors.New("invalid PassHash")
+	}
+
+	if version == 0 {
+		return HashPasswordV0(newPlainPass)
+	}
+
+	if version == 1 {
+		return HashPasswordV1(newPlainPass)
+	}
+
+	if version == 2 {
+		return HashPasswordV2(newPlainPass)
+	}
+
+	if version == 3 {
+		return HashPasswordV3(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
+	}
+
+	if version == 4 {
+		return HashPasswordV4(newPlainPass, langext.Conditional(hastotp, totpsecret, nil))
+	}
+
+	return "", errors.New("unknown version")
+}
+
+func (ph PassHash) String() string {
+	return string(ph)
+}
+
+func HashPassword(plainpass string, totpSecret []byte) (PassHash, error) {
+	return HashPasswordV4(plainpass, totpSecret)
+}
+
+func HashPasswordV4(plainpass string, totpSecret []byte) (PassHash, error) {
+	var strtotp string
+
+	if totpSecret == nil {
+		strtotp = "0"
+	} else {
+		strtotp = hex.EncodeToString(totpSecret)
+	}
+
+	payload, err := bcrypt.GenerateFromPassword([]byte(plainpass), bcrypt.MinCost)
+	if err != nil {
+		return "", err
+	}
+
+	return PassHash(fmt.Sprintf("4|%s|%s", string(payload), strtotp)), nil
+}
+
+func HashPasswordV3(plainpass string, totpSecret []byte) (PassHash, error) {
+	var strtotp string
+
+	if totpSecret == nil {
+		strtotp = "0"
+	} else {
+		strtotp = hex.EncodeToString(totpSecret)
+	}
+
+	seed, err := newSeed()
+	if err != nil {
+		return "", err
+	}
+
+	checksum := hash256Seeded(plainpass, seed)
+
+	return PassHash(fmt.Sprintf("3|%s|%s|%s",
+		base64.RawStdEncoding.EncodeToString(seed),
+		base64.RawStdEncoding.EncodeToString(checksum),
+		strtotp)), nil
+}
+
+func HashPasswordV2(plainpass string) (PassHash, error) {
+	seed, err := newSeed()
+	if err != nil {
+		return "", err
+	}
+
+	checksum := hash256Seeded(plainpass, seed)
+
+	return PassHash(fmt.Sprintf("2|%s|%s", base64.RawStdEncoding.EncodeToString(seed), base64.RawStdEncoding.EncodeToString(checksum))), nil
+}
+
+func HashPasswordV1(plainpass string) (PassHash, error) {
+	return PassHash(fmt.Sprintf("1|%s", base64.RawStdEncoding.EncodeToString(hash256(plainpass)))), nil
+}
+
+func HashPasswordV0(plainpass string) (PassHash, error) {
+	return PassHash(fmt.Sprintf("0|%s", plainpass)), nil
+}
+
+func hash256(s string) []byte {
+	h := sha256.New()
+	h.Write([]byte(s))
+	bs := h.Sum(nil)
+	return bs
+}
+
+func hash256Seeded(s string, seed []byte) []byte {
+	h := sha256.New()
+	h.Write(seed)
+	h.Write([]byte(s))
+	bs := h.Sum(nil)
+	return bs
+}
+
+func newSeed() ([]byte, error) {
+	secret := make([]byte, 32)
+	_, err := rand.Read(secret)
+	if err != nil {
+		return nil, err
+	}
+	return secret, nil
+}

dataext/bufferedReadCloser.go

@@ -1,56 +1,157 @@
 package dataext
 
-import "io"
+import (
+	"errors"
+	"io"
+)
+
+type brcMode int
+
+const (
+	modeSourceReading  brcMode = 0
+	modeSourceFinished brcMode = 1
+	modeBufferReading  brcMode = 2
+	modeBufferFinished brcMode = 3
+)
 
 type BufferedReadCloser interface {
 	io.ReadCloser
 	BufferedAll() ([]byte, error)
+	Reset() error
 }
 
 type bufferedReadCloser struct {
 	buffer []byte
 	inner  io.ReadCloser
-	finished bool
-}
-
-func (b *bufferedReadCloser) Read(p []byte) (int, error) {
-
-	n, err := b.inner.Read(p)
-	if n > 0 {
-		b.buffer = append(b.buffer, p[0:n]...)
-	}
-
-	if err == io.EOF {
-		b.finished = true
-	}
-
-	return n, err
+	mode   brcMode
+	off    int
 }
 
 func NewBufferedReadCloser(sub io.ReadCloser) BufferedReadCloser {
 	return &bufferedReadCloser{
 		buffer: make([]byte, 0, 1024),
 		inner:  sub,
-		finished: false,
+		mode:   modeSourceReading,
+		off:    0,
+	}
+}
+
+func (b *bufferedReadCloser) Read(p []byte) (int, error) {
+	switch b.mode {
+	case modeSourceReading:
+		n, err := b.inner.Read(p)
+		if n > 0 {
+			b.buffer = append(b.buffer, p[0:n]...)
+		}
+
+		if err == io.EOF {
+			b.mode = modeSourceFinished
+		}
+
+		return n, err
+
+	case modeSourceFinished:
+		return 0, io.EOF
+
+	case modeBufferReading:
+
+		if len(b.buffer) <= b.off {
+			b.mode = modeBufferFinished
+			if len(p) == 0 {
+				return 0, nil
+			}
+			return 0, io.EOF
+		}
+
+		n := copy(p, b.buffer[b.off:])
+		b.off += n
+		return n, nil
+
+	case modeBufferFinished:
+		return 0, io.EOF
+
+	default:
+		return 0, errors.New("object in undefined status")
 	}
 }
 
 func (b *bufferedReadCloser) Close() error {
-	err := b.inner.Close()
+	switch b.mode {
+	case modeSourceReading:
+		_, err := b.BufferedAll()
 		if err != nil {
-		b.finished = true
-	}
 			return err
 		}
+		err = b.inner.Close()
+		if err != nil {
+			return err
+		}
+		b.mode = modeSourceFinished
+		return nil
+
+	case modeSourceFinished:
+		return nil
+
+	case modeBufferReading:
+		b.mode = modeBufferFinished
+		return nil
+
+	case modeBufferFinished:
+		return nil
+
+	default:
+		return errors.New("object in undefined status")
+	}
+
+}
 
 func (b *bufferedReadCloser) BufferedAll() ([]byte, error) {
+	switch b.mode {
+	case modeSourceReading:
 		arr := make([]byte, 1024)
-	for !b.finished {
+		for b.mode == modeSourceReading {
 			_, err := b.Read(arr)
 			if err != nil && err != io.EOF {
 				return nil, err
 			}
 		}
-
 		return b.buffer, nil
+
+	case modeSourceFinished:
+		return b.buffer, nil
+
+	case modeBufferReading:
+		return b.buffer, nil
+
+	case modeBufferFinished:
+		return b.buffer, nil
+
+	default:
+		return nil, errors.New("object in undefined status")
+	}
+}
+
+func (b *bufferedReadCloser) Reset() error {
+	switch b.mode {
+	case modeSourceReading:
+		fallthrough
+	case modeSourceFinished:
+		err := b.Close()
+		if err != nil {
+			return err
+		}
+		b.mode = modeBufferReading
+		b.off = 0
+		return nil
+
+	case modeBufferReading:
+		fallthrough
+	case modeBufferFinished:
+		b.mode = modeBufferReading
+		b.off = 0
+		return nil
+
+	default:
+		return errors.New("object in undefined status")
+	}
 }

dataext/lruMap.go

@@ -19,40 +19,38 @@ import (
 // There are also a bunch of unit tests to ensure that the cache is always in a consistent state
 //
 
-type LRUData interface{}
-
-type LRUMap struct {
+type LRUMap[TKey comparable, TData any] struct {
 	maxsize int
 	lock    sync.Mutex
 
-	cache map[string]*cacheNode
+	cache map[TKey]*cacheNode[TKey, TData]
 
-	lfuHead *cacheNode
-	lfuTail *cacheNode
+	lfuHead *cacheNode[TKey, TData]
+	lfuTail *cacheNode[TKey, TData]
 }
 
-type cacheNode struct {
-	key    string
-	data   LRUData
-	parent *cacheNode
-	child  *cacheNode
+type cacheNode[TKey comparable, TData any] struct {
+	key    TKey
+	data   TData
+	parent *cacheNode[TKey, TData]
+	child  *cacheNode[TKey, TData]
 }
 
-func NewLRUMap(size int) *LRUMap {
+func NewLRUMap[TKey comparable, TData any](size int) *LRUMap[TKey, TData] {
 	if size <= 2 && size != 0 {
 		panic("Size must be > 2  (or 0)")
 	}
 
-	return &LRUMap{
+	return &LRUMap[TKey, TData]{
 		maxsize: size,
 		lock:    sync.Mutex{},
-		cache:   make(map[string]*cacheNode, size+1),
+		cache:   make(map[TKey]*cacheNode[TKey, TData], size+1),
 		lfuHead: nil,
 		lfuTail: nil,
 	}
 }
 
-func (c *LRUMap) Put(key string, value LRUData) {
+func (c *LRUMap[TKey, TData]) Put(key TKey, value TData) {
 	if c.maxsize == 0 {
 		return // cache disabled
 	}
@@ -70,7 +68,7 @@ func (c *LRUMap) Put(key string, value LRUData) {
 	}
 
 	// key does not exist: insert into map and add to top of LFU
-	node = &cacheNode{
+	node = &cacheNode[TKey, TData]{
 		key:    key,
 		data:   value,
 		parent: nil,
@@ -95,9 +93,9 @@ func (c *LRUMap) Put(key string, value LRUData) {
 	}
 }
 
-func (c *LRUMap) TryGet(key string) (LRUData, bool) {
+func (c *LRUMap[TKey, TData]) TryGet(key TKey) (TData, bool) {
 	if c.maxsize == 0 {
-		return nil, false // cache disabled
+		return *new(TData), false // cache disabled
 	}
 
 	c.lock.Lock()
@@ -105,13 +103,13 @@ func (c *LRUMap) TryGet(key string) (LRUData, bool) {
 
 	val, ok := c.cache[key]
 	if !ok {
-		return nil, false
+		return *new(TData), false
 	}
 	c.moveNodeToTop(val)
 	return val.data, ok
 }
 
-func (c *LRUMap) moveNodeToTop(node *cacheNode) {
+func (c *LRUMap[TKey, TData]) moveNodeToTop(node *cacheNode[TKey, TData]) {
 	// (only called in critical section !)
 
 	if c.lfuHead == node { // fast case
@@ -144,7 +142,7 @@ func (c *LRUMap) moveNodeToTop(node *cacheNode) {
 	}
 }
 
-func (c *LRUMap) Size() int {
+func (c *LRUMap[TKey, TData]) Size() int {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	return len(c.cache)

dataext/lruMap_test.go

@@ -12,7 +12,7 @@ func init() {
 }
 
 func TestResultCache1(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key := randomKey()
@@ -39,7 +39,7 @@ func TestResultCache1(t *testing.T) {
 	if !ok {
 		t.Errorf("cache TryGet returned no value")
 	}
-	if !eq(cacheval, val) {
+	if cacheval != val {
 		t.Errorf("cache TryGet returned different value (%+v <> %+v)", cacheval, val)
 	}
 
@@ -50,7 +50,7 @@ func TestResultCache1(t *testing.T) {
 }
 
 func TestResultCache2(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -150,7 +150,7 @@ func TestResultCache2(t *testing.T) {
 }
 
 func TestResultCache3(t *testing.T) {
-	cache := NewLRUMap(8)
+	cache := NewLRUMap[string](8)
 	verifyLRUList(cache, t)
 
 	key1 := "key1"
@@ -160,20 +160,20 @@ func TestResultCache3(t *testing.T) {
 	cache.Put(key1, val1)
 	verifyLRUList(cache, t)
 
-	if val, ok := cache.TryGet(key1); !ok || !eq(val, val1) {
+	if val, ok := cache.TryGet(key1); !ok || val != val1 {
 		t.Errorf("Value in cache should be [val1]")
 	}
 
 	cache.Put(key1, val2)
 	verifyLRUList(cache, t)
 
-	if val, ok := cache.TryGet(key1); !ok || !eq(val, val2) {
+	if val, ok := cache.TryGet(key1); !ok || val != val2 {
 		t.Errorf("Value in cache should be [val2]")
 	}
 }
 
 // does a basic consistency check over the internal cache representation
-func verifyLRUList(cache *LRUMap, t *testing.T) {
+func verifyLRUList[TData any](cache *LRUMap[TData], t *testing.T) {
 	size := 0
 
 	tailFound := false
@@ -250,23 +250,10 @@ func randomKey() string {
 	return strconv.FormatInt(rand.Int63(), 16)
 }
 
-func randomVal() LRUData {
+func randomVal() string {
 	v, err := langext.NewHexUUID()
 	if err != nil {
 		panic(err)
 	}
-	return &v
-}
-
-func eq(a LRUData, b LRUData) bool {
-	v1, ok1 := a.(*string)
-	v2, ok2 := b.(*string)
-	if ok1 && ok2 {
-		if v1 == nil || v2 == nil {
-			return false
-		}
-		return v1 == v2
-	}
-
-	return false
+	return v
 }

dataext/stack.go

@@ -0,0 +1,116 @@
+package dataext
+
+import (
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"sync"
+)
+
+var ErrEmptyStack = errors.New("stack is empty")
+
+type Stack[T any] struct {
+	lock *sync.Mutex
+	data []T
+}
+
+func NewStack[T any](threadsafe bool, initialCapacity int) *Stack[T] {
+	var lck *sync.Mutex = nil
+	if threadsafe {
+		lck = &sync.Mutex{}
+	}
+	return &Stack[T]{
+		lock: lck,
+		data: make([]T, 0, initialCapacity),
+	}
+}
+
+func (s *Stack[T]) Push(v T) {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	s.data = append(s.data, v)
+}
+
+func (s *Stack[T]) Pop() (T, error) {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	l := len(s.data)
+	if l == 0 {
+		return *new(T), ErrEmptyStack
+	}
+
+	result := s.data[l-1]
+	s.data = s.data[:l-1]
+
+	return result, nil
+}
+
+func (s *Stack[T]) OptPop() *T {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	l := len(s.data)
+	if l == 0 {
+		return nil
+	}
+
+	result := s.data[l-1]
+	s.data = s.data[:l-1]
+
+	return langext.Ptr(result)
+}
+
+func (s *Stack[T]) Peek() (T, error) {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	l := len(s.data)
+
+	if l == 0 {
+		return *new(T), ErrEmptyStack
+	}
+
+	return s.data[l-1], nil
+}
+
+func (s *Stack[T]) OptPeek() *T {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	l := len(s.data)
+
+	if l == 0 {
+		return nil
+	}
+
+	return langext.Ptr(s.data[l-1])
+}
+
+func (s *Stack[T]) Length() int {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	return len(s.data)
+}
+
+func (s *Stack[T]) Empty() bool {
+	if s.lock != nil {
+		s.lock.Lock()
+		defer s.lock.Unlock()
+	}
+
+	return len(s.data) == 0
+}

dataext/syncSet.go

@@ -2,17 +2,17 @@ package dataext
 
 import "sync"
 
-type SyncStringSet struct {
-	data map[string]bool
+type SyncSet[TData comparable] struct {
+	data map[TData]bool
 	lock sync.Mutex
 }
 
-func (s *SyncStringSet) Add(value string) bool {
+func (s *SyncSet[TData]) Add(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	_, ok := s.data[value]
@@ -21,12 +21,12 @@ func (s *SyncStringSet) Add(value string) bool {
 	return !ok
 }
 
-func (s *SyncStringSet) AddAll(values []string) {
+func (s *SyncSet[TData]) AddAll(values []TData) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	for _, value := range values {
@@ -34,12 +34,12 @@ func (s *SyncStringSet) AddAll(values []string) {
 	}
 }
 
-func (s *SyncStringSet) Contains(value string) bool {
+func (s *SyncSet[TData]) Contains(value TData) bool {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
 	_, ok := s.data[value]
@@ -47,15 +47,15 @@ func (s *SyncStringSet) Contains(value string) bool {
 	return ok
 }
 
-func (s *SyncStringSet) Get() []string {
+func (s *SyncSet[TData]) Get() []TData {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
 	if s.data == nil {
-		s.data = make(map[string]bool)
+		s.data = make(map[TData]bool)
 	}
 
-	r := make([]string, 0, len(s.data))
+	r := make([]TData, 0, len(s.data))
 
 	for k := range s.data {
 		r = append(r, k)

go.mod

@@ -3,8 +3,11 @@ module gogs.mikescher.com/BlackForestBytes/goext
 go 1.19
 
 require (
-	golang.org/x/sys v0.1.0
-	golang.org/x/term v0.1.0
+	golang.org/x/sys v0.3.0
+	golang.org/x/term v0.3.0
 )
 
-require github.com/jmoiron/sqlx v1.3.5 // indirect
+require (
+	github.com/jmoiron/sqlx v1.3.5 // indirect
+	golang.org/x/crypto v0.4.0 // indirect
+)

go.sum

@@ -3,7 +3,13 @@ github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
 github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
 github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8=
+golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
 golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
+golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.1.0 h1:g6Z6vPFA9dYBAF7DWcH6sCcOntplXsDKcliusYijMlw=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI=
+golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA=

langext/bool.go

@@ -15,3 +15,35 @@ func Conditional[T any](v bool, resTrue T, resFalse T) T {
 		return resFalse
 	}
 }
+
+func ConditionalFn00[T any](v bool, resTrue T, resFalse T) T {
+	if v {
+		return resTrue
+	} else {
+		return resFalse
+	}
+}
+
+func ConditionalFn10[T any](v bool, resTrue func() T, resFalse T) T {
+	if v {
+		return resTrue()
+	} else {
+		return resFalse
+	}
+}
+
+func ConditionalFn01[T any](v bool, resTrue T, resFalse func() T) T {
+	if v {
+		return resTrue
+	} else {
+		return resFalse()
+	}
+}
+
+func ConditionalFn11[T any](v bool, resTrue func() T, resFalse func() T) T {
+	if v {
+		return resTrue()
+	} else {
+		return resFalse()
+	}
+}

langext/pointer.go

@@ -34,3 +34,7 @@ func IsNil(i interface{}) bool {
 	}
 	return false
 }
+
+func PtrEquals[T comparable](v1 *T, v2 *T) bool {
+	return (v1 == nil && v2 == nil) || (v1 != nil && v2 != nil && *v1 == *v2)
+}

langext/sort.go

@@ -0,0 +1,57 @@
+package langext
+
+import "sort"
+
+func Sort[T OrderedConstraint](arr []T) {
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func SortStable[T OrderedConstraint](arr []T) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func IsSorted[T OrderedConstraint](arr []T) bool {
+	return sort.SliceIsSorted(arr, func(i1, i2 int) bool {
+		return arr[i1] < arr[i2]
+	})
+}
+
+func SortSlice[T any](arr []T, less func(v1, v2 T) bool) {
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}
+
+func SortSliceStable[T any](arr []T, less func(v1, v2 T) bool) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}
+
+func IsSliceSorted[T any](arr []T, less func(v1, v2 T) bool) bool {
+	return sort.SliceIsSorted(arr, func(i1, i2 int) bool {
+		return less(arr[i1], arr[i2])
+	})
+}
+
+func SortBy[TElem any, TSel OrderedConstraint](arr []TElem, selector func(v TElem) TSel) {
+	sort.Slice(arr, func(i1, i2 int) bool {
+		return selector(arr[i1]) < selector(arr[i2])
+	})
+}
+
+func SortByStable[TElem any, TSel OrderedConstraint](arr []TElem, selector func(v TElem) TSel) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return selector(arr[i1]) < selector(arr[i2])
+	})
+}
+
+func IsSortedBy[TElem any, TSel OrderedConstraint](arr []TElem, selector func(v TElem) TSel) {
+	sort.SliceStable(arr, func(i1, i2 int) bool {
+		return selector(arr[i1]) < selector(arr[i2])
+	})
+}

langext/string.go

@@ -107,3 +107,11 @@ func NumToStringOpt[V IntConstraint](v *V, fallback string) string {
 		return fmt.Sprintf("%d", v)
 	}
 }
+
+func StrRepeat(val string, count int) string {
+	r := ""
+	for i := 0; i < count; i++ {
+		r += val
+	}
+	return r
+}

rext/wrapper.go

@@ -0,0 +1,130 @@
+package rext
+
+import "regexp"
+
+type Regex interface {
+	IsMatch(haystack string) bool
+	MatchFirst(haystack string) (RegexMatch, bool)
+	MatchAll(haystack string) []RegexMatch
+	ReplaceAll(haystack string, repl string, literal bool) string
+	ReplaceAllFunc(haystack string, repl func(string) string) string
+	RemoveAll(haystack string) string
+	GroupCount() int
+}
+
+type regexWrapper struct {
+	rex      *regexp.Regexp
+	subnames []string
+}
+
+type RegexMatch struct {
+	haystack        string
+	submatchesIndex []int
+	subnames        []string
+}
+
+type RegexMatchGroup struct {
+	haystack string
+	start    int
+	end      int
+}
+
+func W(rex *regexp.Regexp) Regex {
+	return &regexWrapper{rex: rex, subnames: rex.SubexpNames()}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+func (w *regexWrapper) IsMatch(haystack string) bool {
+	return w.rex.MatchString(haystack)
+}
+
+func (w *regexWrapper) MatchFirst(haystack string) (RegexMatch, bool) {
+	res := w.rex.FindStringSubmatchIndex(haystack)
+	if res == nil {
+		return RegexMatch{}, false
+	}
+
+	return RegexMatch{haystack: haystack, submatchesIndex: res, subnames: w.subnames}, true
+}
+
+func (w *regexWrapper) MatchAll(haystack string) []RegexMatch {
+	resarr := w.rex.FindAllStringSubmatchIndex(haystack, -1)
+
+	matches := make([]RegexMatch, 0, len(resarr))
+	for _, res := range resarr {
+		matches = append(matches, RegexMatch{haystack: haystack, submatchesIndex: res, subnames: w.subnames})
+	}
+
+	return matches
+}
+
+func (w *regexWrapper) ReplaceAll(haystack string, repl string, literal bool) string {
+	if literal {
+		// do not expand placeholder aka $1, $2, ...
+		return w.rex.ReplaceAllLiteralString(haystack, repl)
+	} else {
+		return w.rex.ReplaceAllString(haystack, repl)
+	}
+}
+
+func (w *regexWrapper) ReplaceAllFunc(haystack string, repl func(string) string) string {
+	return w.rex.ReplaceAllStringFunc(haystack, repl)
+}
+
+func (w *regexWrapper) RemoveAll(haystack string) string {
+	return w.rex.ReplaceAllLiteralString(haystack, "")
+}
+
+// GroupCount returns the amount of groups in this match, does not count group-0 (whole match)
+func (w *regexWrapper) GroupCount() int {
+	return len(w.subnames) - 1
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+func (m RegexMatch) FullMatch() RegexMatchGroup {
+	return RegexMatchGroup{haystack: m.haystack, start: m.submatchesIndex[0], end: m.submatchesIndex[1]}
+}
+
+// GroupCount returns the amount of groups in this match, does not count group-0 (whole match)
+func (m RegexMatch) GroupCount() int {
+	return len(m.subnames) - 1
+}
+
+// GroupByIndex returns the value of a matched group (group 0 == whole match)
+func (m RegexMatch) GroupByIndex(idx int) RegexMatchGroup {
+	return RegexMatchGroup{haystack: m.haystack, start: m.submatchesIndex[idx*2], end: m.submatchesIndex[idx*2+1]}
+}
+
+// GroupByName returns the value of a matched group (group 0 == whole match)
+func (m RegexMatch) GroupByName(name string) RegexMatchGroup {
+	for idx, subname := range m.subnames {
+		if subname == name {
+			return RegexMatchGroup{haystack: m.haystack, start: m.submatchesIndex[idx*2], end: m.submatchesIndex[idx*2+1]}
+		}
+	}
+	panic("failed to find regex-group by name")
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+func (g RegexMatchGroup) Value() string {
+	return g.haystack[g.start:g.end]
+}
+
+func (g RegexMatchGroup) Start() int {
+	return g.start
+}
+
+func (g RegexMatchGroup) End() int {
+	return g.end
+}
+
+func (g RegexMatchGroup) Range() (int, int) {
+	return g.start, g.end
+}
+
+func (g RegexMatchGroup) Length() int {
+	return g.end - g.start
+}

rfctime/interface.go

@@ -0,0 +1,45 @@
+package rfctime
+
+import "time"
+
+type RFCTime interface {
+	Time() time.Time
+	Serialize() string
+
+	UnmarshalJSON(bytes []byte) error
+	MarshalJSON() ([]byte, error)
+
+	MarshalBinary() ([]byte, error)
+	UnmarshalBinary(data []byte) error
+
+	GobEncode() ([]byte, error)
+	GobDecode(data []byte) error
+
+	MarshalText() ([]byte, error)
+	UnmarshalText(data []byte) error
+
+	After(u RFCTime) bool
+	Before(u RFCTime) bool
+	Equal(u RFCTime) bool
+	IsZero() bool
+	Date() (year int, month time.Month, day int)
+	Year() int
+	Month() time.Month
+	Day() int
+	Weekday() time.Weekday
+	ISOWeek() (year, week int)
+	Clock() (hour, min, sec int)
+	Hour() int
+	Minute() int
+	Second() int
+	Nanosecond() int
+	YearDay() int
+	Sub(u RFCTime) time.Duration
+	Unix() int64
+	UnixMilli() int64
+	UnixMicro() int64
+	UnixNano() int64
+	Format(layout string) string
+	GoString() string
+	String() string
+}

rfctime/rfc3339Nano.go

@@ -0,0 +1,182 @@
+package rfctime
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type RFC3339NanoTime time.Time
+
+func (t RFC3339NanoTime) Time() time.Time {
+	return time.Time(t)
+}
+
+func (t RFC3339NanoTime) MarshalBinary() ([]byte, error) {
+	return (time.Time)(t).MarshalBinary()
+}
+
+func (t *RFC3339NanoTime) UnmarshalBinary(data []byte) error {
+	return (*time.Time)(t).UnmarshalBinary(data)
+}
+
+func (t RFC3339NanoTime) GobEncode() ([]byte, error) {
+	return (time.Time)(t).GobEncode()
+}
+
+func (t *RFC3339NanoTime) GobDecode(data []byte) error {
+	return (*time.Time)(t).GobDecode(data)
+}
+
+func (t *RFC3339NanoTime) UnmarshalJSON(data []byte) error {
+	str := ""
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	t0, err := time.Parse(t.FormatStr(), str)
+	if err != nil {
+		return err
+	}
+	*t = RFC3339NanoTime(t0)
+	return nil
+}
+
+func (t RFC3339NanoTime) MarshalJSON() ([]byte, error) {
+	str := t.Time().Format(t.FormatStr())
+	return json.Marshal(str)
+}
+
+func (t RFC3339NanoTime) MarshalText() ([]byte, error) {
+	b := make([]byte, 0, len(t.FormatStr()))
+	return t.Time().AppendFormat(b, t.FormatStr()), nil
+}
+
+func (t *RFC3339NanoTime) UnmarshalText(data []byte) error {
+	var err error
+	v, err := time.Parse(t.FormatStr(), string(data))
+	if err != nil {
+		return err
+	}
+	tt := RFC3339NanoTime(v)
+	*t = tt
+	return nil
+}
+
+func (t RFC3339NanoTime) Serialize() string {
+	return t.Time().Format(t.FormatStr())
+}
+
+func (t RFC3339NanoTime) FormatStr() string {
+	return time.RFC3339Nano
+}
+
+func (t RFC3339NanoTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
+}
+
+func (t RFC3339NanoTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
+}
+
+func (t RFC3339NanoTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t RFC3339NanoTime) IsZero() bool {
+	return t.Time().IsZero()
+}
+
+func (t RFC3339NanoTime) Date() (year int, month time.Month, day int) {
+	return t.Time().Date()
+}
+
+func (t RFC3339NanoTime) Year() int {
+	return t.Time().Year()
+}
+
+func (t RFC3339NanoTime) Month() time.Month {
+	return t.Time().Month()
+}
+
+func (t RFC3339NanoTime) Day() int {
+	return t.Time().Day()
+}
+
+func (t RFC3339NanoTime) Weekday() time.Weekday {
+	return t.Time().Weekday()
+}
+
+func (t RFC3339NanoTime) ISOWeek() (year, week int) {
+	return t.Time().ISOWeek()
+}
+
+func (t RFC3339NanoTime) Clock() (hour, min, sec int) {
+	return t.Time().Clock()
+}
+
+func (t RFC3339NanoTime) Hour() int {
+	return t.Time().Hour()
+}
+
+func (t RFC3339NanoTime) Minute() int {
+	return t.Time().Minute()
+}
+
+func (t RFC3339NanoTime) Second() int {
+	return t.Time().Second()
+}
+
+func (t RFC3339NanoTime) Nanosecond() int {
+	return t.Time().Nanosecond()
+}
+
+func (t RFC3339NanoTime) YearDay() int {
+	return t.Time().YearDay()
+}
+
+func (t RFC3339NanoTime) Add(d time.Duration) RFC3339NanoTime {
+	return RFC3339NanoTime(t.Time().Add(d))
+}
+
+func (t RFC3339NanoTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
+}
+
+func (t RFC3339NanoTime) AddDate(years int, months int, days int) RFC3339NanoTime {
+	return RFC3339NanoTime(t.Time().AddDate(years, months, days))
+}
+
+func (t RFC3339NanoTime) Unix() int64 {
+	return t.Time().Unix()
+}
+
+func (t RFC3339NanoTime) UnixMilli() int64 {
+	return t.Time().UnixMilli()
+}
+
+func (t RFC3339NanoTime) UnixMicro() int64 {
+	return t.Time().UnixMicro()
+}
+
+func (t RFC3339NanoTime) UnixNano() int64 {
+	return t.Time().UnixNano()
+}
+
+func (t RFC3339NanoTime) Format(layout string) string {
+	return t.Time().Format(layout)
+}
+
+func (t RFC3339NanoTime) GoString() string {
+	return t.Time().GoString()
+}
+
+func (t RFC3339NanoTime) String() string {
+	return t.Time().String()
+}
+
+func NewRFC3339Nano(t time.Time) RFC3339NanoTime {
+	return RFC3339NanoTime(t)
+}
+
+func NowRFC3339Nano() RFC3339NanoTime {
+	return RFC3339NanoTime(time.Now())
+}

rfctime/rfc3339Nano_test.go

@@ -0,0 +1,51 @@
+package rfctime
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestRoundtrip(t *testing.T) {
+
+	type Wrap struct {
+		Value RFC3339NanoTime `json:"v"`
+	}
+
+	val1 := NewRFC3339Nano(time.Now())
+	w1 := Wrap{val1}
+
+	jstr1, err := json.Marshal(w1)
+	if err != nil {
+		panic(err)
+	}
+
+	if string(jstr1) != "{\"v\":\"2023-01-29T20:32:36.149692117+01:00\"}" {
+		t.Errorf("repr differs")
+	}
+
+	w2 := Wrap{}
+
+	err = json.Unmarshal(jstr1, &w2)
+	if err != nil {
+		panic(err)
+	}
+
+	jstr2, err := json.Marshal(w2)
+	if err != nil {
+		panic(err)
+	}
+
+	assertEqual(t, string(jstr1), string(jstr2))
+
+	if !w1.Value.Equal(&w2.Value) {
+		t.Errorf("time differs")
+	}
+
+}
+
+func assertEqual(t *testing.T, actual string, expected string) {
+	if actual != expected {
+		t.Errorf("values differ: Actual: '%v', Expected: '%v'", actual, expected)
+	}
+}

rfctime/unix.go

@@ -0,0 +1,176 @@
+package rfctime
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+)
+
+type UnixTime time.Time
+
+func (t UnixTime) Time() time.Time {
+	return time.Time(t)
+}
+
+func (t UnixTime) MarshalBinary() ([]byte, error) {
+	return (time.Time)(t).MarshalBinary()
+}
+
+func (t *UnixTime) UnmarshalBinary(data []byte) error {
+	return (*time.Time)(t).UnmarshalBinary(data)
+}
+
+func (t UnixTime) GobEncode() ([]byte, error) {
+	return (time.Time)(t).GobEncode()
+}
+
+func (t *UnixTime) GobDecode(data []byte) error {
+	return (*time.Time)(t).GobDecode(data)
+}
+
+func (t *UnixTime) UnmarshalJSON(data []byte) error {
+	str := ""
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	t0, err := strconv.ParseInt(str, 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixTime(time.Unix(t0, 0))
+	return nil
+}
+
+func (t UnixTime) MarshalJSON() ([]byte, error) {
+	str := strconv.FormatInt(t.Time().Unix(), 10)
+	return json.Marshal(str)
+}
+
+func (t UnixTime) MarshalText() ([]byte, error) {
+	return []byte(strconv.FormatInt(t.Time().Unix(), 10)), nil
+}
+
+func (t *UnixTime) UnmarshalText(data []byte) error {
+	t0, err := strconv.ParseInt(string(data), 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixTime(time.Unix(t0, 0))
+	return nil
+}
+
+func (t UnixTime) Serialize() string {
+	return strconv.FormatInt(t.Time().Unix(), 10)
+}
+
+func (t UnixTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
+}
+
+func (t UnixTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
+}
+
+func (t UnixTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t UnixTime) IsZero() bool {
+	return t.Time().IsZero()
+}
+
+func (t UnixTime) Date() (year int, month time.Month, day int) {
+	return t.Time().Date()
+}
+
+func (t UnixTime) Year() int {
+	return t.Time().Year()
+}
+
+func (t UnixTime) Month() time.Month {
+	return t.Time().Month()
+}
+
+func (t UnixTime) Day() int {
+	return t.Time().Day()
+}
+
+func (t UnixTime) Weekday() time.Weekday {
+	return t.Time().Weekday()
+}
+
+func (t UnixTime) ISOWeek() (year, week int) {
+	return t.Time().ISOWeek()
+}
+
+func (t UnixTime) Clock() (hour, min, sec int) {
+	return t.Time().Clock()
+}
+
+func (t UnixTime) Hour() int {
+	return t.Time().Hour()
+}
+
+func (t UnixTime) Minute() int {
+	return t.Time().Minute()
+}
+
+func (t UnixTime) Second() int {
+	return t.Time().Second()
+}
+
+func (t UnixTime) Nanosecond() int {
+	return t.Time().Nanosecond()
+}
+
+func (t UnixTime) YearDay() int {
+	return t.Time().YearDay()
+}
+
+func (t UnixTime) Add(d time.Duration) UnixTime {
+	return UnixTime(t.Time().Add(d))
+}
+
+func (t UnixTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
+}
+
+func (t UnixTime) AddDate(years int, months int, days int) UnixTime {
+	return UnixTime(t.Time().AddDate(years, months, days))
+}
+
+func (t UnixTime) Unix() int64 {
+	return t.Time().Unix()
+}
+
+func (t UnixTime) UnixMilli() int64 {
+	return t.Time().UnixMilli()
+}
+
+func (t UnixTime) UnixMicro() int64 {
+	return t.Time().UnixMicro()
+}
+
+func (t UnixTime) UnixNano() int64 {
+	return t.Time().UnixNano()
+}
+
+func (t UnixTime) Format(layout string) string {
+	return t.Time().Format(layout)
+}
+
+func (t UnixTime) GoString() string {
+	return t.Time().GoString()
+}
+
+func (t UnixTime) String() string {
+	return t.Time().String()
+}
+
+func NewUnix(t time.Time) UnixTime {
+	return UnixTime(t)
+}
+
+func NowUnix() UnixTime {
+	return UnixTime(time.Now())
+}

rfctime/unixMilli.go

@@ -0,0 +1,176 @@
+package rfctime
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+)
+
+type UnixMilliTime time.Time
+
+func (t UnixMilliTime) Time() time.Time {
+	return time.Time(t)
+}
+
+func (t UnixMilliTime) MarshalBinary() ([]byte, error) {
+	return (time.Time)(t).MarshalBinary()
+}
+
+func (t *UnixMilliTime) UnmarshalBinary(data []byte) error {
+	return (*time.Time)(t).UnmarshalBinary(data)
+}
+
+func (t UnixMilliTime) GobEncode() ([]byte, error) {
+	return (time.Time)(t).GobEncode()
+}
+
+func (t *UnixMilliTime) GobDecode(data []byte) error {
+	return (*time.Time)(t).GobDecode(data)
+}
+
+func (t *UnixMilliTime) UnmarshalJSON(data []byte) error {
+	str := ""
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	t0, err := strconv.ParseInt(str, 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixMilliTime(time.UnixMilli(t0))
+	return nil
+}
+
+func (t UnixMilliTime) MarshalJSON() ([]byte, error) {
+	str := strconv.FormatInt(t.Time().UnixMilli(), 10)
+	return json.Marshal(str)
+}
+
+func (t UnixMilliTime) MarshalText() ([]byte, error) {
+	return []byte(strconv.FormatInt(t.Time().UnixMilli(), 10)), nil
+}
+
+func (t *UnixMilliTime) UnmarshalText(data []byte) error {
+	t0, err := strconv.ParseInt(string(data), 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixMilliTime(time.UnixMilli(t0))
+	return nil
+}
+
+func (t UnixMilliTime) Serialize() string {
+	return strconv.FormatInt(t.Time().UnixMilli(), 10)
+}
+
+func (t UnixMilliTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
+}
+
+func (t UnixMilliTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
+}
+
+func (t UnixMilliTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t UnixMilliTime) IsZero() bool {
+	return t.Time().IsZero()
+}
+
+func (t UnixMilliTime) Date() (year int, month time.Month, day int) {
+	return t.Time().Date()
+}
+
+func (t UnixMilliTime) Year() int {
+	return t.Time().Year()
+}
+
+func (t UnixMilliTime) Month() time.Month {
+	return t.Time().Month()
+}
+
+func (t UnixMilliTime) Day() int {
+	return t.Time().Day()
+}
+
+func (t UnixMilliTime) Weekday() time.Weekday {
+	return t.Time().Weekday()
+}
+
+func (t UnixMilliTime) ISOWeek() (year, week int) {
+	return t.Time().ISOWeek()
+}
+
+func (t UnixMilliTime) Clock() (hour, min, sec int) {
+	return t.Time().Clock()
+}
+
+func (t UnixMilliTime) Hour() int {
+	return t.Time().Hour()
+}
+
+func (t UnixMilliTime) Minute() int {
+	return t.Time().Minute()
+}
+
+func (t UnixMilliTime) Second() int {
+	return t.Time().Second()
+}
+
+func (t UnixMilliTime) Nanosecond() int {
+	return t.Time().Nanosecond()
+}
+
+func (t UnixMilliTime) YearDay() int {
+	return t.Time().YearDay()
+}
+
+func (t UnixMilliTime) Add(d time.Duration) UnixMilliTime {
+	return UnixMilliTime(t.Time().Add(d))
+}
+
+func (t UnixMilliTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
+}
+
+func (t UnixMilliTime) AddDate(years int, months int, days int) UnixMilliTime {
+	return UnixMilliTime(t.Time().AddDate(years, months, days))
+}
+
+func (t UnixMilliTime) Unix() int64 {
+	return t.Time().Unix()
+}
+
+func (t UnixMilliTime) UnixMilli() int64 {
+	return t.Time().UnixMilli()
+}
+
+func (t UnixMilliTime) UnixMicro() int64 {
+	return t.Time().UnixMicro()
+}
+
+func (t UnixMilliTime) UnixNano() int64 {
+	return t.Time().UnixNano()
+}
+
+func (t UnixMilliTime) Format(layout string) string {
+	return t.Time().Format(layout)
+}
+
+func (t UnixMilliTime) GoString() string {
+	return t.Time().GoString()
+}
+
+func (t UnixMilliTime) String() string {
+	return t.Time().String()
+}
+
+func NewUnixMilli(t time.Time) UnixMilliTime {
+	return UnixMilliTime(t)
+}
+
+func NowUnixMilli() UnixMilliTime {
+	return UnixMilliTime(time.Now())
+}

rfctime/unixNano.go

@@ -0,0 +1,176 @@
+package rfctime
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+)
+
+type UnixNanoTime time.Time
+
+func (t UnixNanoTime) Time() time.Time {
+	return time.Time(t)
+}
+
+func (t UnixNanoTime) MarshalBinary() ([]byte, error) {
+	return (time.Time)(t).MarshalBinary()
+}
+
+func (t *UnixNanoTime) UnmarshalBinary(data []byte) error {
+	return (*time.Time)(t).UnmarshalBinary(data)
+}
+
+func (t UnixNanoTime) GobEncode() ([]byte, error) {
+	return (time.Time)(t).GobEncode()
+}
+
+func (t *UnixNanoTime) GobDecode(data []byte) error {
+	return (*time.Time)(t).GobDecode(data)
+}
+
+func (t *UnixNanoTime) UnmarshalJSON(data []byte) error {
+	str := ""
+	if err := json.Unmarshal(data, &str); err != nil {
+		return err
+	}
+	t0, err := strconv.ParseInt(str, 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixNanoTime(time.Unix(0, t0))
+	return nil
+}
+
+func (t UnixNanoTime) MarshalJSON() ([]byte, error) {
+	str := strconv.FormatInt(t.Time().UnixNano(), 10)
+	return json.Marshal(str)
+}
+
+func (t UnixNanoTime) MarshalText() ([]byte, error) {
+	return []byte(strconv.FormatInt(t.Time().UnixNano(), 10)), nil
+}
+
+func (t *UnixNanoTime) UnmarshalText(data []byte) error {
+	t0, err := strconv.ParseInt(string(data), 10, 64)
+	if err != nil {
+		return err
+	}
+	*t = UnixNanoTime(time.Unix(0, t0))
+	return nil
+}
+
+func (t UnixNanoTime) Serialize() string {
+	return strconv.FormatInt(t.Time().UnixNano(), 10)
+}
+
+func (t UnixNanoTime) After(u RFCTime) bool {
+	return t.Time().After(u.Time())
+}
+
+func (t UnixNanoTime) Before(u RFCTime) bool {
+	return t.Time().Before(u.Time())
+}
+
+func (t UnixNanoTime) Equal(u RFCTime) bool {
+	return t.Time().Equal(u.Time())
+}
+
+func (t UnixNanoTime) IsZero() bool {
+	return t.Time().IsZero()
+}
+
+func (t UnixNanoTime) Date() (year int, month time.Month, day int) {
+	return t.Time().Date()
+}
+
+func (t UnixNanoTime) Year() int {
+	return t.Time().Year()
+}
+
+func (t UnixNanoTime) Month() time.Month {
+	return t.Time().Month()
+}
+
+func (t UnixNanoTime) Day() int {
+	return t.Time().Day()
+}
+
+func (t UnixNanoTime) Weekday() time.Weekday {
+	return t.Time().Weekday()
+}
+
+func (t UnixNanoTime) ISOWeek() (year, week int) {
+	return t.Time().ISOWeek()
+}
+
+func (t UnixNanoTime) Clock() (hour, min, sec int) {
+	return t.Time().Clock()
+}
+
+func (t UnixNanoTime) Hour() int {
+	return t.Time().Hour()
+}
+
+func (t UnixNanoTime) Minute() int {
+	return t.Time().Minute()
+}
+
+func (t UnixNanoTime) Second() int {
+	return t.Time().Second()
+}
+
+func (t UnixNanoTime) Nanosecond() int {
+	return t.Time().Nanosecond()
+}
+
+func (t UnixNanoTime) YearDay() int {
+	return t.Time().YearDay()
+}
+
+func (t UnixNanoTime) Add(d time.Duration) UnixNanoTime {
+	return UnixNanoTime(t.Time().Add(d))
+}
+
+func (t UnixNanoTime) Sub(u RFCTime) time.Duration {
+	return t.Time().Sub(u.Time())
+}
+
+func (t UnixNanoTime) AddDate(years int, months int, days int) UnixNanoTime {
+	return UnixNanoTime(t.Time().AddDate(years, months, days))
+}
+
+func (t UnixNanoTime) Unix() int64 {
+	return t.Time().Unix()
+}
+
+func (t UnixNanoTime) UnixMilli() int64 {
+	return t.Time().UnixNano()
+}
+
+func (t UnixNanoTime) UnixMicro() int64 {
+	return t.Time().UnixMicro()
+}
+
+func (t UnixNanoTime) UnixNano() int64 {
+	return t.Time().UnixNano()
+}
+
+func (t UnixNanoTime) Format(layout string) string {
+	return t.Time().Format(layout)
+}
+
+func (t UnixNanoTime) GoString() string {
+	return t.Time().GoString()
+}
+
+func (t UnixNanoTime) String() string {
+	return t.Time().String()
+}
+
+func NewUnixNano(t time.Time) UnixNanoTime {
+	return UnixNanoTime(t)
+}
+
+func NowUnixNano() UnixNanoTime {
+	return UnixNanoTime(time.Now())
+}

sq/database.go

@@ -12,14 +12,15 @@ type DB interface {
 	Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error)
 	Ping(ctx context.Context) error
 	BeginTransaction(ctx context.Context, iso sql.IsolationLevel) (Tx, error)
-	SetListener(listener Listener)
+	AddListener(listener Listener)
+	Exit() error
 }
 
 type database struct {
 	db    *sqlx.DB
 	txctr uint16
 	lock  sync.Mutex
-	lstr  Listener
+	lstr  []Listener
 }
 
 func NewDB(db *sqlx.DB) DB {
@@ -27,31 +28,50 @@ func NewDB(db *sqlx.DB) DB {
 		db:    db,
 		txctr: 0,
 		lock:  sync.Mutex{},
+		lstr:  make([]Listener, 0),
 	}
 }
 
-func (db *database) SetListener(listener Listener) {
-	db.lstr = listener
+func (db *database) AddListener(listener Listener) {
+	db.lstr = append(db.lstr, listener)
 }
 
-func (db *database) Exec(ctx context.Context, sql string, prep PP) (sql.Result, error) {
-	if db.lstr != nil {
-		db.lstr.OnExec(nil, sql, &prep)
+func (db *database) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
+	origsql := sqlstr
+	for _, v := range db.lstr {
+		err := v.PreExec(ctx, nil, &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	res, err := db.db.NamedExecContext(ctx, sqlstr, prep)
+
+	for _, v := range db.lstr {
+		v.PostExec(nil, origsql, sqlstr, prep)
 	}
 
-	res, err := db.db.NamedExecContext(ctx, sql, prep)
 	if err != nil {
 		return nil, err
 	}
 	return res, nil
 }
 
-func (db *database) Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error) {
-	if db.lstr != nil {
-		db.lstr.OnQuery(nil, sql, &prep)
+func (db *database) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
+	origsql := sqlstr
+	for _, v := range db.lstr {
+		err := v.PreQuery(ctx, nil, &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	rows, err := sqlx.NamedQueryContext(ctx, db.db, sqlstr, prep)
+
+	for _, v := range db.lstr {
+		v.PostQuery(nil, origsql, sqlstr, prep)
 	}
 
-	rows, err := db.db.NamedQueryContext(ctx, sql, prep)
 	if err != nil {
 		return nil, err
 	}
@@ -59,11 +79,19 @@ func (db *database) Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows,
 }
 
 func (db *database) Ping(ctx context.Context) error {
-	if db.lstr != nil {
-		db.lstr.OnPing()
+	for _, v := range db.lstr {
+		err := v.PrePing(ctx)
+		if err != nil {
+			return err
+		}
 	}
 
 	err := db.db.PingContext(ctx)
+
+	for _, v := range db.lstr {
+		v.PostPing(err)
+	}
+
 	if err != nil {
 		return err
 	}
@@ -76,8 +104,11 @@ func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel
 	db.txctr += 1 // with overflow !
 	db.lock.Unlock()
 
-	if db.lstr != nil {
-		db.lstr.OnTxBegin(txid)
+	for _, v := range db.lstr {
+		err := v.PreTxBegin(ctx, txid)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	xtx, err := db.db.BeginTxx(ctx, &sql.TxOptions{Isolation: iso})
@@ -85,5 +116,13 @@ func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel
 		return nil, err
 	}
 
+	for _, v := range db.lstr {
+		v.PostTxBegin(txid, err)
+	}
+
 	return NewTransaction(xtx, txid, db.lstr), nil
 }
+
+func (db *database) Exit() error {
+	return db.db.Close()
+}

sq/listener.go

@@ -1,10 +1,19 @@
 package sq
 
+import "context"
+
 type Listener interface {
-	OnQuery(txID *uint16, sql string, params *PP)
-	OnExec(txID *uint16, sql string, params *PP)
-	OnPing()
-	OnTxBegin(txid uint16)
-	OnTxCommit(txid uint16)
-	OnTxRollback(txid uint16)
+	PrePing(ctx context.Context) error
+	PreTxBegin(ctx context.Context, txid uint16) error
+	PreTxCommit(txid uint16) error
+	PreTxRollback(txid uint16) error
+	PreQuery(ctx context.Context, txID *uint16, sql *string, params *PP) error
+	PreExec(ctx context.Context, txID *uint16, sql *string, params *PP) error
+
+	PostPing(result error)
+	PostTxBegin(txid uint16, result error)
+	PostTxCommit(txid uint16, result error)
+	PostTxRollback(txid uint16, result error)
+	PostQuery(txID *uint16, sqlOriginal string, sqlReal string, params PP)
+	PostExec(txID *uint16, sqlOriginal string, sqlReal string, params PP)
 }

sq/params.go

@@ -1,3 +1,13 @@
 package sq
 
 type PP map[string]any
+
+func Join(pps ...PP) PP {
+	r := PP{}
+	for _, add := range pps {
+		for k, v := range add {
+			r[k] = v
+		}
+	}
+	return r
+}

sq/scanner.go

@@ -6,24 +6,78 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
-func ScanSingle[TData any](rows *sqlx.Rows, close bool) (TData, error) {
+type StructScanMode string
+
+const (
+	SModeFast     StructScanMode = "FAST"
+	SModeExtended StructScanMode = "EXTENDED"
+)
+
+type StructScanSafety string
+
+const (
+	Safe   StructScanSafety = "SAFE"
+	Unsafe StructScanSafety = "UNSAFE"
+)
+
+func ScanSingle[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) (TData, error) {
 	if rows.Next() {
+		var strscan *StructScanner
+
+		if sec == Safe {
+			strscan = NewStructScanner(rows, false)
 			var data TData
-		err := rows.StructScan(&data)
+			err := strscan.Start(&data)
 			if err != nil {
 				return *new(TData), err
 			}
+		} else if sec == Unsafe {
+			strscan = NewStructScanner(rows, true)
+			var data TData
+			err := strscan.Start(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else {
+			return *new(TData), errors.New("unknown value for <sec>")
+		}
+
+		var data TData
+
+		if mode == SModeFast {
+			err := strscan.StructScanBase(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else if mode == SModeExtended {
+			err := strscan.StructScanExt(&data)
+			if err != nil {
+				return *new(TData), err
+			}
+		} else {
+			return *new(TData), errors.New("unknown value for <mode>")
+		}
+
 		if rows.Next() {
-			_ = rows.Close()
-			return *new(TData), errors.New("sql returned more than onw row")
-		}
 			if close {
-			err = rows.Close()
+				_ = rows.Close()
+			}
+			return *new(TData), errors.New("sql returned more than one row")
+		}
+
+		if close {
+			err := rows.Close()
 			if err != nil {
 				return *new(TData), err
 			}
 		}
+
+		if err := rows.Err(); err != nil {
+			return *new(TData), err
+		}
+
 		return data, nil
+
 	} else {
 		if close {
 			_ = rows.Close()
@@ -32,21 +86,55 @@ func ScanSingle[TData any](rows *sqlx.Rows, close bool) (TData, error) {
 	}
 }
 
-func ScanAll[TData any](rows *sqlx.Rows, close bool) ([]TData, error) {
+func ScanAll[TData any](rows *sqlx.Rows, mode StructScanMode, sec StructScanSafety, close bool) ([]TData, error) {
+	var strscan *StructScanner
+
+	if sec == Safe {
+		strscan = NewStructScanner(rows, false)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return nil, err
+		}
+	} else if sec == Unsafe {
+		strscan = NewStructScanner(rows, true)
+		var data TData
+		err := strscan.Start(&data)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		return nil, errors.New("unknown value for <sec>")
+	}
+
 	res := make([]TData, 0)
 	for rows.Next() {
+		if mode == SModeFast {
 			var data TData
-		err := rows.StructScan(&data)
+			err := strscan.StructScanBase(&data)
 			if err != nil {
 				return nil, err
 			}
 			res = append(res, data)
+		} else if mode == SModeExtended {
+			var data TData
+			err := strscan.StructScanExt(&data)
+			if err != nil {
+				return nil, err
+			}
+			res = append(res, data)
+		} else {
+			return nil, errors.New("unknown value for <mode>")
+		}
 	}
 	if close {
-		err := rows.Close()
+		err := strscan.rows.Close()
 		if err != nil {
 			return nil, err
 		}
 	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
 	return res, nil
 }

sq/structscanner.go

@@ -0,0 +1,223 @@
+package sq
+
+import (
+	"errors"
+	"fmt"
+	"github.com/jmoiron/sqlx"
+	"github.com/jmoiron/sqlx/reflectx"
+	"reflect"
+)
+
+// forked from sqlx, but added ability to unmarshal optional-nested structs
+
+type StructScanner struct {
+	rows   *sqlx.Rows
+	Mapper *reflectx.Mapper
+	unsafe bool
+
+	fields  [][]int
+	values  []any
+	columns []string
+}
+
+func NewStructScanner(rows *sqlx.Rows, unsafe bool) *StructScanner {
+	return &StructScanner{
+		rows:   rows,
+		Mapper: reflectx.NewMapper("db"),
+		unsafe: unsafe,
+	}
+}
+
+func (r *StructScanner) Start(dest any) error {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	columns, err := r.rows.Columns()
+	if err != nil {
+		return err
+	}
+
+	r.columns = columns
+	r.fields = r.Mapper.TraversalsByName(v.Type(), columns)
+	// if we are not unsafe and are missing fields, return an error
+	if f, err := missingFields(r.fields); err != nil && !r.unsafe {
+		return fmt.Errorf("missing destination name %s in %T", columns[f], dest)
+	}
+	r.values = make([]interface{}, 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 {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	// ========= STEP 1 ::  =========
+
+	v = v.Elem()
+
+	err := fieldsByTraversalExtended(v, r.fields, r.values)
+	if err != nil {
+		return err
+	}
+	// scan into the struct field pointers and append to our results
+	err = r.rows.Scan(r.values...)
+	if err != nil {
+		return err
+	}
+
+	nullStructs := make(map[string]bool)
+
+	for i, traversal := range r.fields {
+		if len(traversal) == 0 {
+			continue
+		}
+
+		isnsil := reflect.ValueOf(r.values[i]).Elem().IsNil()
+
+		for i := 1; i < len(traversal); i++ {
+
+			canParentNil := reflectx.FieldByIndexes(v, traversal[0:i]).Kind() == reflect.Pointer
+
+			k := fmt.Sprintf("%v", traversal[0:i])
+			if v, ok := nullStructs[k]; ok {
+
+				nullStructs[k] = canParentNil && v && isnsil
+
+			} else {
+				nullStructs[k] = canParentNil && isnsil
+			}
+		}
+
+	}
+
+	forcenulled := make(map[string]bool)
+
+	for i, traversal := range r.fields {
+		if len(traversal) == 0 {
+			continue
+		}
+
+		anyparentnull := false
+		for i := 1; i < len(traversal); i++ {
+			k := fmt.Sprintf("%v", traversal[0:i])
+			if nv, ok := nullStructs[k]; ok && nv {
+
+				if _, ok := forcenulled[k]; !ok {
+					f := reflectx.FieldByIndexes(v, traversal[0:i])
+					f.Set(reflect.Zero(f.Type())) // set to nil
+					forcenulled[k] = true
+				}
+
+				anyparentnull = true
+				break
+
+			}
+		}
+
+		if anyparentnull {
+			continue
+		}
+
+		f := reflectx.FieldByIndexes(v, traversal)
+
+		val1 := reflect.ValueOf(r.values[i])
+		val2 := val1.Elem()
+		val3 := val2.Elem()
+
+		if val2.IsNil() {
+			if f.Kind() != reflect.Pointer {
+				return errors.New(fmt.Sprintf("Cannot set field %v to NULL value from column '%s' (type: %s)", traversal, r.columns[i], f.Type().String()))
+			}
+
+			f.Set(reflect.Zero(f.Type())) // set to nil
+		} else {
+			f.Set(val3)
+		}
+
+	}
+
+	return r.rows.Err()
+}
+
+// StructScanBase forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+// without (relevant) changes
+func (r *StructScanner) StructScanBase(dest any) error {
+	v := reflect.ValueOf(dest)
+
+	if v.Kind() != reflect.Ptr {
+		return errors.New("must pass a pointer, not a value, to StructScan destination")
+	}
+
+	v = v.Elem()
+
+	err := fieldsByTraversalBase(v, r.fields, r.values, true)
+	if err != nil {
+		return err
+	}
+	// scan into the struct field pointers and append to our results
+	err = r.rows.Scan(r.values...)
+	if err != nil {
+		return err
+	}
+	return r.rows.Err()
+}
+
+// fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func fieldsByTraversalExtended(v reflect.Value, traversals [][]int, values []interface{}) error {
+	v = reflect.Indirect(v)
+	if v.Kind() != reflect.Struct {
+		return errors.New("argument not a struct")
+	}
+
+	for i, traversal := range traversals {
+		if len(traversal) == 0 {
+			values[i] = new(interface{})
+			continue
+		}
+		f := reflectx.FieldByIndexes(v, traversal)
+
+		values[i] = reflect.New(reflect.PointerTo(f.Type())).Interface()
+	}
+	return nil
+}
+
+// fieldsByTraversal forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func fieldsByTraversalBase(v reflect.Value, traversals [][]int, values []interface{}, ptrs bool) error {
+	v = reflect.Indirect(v)
+	if v.Kind() != reflect.Struct {
+		return errors.New("argument not a struct")
+	}
+
+	for i, traversal := range traversals {
+		if len(traversal) == 0 {
+			values[i] = new(interface{})
+			continue
+		}
+		f := reflectx.FieldByIndexes(v, traversal)
+		if ptrs {
+			values[i] = f.Addr().Interface()
+		} else {
+			values[i] = f.Interface()
+		}
+	}
+	return nil
+}
+
+// missingFields forked from github.com/jmoiron/sqlx@v1.3.5/sqlx.go
+func missingFields(transversals [][]int) (field int, err error) {
+	for i, t := range transversals {
+		if len(t) == 0 {
+			return i, errors.New("missing field")
+		}
+	}
+	return 0, nil
+}

sq/transaction.go

@@ -17,10 +17,10 @@ type Tx interface {
 type transaction struct {
 	tx   *sqlx.Tx
 	id   uint16
-	lstr Listener
+	lstr []Listener
 }
 
-func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr Listener) Tx {
+func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr []Listener) Tx {
 	return &transaction{
 		tx:   xtx,
 		id:   txid,
@@ -29,39 +29,75 @@ func NewTransaction(xtx *sqlx.Tx, txid uint16, lstr Listener) Tx {
 }
 
 func (tx *transaction) Rollback() error {
-	if tx.lstr != nil {
-		tx.lstr.OnTxRollback(tx.id)
+	for _, v := range tx.lstr {
+		err := v.PreTxRollback(tx.id)
+		if err != nil {
+			return err
+		}
 	}
 
-	return tx.tx.Rollback()
+	result := tx.tx.Rollback()
+
+	for _, v := range tx.lstr {
+		v.PostTxRollback(tx.id, result)
+	}
+
+	return result
 }
 
 func (tx *transaction) Commit() error {
-	if tx.lstr != nil {
-		tx.lstr.OnTxCommit(tx.id)
+	for _, v := range tx.lstr {
+		err := v.PreTxCommit(tx.id)
+		if err != nil {
+			return err
+		}
 	}
 
-	return tx.tx.Commit()
+	result := tx.tx.Commit()
+
+	for _, v := range tx.lstr {
+		v.PostTxRollback(tx.id, result)
 	}
 
-func (tx *transaction) Exec(ctx context.Context, sql string, prep PP) (sql.Result, error) {
-	if tx.lstr != nil {
-		tx.lstr.OnExec(langext.Ptr(tx.id), sql, &prep)
+	return result
+}
+
+func (tx *transaction) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
+	origsql := sqlstr
+	for _, v := range tx.lstr {
+		err := v.PreExec(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	res, err := tx.tx.NamedExecContext(ctx, sqlstr, prep)
+
+	for _, v := range tx.lstr {
+		v.PostExec(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
 
-	res, err := tx.tx.NamedExecContext(ctx, sql, prep)
 	if err != nil {
 		return nil, err
 	}
 	return res, nil
 }
 
-func (tx *transaction) Query(ctx context.Context, sql string, prep PP) (*sqlx.Rows, error) {
-	if tx.lstr != nil {
-		tx.lstr.OnQuery(langext.Ptr(tx.id), sql, &prep)
+func (tx *transaction) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
+	origsql := sqlstr
+	for _, v := range tx.lstr {
+		err := v.PreQuery(ctx, langext.Ptr(tx.id), &sqlstr, &prep)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	rows, err := sqlx.NamedQueryContext(ctx, tx.tx, sqlstr, prep)
+
+	for _, v := range tx.lstr {
+		v.PostQuery(langext.Ptr(tx.id), origsql, sqlstr, prep)
 	}
 
-	rows, err := sqlx.NamedQueryContext(ctx, tx.tx, sql, prep)
 	if err != nil {
 		return nil, err
 	}