v0.0.491 small optimization in Paginate method

README.md

@@ -8,7 +8,7 @@ This should not have any heavy dependencies (gin, mongo, etc) and add missing ba
 Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 
 
-### Packages:
+## Packages:
 
 | Name        | Maintainer | Description                                                                                                   |
 |-------------|------------|---------------------------------------------------------------------------------------------------------------|
@@ -21,7 +21,7 @@ Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 | reflectext  | Mike       | Utility for golang reflection                                                                                 |
 | fsext       | Mike       | Utility for filesytem access                                                                                  |
 |             |            |                                                                                                               |
-| mongoext    | Mike       | Utility/Helper functions for mongodb                                                                          |
+| mongoext    | Mike       | Utility/Helper functions for mongodb (kinda abandoned)                                                        |
 | cursortoken | Mike       | MongoDB cursortoken implementation                                                                            |
 | pagination  | Mike       | Pagination implementation                                                                                     |
 |             |            |                                                                                                               |
@@ -42,4 +42,69 @@ Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 | wmo         | Mike       | Mongo Wrapper, wraps mongodb with a better interface                                                          |
 |             |            |                                                                                                               |
 | scn         | Mike       | SimpleCloudNotifier                                                                                           |
-|             |            |                                                                                                               |
+|             |            |                                                                                                               |
+
+
+
+## Usage:
+
+### exerr
+
+ - see **mongoext/builder.go** for full info
+
+Short summary:
+ - An better error package with metadata, listener, api-output and error-traces
+ - Initialize with `exerr.Init()`
+ - *Never* return `err` direct, always use exerr.Wrap(err, "...") - add metadata where applicable
+ - at the end either Print(), Fatal() or Output() your error (print = stdout, fatal = panic, output = json API response)
+ - You can add listeners with exerr.RegisterListener(), and save the full errors to a db or smth
+
+### wmo
+
+ - A typed wrapper around the official mongo-go-driver
+ - Use `wmo.W[...](...)` to wrap the collections and type-ify them
+ - The new collections have all the usual methods, but types
+ - Also they have List() and Paginate() methods for paginated listings (witehr with a cursortoken or page/limit)
+ - Register additional hooks with `WithDecodeFunc`, `WithUnmarshalHook`, `WithMarshalHook`, `WithModifyingPipeline`, `WithModifyingPipelineFunc`
+ - List(), Paginate(), etc support filter interfaces
+   - Rule(s) of thumb: 
+     - filter the results in the filter interface
+     - sort the results in the sort function of the filter interface
+     - add joins ($lookup's) in the `WithModifyingPipelineFunc`/`WithModifyingPipeline`
+
+#### ginext
+
+ - A wrapper around gin-gonic/gin
+ - create the gin engine with `ginext.NewEngine`
+ - Add routes with `engine.Routes()...`
+   - `.Use(..)` adds a middleware
+   - `.Group(..)` adds a group
+   - `.Get().Handle(..)` adds a handler
+ - Handler return values (in contract to ginext) - values implement the `ginext.HTTPResponse` interface
+ - Every handler starts with something like:
+```go 
+func (handler Handler) CommunityMetricsValues(pctx ginext.PreContext) ginext.HTTPResponse {
+    type communityURI struct {
+        Version     string             `uri:"version"`
+        CommunityID models.CommunityID `uri:"cid"`
+    }
+    type body struct {
+        UserID  models.UserID  `json:"userID"`
+        EventID models.EventID `json:"eventID"`
+    }
+
+    var u uri
+    var b body
+    ctx, gctx, httpErr := pctx.URI(&u).Body(&b).Start() // can have more unmarshaller, like header, form, etc
+    if httpErr != nil {
+    	return *httpErr
+    }
+    defer ctx.Cancel()
+
+    // do stuff
+}
+```
+
+#### sq
+
+ - TODO (like mongoext for sqlite/sql databases)

cursortoken/token.go

@@ -3,8 +3,8 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"errors"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"strings"
 	"time"
 )
@@ -127,7 +127,7 @@ func Decode(tok string) (CursorToken, error) {
 	}
 
 	if !strings.HasPrefix(tok, "tok_") {
-		return CursorToken{}, errors.New("could not decode token, missing prefix")
+		return CursorToken{}, exerr.New(exerr.TypeCursorTokenDecode, "could not decode token, missing prefix").Str("token", tok).Build()
 	}
 
 	body, err := base32.StdEncoding.DecodeString(tok[len("tok_"):])
@@ -138,7 +138,7 @@ func Decode(tok string) (CursorToken, error) {
 	var tokenDeserialize cursorTokenSerialize
 	err = json.Unmarshal(body, &tokenDeserialize)
 	if err != nil {
-		return CursorToken{}, err
+		return CursorToken{}, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).Build()
 	}
 
 	token := CursorToken{Mode: CTMNormal}

exerr/builder.go

@@ -30,6 +30,10 @@ import (
 // If possible add metadata to the error (eg the id that was not found, ...), the methods are the same as in zerolog
 //     return nil, exerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
 //
+// You can also add extra-data to an error with Extra(..)
+// in contrast to metadata is extradata always printed in the resulting error and is more intended for additional (programmatically readable) data in addition to the errortype
+// (metadata is more internal debug info/help)
+//
 // You can change the errortype with `.User()` and `.System()` (User-errors are 400 and System-errors 500)
 // You can also manually set the statuscode with `.WithStatuscode(http.NotFound)`
 // You can set the type with `WithType(..)`
@@ -76,12 +80,14 @@ func Wrap(err error, msg string) *Builder {
 		return &Builder{errorData: newExErr(CatSystem, TypeInternal, msg)} // prevent NPE if we call Wrap with err==nil
 	}
 
+	v := FromError(err)
+
 	if !pkgconfig.RecursiveErrors {
-		v := FromError(err)
 		v.Message = msg
 		return &Builder{wrappedErr: err, errorData: v}
+	} else {
+		return &Builder{wrappedErr: err, errorData: wrapExErr(v, msg, CatWrap, 1)}
 	}
-	return &Builder{wrappedErr: err, errorData: wrapExErr(FromError(err), msg, CatWrap, 1)}
 }
 
 // ----------------------------------------------------------------------------
@@ -368,29 +374,6 @@ func (b *Builder) CtxData(method Method, ctx context.Context) *Builder {
 	return b
 }
 
-func formatHeader(header map[string][]string) string {
-	ml := 1
-	for k, _ := range header {
-		if len(k) > ml {
-			ml = len(k)
-		}
-	}
-	r := ""
-	for k, v := range header {
-		if r != "" {
-			r += "\n"
-		}
-		for _, hval := range v {
-			value := hval
-			value = strings.ReplaceAll(value, "\n", "\\n")
-			value = strings.ReplaceAll(value, "\r", "\\r")
-			value = strings.ReplaceAll(value, "\t", "\\t")
-			r += langext.StrPadRight(k, " ", ml) + " := " + value
-		}
-	}
-	return r
-}
-
 func extractHeader(header map[string][]string) []string {
 	r := make([]string, 0, len(header))
 	for k, v := range header {
@@ -407,6 +390,16 @@ func extractHeader(header map[string][]string) []string {
 
 // ----------------------------------------------------------------------------
 
+// Extra adds additional data to the error
+// this is not like the other metadata (like Id(), Str(), etc)
+// this data is public and will be printed/outputted
+func (b *Builder) Extra(key string, val any) *Builder {
+	b.errorData.Extra[key] = val
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
 // Build creates a new error, ready to pass up the stack
 // If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
 // Can be gloablly configured with ZeroLogErrTraces and ZeroLogAllTraces
@@ -468,6 +461,10 @@ func (b *Builder) Print(ctxs ...context.Context) {
 		b.errorData.Log(pkgconfig.ZeroLogger.Error())
 	} else if b.errorData.Severity == SevWarn {
 		b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
+	} else if b.errorData.Severity == SevInfo {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
+	} else {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
 	}
 
 	b.errorData.CallListener(MethodPrint)

exerr/constructor.go

@@ -31,6 +31,7 @@ func FromError(err error) *ExErr {
 		Caller:         "",
 		OriginalError:  nil,
 		Meta:           getForeignMeta(err),
+		Extra:          make(map[string]any),
 	}
 }
 
@@ -48,6 +49,7 @@ func newExErr(cat ErrorCategory, errtype ErrorType, msg string) *ExErr {
 		Caller:         callername(2),
 		OriginalError:  nil,
 		Meta:           make(map[string]MetaValue),
+		Extra:          make(map[string]any),
 	}
 }
 
@@ -65,6 +67,7 @@ func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExE
 		Caller:         callername(1 + stacktraceskip),
 		OriginalError:  e,
 		Meta:           make(map[string]MetaValue),
+		Extra:          langext.CopyMap(langext.ForceMap(e.Extra)),
 	}
 }
 

exerr/dataType.go

@@ -23,6 +23,7 @@ var (
 	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
 	TypePanic          = NewType("PANIC", langext.Ptr(500))
 	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
+	TypeAssert         = NewType("ASSERT", langext.Ptr(500))
 
 	TypeMongoQuery        = NewType("MONGO_QUERY", langext.Ptr(500))
 	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500))

exerr/exerr.go

@@ -1,6 +1,7 @@
 package exerr
 
 import (
+	"fmt"
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
@@ -26,7 +27,8 @@ type ExErr struct {
 
 	OriginalError *ExErr `json:"originalError"`
 
-	Meta MetaMap `json:"meta"`
+	Extra map[string]any `json:"extra"`
+	Meta  MetaMap        `json:"meta"`
 }
 
 func (ee *ExErr) Error() string {
@@ -81,6 +83,23 @@ func (ee *ExErr) Log(evt *zerolog.Event) {
 }
 
 func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
+
+	// [LogPrintShort]
+	//
+	// - Only print message and type
+	// - Used e.g. for logging to the console when Build is called
+	// - also used in Print() if level == Warn/Info
+	//
+	// [LogPrintOverview]
+	//
+	// - print message, extra and errortrace
+	//
+	// [LogPrintFull]
+	//
+	// - print full error, with meta and extra, and trace, etc
+	// - Used in Output() and Print()
+	//
+
 	if lvl == LogPrintShort {
 
 		msg := ee.Message
@@ -101,6 +120,10 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 
 		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
 
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
 		indent := ""
 		for curr := ee; curr != nil; curr = curr.OriginalError {
 			indent += "  "
@@ -122,6 +145,10 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 
 		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
 
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
 		indent := ""
 		for curr := ee; curr != nil; curr = curr.OriginalError {
 			indent += "  "
@@ -328,6 +355,14 @@ func (ee *ExErr) GetMetaTime(key string) (time.Time, bool) {
 	return time.Time{}, false
 }
 
+func (ee *ExErr) GetExtra(key string) (any, bool) {
+	if v, ok := ee.Extra[key]; ok {
+		return v, true
+	}
+
+	return nil, false
+}
+
 // 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

@@ -90,6 +90,20 @@ func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool,
 		apiOutput["__data"] = ee.toJson(0, applyExtendListener, includeMetaFields)
 	}
 
+	for exkey, exval := range ee.Extra {
+
+		// ensure we do not override existing values
+		for {
+			if _, ok := apiOutput[exkey]; ok {
+				exkey = "_" + exkey
+			} else {
+				break
+			}
+		}
+
+		apiOutput[exkey] = exval
+	}
+
 	if applyExtendListener {
 		pkgconfig.ExtendGinOutput(ee, apiOutput)
 	}

ginext/cors.go

@@ -3,13 +3,17 @@ package ginext
 import (
 	"github.com/gin-gonic/gin"
 	"net/http"
+	"strings"
 )
 
-func CorsMiddleware() gin.HandlerFunc {
+func CorsMiddleware(allowheader []string, exposeheader []string) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
 		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
-		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", strings.Join(allowheader, ", "))
+		if len(exposeheader) > 0 {
+			c.Writer.Header().Set("Access-Control-Expose-Headers", strings.Join(exposeheader, ", "))
+		}
 		c.Writer.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE, COUNT")
 
 		if c.Request.Method == "OPTIONS" {

ginext/engine.go

@@ -21,12 +21,16 @@ type GinWrapper struct {
 
 	opt                   Options
 	allowCors             bool
+	corsAllowHeader       []string
+	corsExposeHeader      []string
 	ginDebug              bool
 	bufferBody            bool
 	requestTimeout        time.Duration
 	listenerBeforeRequest []func(g *gin.Context)
 	listenerAfterRequest  []func(g *gin.Context, resp HTTPResponse)
 
+	buildRequestBindError func(g *gin.Context, fieldtype string, err error) HTTPResponse
+
 	routeSpecs []ginRouteSpec
 }
 
@@ -38,15 +42,18 @@ type ginRouteSpec struct {
 }
 
 type Options struct {
-	AllowCors                *bool                                     // Add cors handler to allow all CORS requests on the default http methods
+	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)
+	CorsAllowHeader          *[]string                                                      // override the default values of Access-Control-Allow-Headers (AllowCors must be true)
-	SuppressGinLogs          *bool                                     // Suppress our custom gin logs (even if GinDebug == true)
+	CorsExposeHeader         *[]string                                                      // return Access-Control-Expose-Headers (AllowCors must be true)
-	BufferBody               *bool                                     // Buffers the input body stream, this way the ginext error handler can later include the whole request body
+	GinDebug                 *bool                                                          // Set gin.debug to true (adds more logs)
-	Timeout                  *time.Duration                            // The default handler timeout
+	SuppressGinLogs          *bool                                                          // Suppress our custom gin logs (even if GinDebug == true)
-	ListenerBeforeRequest    []func(g *gin.Context)                    // Register listener that are called before the handler method
+	BufferBody               *bool                                                          // Buffers the input body stream, this way the ginext error handler can later include the whole request body
-	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse) // Register listener that are called after the handler method
+	Timeout                  *time.Duration                                                 // The default handler timeout
-	DebugTrimHandlerPrefixes []string                                  // Trim these prefixes from the handler names in the debug print
+	ListenerBeforeRequest    []func(g *gin.Context)                                         // Register listener that are called before the handler method
-	DebugReplaceHandlerNames map[string]string                         // Replace handler names in debug output
+	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse)                      // Register listener that are called after the handler method
+	DebugTrimHandlerPrefixes []string                                                       // Trim these prefixes from the handler names in the debug print
+	DebugReplaceHandlerNames map[string]string                                              // Replace handler names in debug output
+	BuildRequestBindError    func(g *gin.Context, fieldtype string, err error) HTTPResponse // Override function which generates the HTTPResponse errors that are returned by the preContext..Start() methids
 }
 
 // NewEngine creates a new (wrapped) ginEngine
@@ -72,18 +79,21 @@ func NewEngine(opt Options) *GinWrapper {
 		opt:                   opt,
 		suppressGinLogs:       langext.Coalesce(opt.SuppressGinLogs, false),
 		allowCors:             langext.Coalesce(opt.AllowCors, false),
+		corsAllowHeader:       langext.Coalesce(opt.CorsAllowHeader, []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization", "accept", "origin", "Cache-Control", "X-Requested-With"}),
+		corsExposeHeader:      langext.Coalesce(opt.CorsExposeHeader, []string{}),
 		ginDebug:              ginDebug,
 		bufferBody:            langext.Coalesce(opt.BufferBody, false),
 		requestTimeout:        langext.Coalesce(opt.Timeout, 24*time.Hour),
 		listenerBeforeRequest: opt.ListenerBeforeRequest,
 		listenerAfterRequest:  opt.ListenerAfterRequest,
+		buildRequestBindError: langext.Conditional(opt.BuildRequestBindError == nil, defaultBuildRequestBindError, opt.BuildRequestBindError),
 	}
 
 	engine.RedirectFixedPath = false
 	engine.RedirectTrailingSlash = false
 
 	if wrapper.allowCors {
-		engine.Use(CorsMiddleware())
+		engine.Use(CorsMiddleware(wrapper.corsAllowHeader, wrapper.corsExposeHeader))
 	}
 
 	if ginDebug && !wrapper.suppressGinLogs {
@@ -218,3 +228,11 @@ func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
 func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
 	w.engine.ServeHTTP(writer, req)
 }
+
+func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
+	return w.engine.Routes()
+}
+
+func defaultBuildRequestBindError(g *gin.Context, fieldtype string, err error) HTTPResponse {
+	return Error(err)
+}

ginext/preContext.go

@@ -15,16 +15,17 @@ import (
 )
 
 type PreContext struct {
-	ginCtx         *gin.Context
+	ginCtx                 *gin.Context
-	wrapper        *GinWrapper
+	wrapper                *GinWrapper
-	uri            any
+	uri                    any
-	query          any
+	query                  any
-	body           any
+	body                   any
-	rawbody        *[]byte
+	rawbody                *[]byte
-	form           any
+	form                   any
-	header         any
+	header                 any
-	timeout        *time.Duration
+	timeout                *time.Duration
-	persistantData *preContextData // must be a ptr, so that we can get the values back in out Wrap func
+	persistantData         *preContextData // must be a ptr, so that we can get the values back in out Wrap func
+	ignoreWrongContentType bool
 }
 
 type preContextData struct {
@@ -71,6 +72,11 @@ func (pctx *PreContext) WithSession(sessionObj SessionObject) *PreContext {
 	return pctx
 }
 
+func (pctx *PreContext) IgnoreWrongContentType() *PreContext {
+	pctx.ignoreWrongContentType = true
+	return pctx
+}
+
 func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	if pctx.uri != nil {
 		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
@@ -78,7 +84,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailURI).
 				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
 		}
 	}
 
@@ -88,7 +94,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailQuery).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
 		}
 	}
 
@@ -99,13 +105,15 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailJSON).
 					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
 			}
 		} else {
-			err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
+			if !pctx.ignoreWrongContentType {
-				Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+				err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
-				Build()
+					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
-			return nil, nil, langext.Ptr(Error(err))
+					Build()
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+			}
 		}
 	}
 
@@ -113,14 +121,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		if brc, ok := pctx.ginCtx.Request.Body.(dataext.BufferedReadCloser); ok {
 			v, err := brc.BufferedAll()
 			if err != nil {
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = v
 		} else {
 			buf := &bytes.Buffer{}
 			_, err := io.Copy(buf, pctx.ginCtx.Request.Body)
 			if err != nil {
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = buf.Bytes()
 		}
@@ -133,7 +141,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else if pctx.ginCtx.ContentType() == "application/x-www-form-urlencoded" {
 			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
@@ -141,13 +149,15 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else {
-			err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
+			if !pctx.ignoreWrongContentType {
-				Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+				err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
-				Build()
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
-			return nil, nil, langext.Ptr(Error(err))
+					Build()
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+			}
 		}
 	}
 
@@ -157,7 +167,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailHeader).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
 		}
 	}
 
@@ -169,7 +179,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, actx)
 		if err != nil {
 			actx.Cancel()
-			return nil, nil, langext.Ptr(Error(exerr.Wrap(err, "Failed to init session").Build()))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
 		}
 	}
 

ginext/response.go

@@ -36,6 +36,12 @@ type InspectableHTTPResponse interface {
 	Headers() []string
 }
 
+type HTTPErrorResponse interface {
+	HTTPResponse
+
+	Error() error
+}
+
 func NotImplemented() HTTPResponse {
 	return Error(exerr.New(exerr.TypeNotImplemented, "").Build())
 }

ginext/responseJsonAPI.go

@@ -13,6 +13,10 @@ type jsonAPIErrResponse struct {
 	cookies []cookieval
 }
 
+func (j jsonAPIErrResponse) Error() error {
+	return j.err
+}
+
 func (j jsonAPIErrResponse) Write(g *gin.Context) {
 	for _, v := range j.headers {
 		g.Header(v.Key, v.Val)

go.mod

@@ -9,9 +9,9 @@ require (
 	github.com/rs/xid v1.5.0
 	github.com/rs/zerolog v1.33.0
 	go.mongodb.org/mongo-driver v1.16.0
-	golang.org/x/crypto v0.24.0
+	golang.org/x/crypto v0.25.0
-	golang.org/x/sys v0.21.0
+	golang.org/x/sys v0.22.0
-	golang.org/x/term v0.21.0
+	golang.org/x/term v0.22.0
 )
 
 require (
@@ -21,14 +21,14 @@ require (
 )
 
 require (
-	github.com/bytedance/sonic v1.11.9 // indirect
+	github.com/bytedance/sonic v1.12.0 // indirect
-	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/bytedance/sonic/loader v0.2.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.1 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.4 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.5 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
@@ -52,10 +52,10 @@ require (
 	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-20240424034433-3c2c7870ae76 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
 	golang.org/x/arch v0.8.0 // indirect
 	golang.org/x/image v0.18.0 // indirect
-	golang.org/x/net v0.26.0 // indirect
+	golang.org/x/net v0.27.0 // indirect
 	golang.org/x/text v0.16.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

@@ -24,9 +24,13 @@ github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LR
 github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic v1.11.9 h1:LFHENlIY/SLzDWverzdOvgMztTxcfcF+cqNsz9pK5zg=
 github.com/bytedance/sonic v1.11.9/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic v1.12.0 h1:YGPgxF9xzaCNvd/ZKdQ28yRovhfMFZQjuk6fKBzZ3ls=
+github.com/bytedance/sonic v1.12.0/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
 github.com/bytedance/sonic/loader v0.1.0/go.mod h1:UmRT+IRTGKz/DAkzcEGzyVqQFJ7H9BqwBO3pm9H/+HY=
 github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
+github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
@@ -57,6 +61,8 @@ github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uq
 github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I=
 github.com/gabriel-vasile/mimetype v1.4.4/go.mod h1:JwLei5XPtWdGiMFB5Pjle1oEeoSeEuJfJE+TtfvdB/s=
+github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
+github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
 github.com/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=
@@ -213,6 +219,8 @@ github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a h1:fZHgsYlfvtyqTosly
 github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a/go.mod h1:ul22v+Nro/R083muKhosV54bj5niojjWZvU8xrevuH4=
 github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 h1:tBiBTKHnIjovYoLX/TPkcf+OjqqKGQrPtGT3Foz+Pgo=
 github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76/go.mod h1:SQliXeA7Dhkt//vS29v3zpbEwoa+zb2Cn5xj5uO4K5U=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 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=
@@ -249,6 +257,8 @@ golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 h1:hVwzHzIUGRjiF7EcUjqNxk3NCfkPxbDKRdnNE1Rpg0U=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -278,6 +288,8 @@ golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
 golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
 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.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
@@ -307,6 +319,8 @@ golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.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.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
@@ -321,6 +335,8 @@ golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
 golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
+golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
 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=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.477"
+const GoextVersion = "0.0.491"
 
-const GoextVersionTimestamp = "2024-06-29T15:36:39+0200"
+const GoextVersionTimestamp = "2024-07-31T00:15:09+0200"

langext/maps.go

@@ -66,7 +66,7 @@ func CopyMap[K comparable, V any](a map[K]V) map[K]V {
 
 func ForceMap[K comparable, V any](v map[K]V) map[K]V {
 	if v == nil {
-		return make(map[K]V, 0)
+		return make(map[K]V)
 	} else {
 		return v
 	}

mathext/statistics.go

@@ -1,6 +1,9 @@
 package mathext
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
 
 func Sum[T langext.NumberConstraint](v []T) T {
 	total := T(0)
@@ -41,3 +44,53 @@ func ArrMax[T langext.OrderedConstraint](v []T) T {
 	}
 	return r
 }
+
+func MustPercentile[T langext.NumberConstraint](rawdata []T, percentile float64) T {
+	v, err := Percentile(rawdata, percentile)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+func Percentile[T langext.NumberConstraint](rawdata []T, percentile float64) (T, error) {
+	v, err := FloatPercentile(rawdata, percentile)
+	if err != nil {
+		return T(0), err
+	}
+	return T(v), nil
+
+}
+
+func FloatPercentile[T langext.NumberConstraint](rawdata []T, percentile float64) (float64, error) {
+	if len(rawdata) == 0 {
+		return 0, exerr.New(exerr.TypeAssert, "no data to calculate percentile").Any("percentile", percentile).Build()
+	}
+
+	if percentile < 0 || percentile > 100 {
+		return 0, exerr.New(exerr.TypeAssert, "percentile out of range").Any("percentile", percentile).Build()
+	}
+
+	data := langext.ArrCopy(rawdata)
+	langext.Sort(data)
+
+	idxFloat := float64(len(data)-1) * (percentile / float64(100))
+
+	idxInt := int(idxFloat)
+
+	// exact match on index
+	if idxFloat == float64(idxInt) {
+		return float64(data[idxInt]), nil
+	}
+
+	// linear interpolation
+	v1 := data[idxInt]
+	v2 := data[idxInt+1]
+
+	weight := idxFloat - float64(idxInt)
+
+	valFloat := (float64(v1) * (1 - weight)) + (float64(v2) * weight)
+
+	return valFloat, nil
+
+}

mathext/statistics_test.go

@@ -0,0 +1,238 @@
+package mathext
+
+import (
+	"math"
+	"testing"
+)
+
+func TestSumIntsHappyPath(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	expected := 15
+	result := Sum(values)
+	if result != expected {
+		t.Errorf("Sum of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestSumFloatsHappyPath(t *testing.T) {
+	values := []float64{1.1, 2.2, 3.3}
+	expected := 6.6
+	result := Sum(values)
+	if result != expected {
+		t.Errorf("Sum of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMeanOfInts(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	expected := 3.0
+	result := Mean(values)
+	if result != expected {
+		t.Errorf("Mean of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMedianOddNumberOfElements(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	expected := 3.0
+	result := Median(values)
+	if result != expected {
+		t.Errorf("Median of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMedianEvenNumberOfElements(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5, 6}
+	expected := 3.5
+	result := Median(values)
+	if result != expected {
+		t.Errorf("Median of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestArrMinInts(t *testing.T) {
+	values := []int{5, 3, 9, 1, 4}
+	expected := 1
+	result := ArrMin(values)
+	if result != expected {
+		t.Errorf("ArrMin of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestArrMaxInts(t *testing.T) {
+	values := []int{5, 3, 9, 1, 4}
+	expected := 9
+	result := ArrMax(values)
+	if result != expected {
+		t.Errorf("ArrMax of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestPercentileValidInput(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	percentile := 50.0
+	expected := 3
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileOutOfRange(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	percentile := 150.0
+	_, err := Percentile(values, percentile)
+	if err == nil {
+		t.Errorf("Expected error for percentile %v out of range, got nil", percentile)
+	}
+}
+
+func TestPercentileValueInArray(t *testing.T) {
+	values := []int{1, 3, 5, 7, 9}
+	percentile := 40.0
+	expected := 4
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileValueInArray(t *testing.T) {
+	values := []int{1, 3, 5, 7, 9}
+	percentile := 40.0
+	expected := 4.2
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileInterpolation(t *testing.T) {
+	values := []float64{1.0, 2.0, 3.0, 4.0, 5.0}
+	percentile := 25.0
+	expected := 2.0
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileSingleValue(t *testing.T) {
+	values := []int{10}
+	percentile := 50.0
+	expected := 10
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileExactlyBetweenTwoValues(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	percentile := 62.5 // Exactly between 3 and 4
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileTwoThirdsBetweenTwoValues(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 66.666666666666
+	expected := 6.666666666666667 // Since 2/3 of the way between 6 and 7 is 6.666...
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileBetweenTwoValues1(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 11.0
+	expected := 1.1
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileBetweenTwoValues2(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 9.0
+	expected := 0.9
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInput(t *testing.T) {
+	values := []float64{5, 1, 4, 2, 3} // Unsorted input
+	percentile := 50.0
+	expected := 3.0
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInputLowPercentile(t *testing.T) {
+	values := []float64{10, 6, 7, 3, 2, 9, 8, 1, 4, 5} // Unsorted input
+	percentile := 10.0
+	expected := 1.9 // Expecting interpolation between 1 and 2
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInputHighPercentile(t *testing.T) {
+	values := []float64{10, 6, 7, 3, 2, 9, 8, 1, 4, 5} // Unsorted input
+	percentile := 90.0
+	expected := 9.1 // Expecting interpolation between 9 and 10
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileExactValueFromInput(t *testing.T) {
+	values := []float64{1.5, 2.5, 3.5, 4.5, 5.5}
+	percentile := 50.0 // Exact value from input array should be 3.5
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileInterpolatedValue(t *testing.T) {
+	values := []float64{1.0, 2.0, 3.0, 4.0, 5.0}
+	percentile := 87.5 // Interpolated value between 4.0 and 5.0
+	expected := 4.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileUnsortedInputExactValue(t *testing.T) {
+	values := []float64{5.5, 1.5, 4.5, 2.5, 3.5} // Unsorted input
+	percentile := 50.0
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileUnsortedInputInterpolatedValue(t *testing.T) {
+	values := []float64{10.5, 6.5, 7.5, 3.5, 2.5, 9.5, 8.5, 1.5, 4.5, 5.5}
+	percentile := 80.0 // Interpolated value between 4.0 and 5.0
+	expected := 8.7
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}

reflectext/structAccess.go

@@ -0,0 +1,185 @@
+package reflectext
+
+import (
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+var ErrAccessStructInvalidFieldType = errors.New("invalid field type")
+var ErrAccessStructFieldInPathWasNil = errors.New("a field in the path was nil")
+var ErrAccessStructInvalidArrayIndex = errors.New("invalid array index")
+var ErrAccessStructInvalidMapKey = errors.New("invalid map key")
+var ErrAccessStructArrayAccess = errors.New("trying to access array")
+var ErrAccessStructMapAccess = errors.New("trying to access map")
+var ErrAccessStructMissingField = errors.New("missing field")
+
+type AccessStructOpt struct {
+	ReturnNilOnMissingFields          bool    // return nil (instead of error) when a field in the path is missing (aka the supplied path is wrong)
+	ReturnNilOnNilPtrFields           bool    // return nil (instead of error) when a field in the path is nil
+	ReturnNilOnWrongFinalFieldType    bool    // return nil (instead of error) when the (final) field is not of the requested generic type
+	ReturnNilOnWrongIntermedFieldType bool    // return nil (instead of error) when the intermediate field has an invalid type
+	ReturnNilOnInvalidArrayIndizes    bool    // return nil (instead of error) when trying to acces an array with an invalid index (not a number or out of range)
+	ReturnNilOnMissingMapKeys         bool    // return nil (instead of error) when trying to access a map with a missing key
+	UsedTagForKeys                    *string // Use this tag for key names in the struct (instead of the StructField.Name)
+	PreventArrayAccess                bool    // do not access array indizes - throw an error instead
+	PreventMapAccess                  bool    // do not access maps - throw an error instead
+}
+
+func AccessJSONStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: langext.Ptr("json")})
+}
+
+func AccessStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{})
+}
+
+func AccessStructByArrayPath[TResult any](v any, path []string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), path, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func AccessStructByStringPath[TResult any](v any, path string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+	arrpath := strings.Split(path, ".")
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), arrpath, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func accessStructByPath(val reflect.Value, path []string, opt AccessStructOpt) (any, error) {
+	if len(path) == 0 {
+		return val.Interface(), nil
+	}
+
+	currPath := path[0]
+
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+		return accessStructByPath(val.Elem(), path, opt)
+	}
+
+	if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
+		if opt.PreventArrayAccess {
+			return nil, ErrAccessStructArrayAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		arrIdx, err := strconv.ParseInt(currPath, 10, 64)
+		if err != nil {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		if arrIdx < 0 || int(arrIdx) >= val.Len() {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		return accessStructByPath(val.Index(int(arrIdx)), path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Map {
+		if opt.PreventMapAccess {
+			return nil, ErrAccessStructMapAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		mapval := val.MapIndex(reflect.ValueOf(currPath))
+		if !mapval.IsValid() || mapval.IsZero() {
+			if opt.ReturnNilOnMissingMapKeys {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidMapKey
+			}
+		}
+
+		return accessStructByPath(mapval, path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Struct {
+		if opt.UsedTagForKeys != nil {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Tag.Get(*opt.UsedTagForKeys) == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		} else {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Name == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		}
+	}
+
+	if opt.ReturnNilOnWrongIntermedFieldType {
+		return nil, nil
+	} else {
+		return nil, ErrAccessStructMissingField
+	}
+}

reflectext/structAccess_test.go

@@ -0,0 +1,259 @@
+package reflectext
+
+import "testing"
+
+type TestStruct struct {
+	Name string `json:"name"`
+	Age  int    `json:"age"`
+}
+
+func TestAccessStructByArrayPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByStringPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByStringPath[string](testStruct, "Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByStringPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByStringPath[string](testStruct, "Invalid")
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type RecursiveStruct struct {
+	Name     string
+	Sub      *RecursiveStruct
+	SubSlice []RecursiveStruct
+}
+
+func TestAccessStructByArrayPath_RecursiveStruct(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", Sub: &RecursiveStruct{Name: "Jane"}}
+	result, err := AccessStructByArrayPath[string](*testStruct.Sub, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_RecursiveStructSlice(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", SubSlice: []RecursiveStruct{{Name: "Jane"}}}
+	result, err := AccessStructByArrayPath[string](testStruct.SubSlice[0], []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_WrongType(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[int](testStruct, []string{"Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Name", "Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStruct struct {
+	Name string
+	Sub  *TestStruct
+}
+
+func TestAccessStructByStringPath_NestedStruct(t *testing.T) {
+	testStruct := NestedStruct{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+type DeepNestedStruct struct {
+	Name string
+	Sub  *NestedStruct
+}
+
+func TestAccessStructByStringPath_DeepNestedStruct(t *testing.T) {
+	testStruct := DeepNestedStruct{Name: "John", Sub: &NestedStruct{Name: "Jane", Sub: &TestStruct{Name: "Doe", Age: 30}}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Doe" {
+		t.Errorf("Expected 'Doe', got '%s'", result)
+	}
+}
+
+type MapStruct struct {
+	Name string
+	Age  int
+}
+
+type TestStructWithMap struct {
+	MapField map[string]MapStruct
+}
+
+func TestAccessStructByArrayPath_MapField(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "key", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidMapKey(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "invalid", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type ArrayStruct struct {
+	Name string
+	Arr  []TestStruct
+}
+
+func TestAccessStructByArrayPath_ArrayField(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "0", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidArrayIndex(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "1", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type FunctionStruct struct {
+	Name string
+	Func func() string
+}
+
+func TestAccessStructByArrayPath_FunctionField(t *testing.T) {
+	testStruct := FunctionStruct{Name: "John", Func: func() string { return "Hello" }}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Func"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_NonExistentPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"NonExistent"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStructWithTag struct {
+	Name string      `json:"name"`
+	Sub  *TestStruct `json:"sub"`
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeys(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "name"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeysInvalid(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "invalid"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type DifferentTypeStruct struct {
+	Name string
+	Age  int
+}
+
+func TestAccessStructByArrayPath_DifferentType(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[any](testStruct, []string{"Age"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != 30 {
+		t.Errorf("Expected '30', got '%v'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_DifferentTypeInvalid(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[any](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}

timeext/diff.go

@@ -0,0 +1,13 @@
+package timeext
+
+import "time"
+
+func YearDifference(t1 time.Time, t2 time.Time, tz *time.Location) float64 {
+
+	yDelta := float64(t1.Year() - t2.Year())
+
+	processT1 := float64(t1.Sub(TimeToYearStart(t1, tz))) / float64(TimeToYearEnd(t1, tz).Sub(TimeToYearStart(t1, tz)))
+	processT2 := float64(t2.Sub(TimeToYearStart(t2, tz))) / float64(TimeToYearEnd(t2, tz).Sub(TimeToYearStart(t2, tz)))
+
+	return yDelta + (processT1 - processT2)
+}

timeext/diff_test.go

@@ -0,0 +1,83 @@
+package timeext
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+func TestYearDifferenceWithSameYearAndDay(t *testing.T) {
+	t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.0
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithOneYearApart(t *testing.T) {
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 1.0
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithDifferentMonths(t *testing.T) {
+	t1 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.4166666666666667 // Approximation of 5/12 months
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceAcrossYears(t *testing.T) {
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.5833333333333334 // Approximation of 7/12 months
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithTimezone(t *testing.T) {
+	tz, _ := time.LoadLocation("America/New_York")
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, tz)
+	t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, tz)
+	expected := 0.5833333333333334 // Same as UTC but ensuring timezone is considered
+	result := YearDifference(t1, t2, tz)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithNegativeDifference(t *testing.T) {
+	t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
+	t2 := time.Date(2021, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
+	expected := -1.0
+	result := YearDifference(t1, t2, TimezoneBerlin)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithNegativeDifference2(t *testing.T) {
+	t1 := time.Date(2020, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
+	t2 := time.Date(2021, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
+	expected := -1.0
+	result := YearDifference(t1, t2, TimezoneBerlin)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func epsilonEquals(a, b float64) bool {
+	epsilon := 0.01
+	return math.Abs(a-b) < epsilon
+}

timeext/time.go

@@ -65,6 +65,10 @@ func TimeToYearEnd(t time.Time, tz *time.Location) time.Time {
 	return TimeToYearStart(t, tz).AddDate(1, 0, 0).Add(-1)
 }
 
+func TimeToNextYearStart(t time.Time, tz *time.Location) time.Time {
+	return TimeToYearStart(t, tz).AddDate(1, 0, 0)
+}
+
 // IsSameDayIncludingDateBoundaries returns true if t1 and t2 are part of the same day (TZ/Berlin), the boundaries of the day are
 // inclusive, this means 2021-09-15T00:00:00 is still part of the day 2021-09-14
 func IsSameDayIncludingDateBoundaries(t1 time.Time, t2 time.Time, tz *time.Location) bool {

timeext/time_test.go

@@ -72,6 +72,13 @@ func TestIsSunday(t *testing.T) {
 	}
 }
 
+func TestIsSunday_OnSunday(t *testing.T) {
+	sunday := time.Date(2022, 5, 15, 0, 0, 0, 0, TimezoneBerlin) // A Sunday
+	if !IsSunday(sunday, TimezoneBerlin) {
+		t.Errorf("Expected true for Sunday")
+	}
+}
+
 func TestDurationFromTime(t *testing.T) {
 	expected := time.Duration(13*time.Hour + 14*time.Minute + 15*time.Second)
 	result := DurationFromTime(13, 14, 15)
@@ -156,3 +163,31 @@ func TestAddYears(t *testing.T) {
 		t.Errorf("Expected %v but got %v", expected, result)
 	}
 }
+
+func TestIsDatePartEqual_SameDateDifferentTimes(t *testing.T) {
+	tz := time.UTC
+	t1 := time.Date(2022, 5, 18, 10, 30, 0, 0, tz)
+	t2 := time.Date(2022, 5, 18, 20, 45, 0, 0, tz)
+	if !IsDatePartEqual(t1, t2, tz) {
+		t.Errorf("Expected dates to be equal")
+	}
+}
+
+func TestWithTimePart_ChangeTime(t *testing.T) {
+	base := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
+	result := WithTimePart(base, 15, 30, 45)
+	expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestCombineDateAndTime_CombineDifferentParts(t *testing.T) {
+	date := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
+	timePart := time.Date(2000, 1, 1, 15, 30, 45, 0, time.UTC)
+	result := CombineDateAndTime(date, timePart)
+	expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}

wmo/queryPaginate.go

@@ -60,19 +60,27 @@ func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.MongoFilter, page
 		return nil, pag.Pagination{}, exerr.Wrap(err, "failed to all-decode entities").Build()
 	}
 
-	cursorTotalCount, err := c.coll.Aggregate(ctx, pipelineTotalCount)
-	if err != nil {
-		return nil, pag.Pagination{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
-	}
-
 	var tcRes totalCountResult
-	if cursorTotalCount.Next(ctx) {
+
-		err = cursorTotalCount.Decode(&tcRes)
+	if limit == nil {
-		if err != nil {
+		// optimization, limit==nil, so we query all entities anyway, just use the array length
-			return nil, pag.Pagination{}, exerr.Wrap(err, "failed to decode mongo-aggregation $count result").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+		tcRes.Count = len(entities)
-		}
 	} else {
-		tcRes.Count = 0 // no entries in DB
+
+		cursorTotalCount, err := c.coll.Aggregate(ctx, pipelineTotalCount)
+		if err != nil {
+			return nil, pag.Pagination{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+		}
+
+		if cursorTotalCount.Next(ctx) {
+			err = cursorTotalCount.Decode(&tcRes)
+			if err != nil {
+				return nil, pag.Pagination{}, exerr.Wrap(err, "failed to decode mongo-aggregation $count result").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+			}
+		} else {
+			tcRes.Count = 0 // no entries in DB
+		}
+
 	}
 
 	paginationObj := pag.Pagination{

wpdf/wpdfImage.go

@@ -7,6 +7,7 @@ import (
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"image"
 	"image/color"
+	"image/draw"
 	"net/http"
 )
 
@@ -284,6 +285,13 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 			}
 		}
 
+		if dataimg.ColorModel() != color.RGBAModel && dataimg.ColorModel() != color.NRGBAModel {
+			// the image cannto be 16bpp or similar - otherwise fpdf errors out
+			dataImgRGBA := image.NewNRGBA(image.Rect(0, 0, dataimg.Bounds().Dx(), dataimg.Bounds().Dy()))
+			draw.Draw(dataImgRGBA, dataImgRGBA.Bounds(), dataimg, dataimg.Bounds().Min, draw.Src)
+			dataimg = dataImgRGBA
+		}
+
 		bfr, imgMime, err := imageext.EncodeImage(dataimg, compression)
 		if err != nil {
 			b.b.SetError(err)