✨ v3 (feature): request binding

app.go

@@ -102,14 +102,18 @@ type App struct {
 	newCtxFunc func(app *App) CustomCtx
 	// TLS handler
 	tlsHandler *TLSHandler
+	// bind decoder cache
+	bindDecoderCache sync.Map
+	// form decoder cache
+	formDecoderCache sync.Map
+	// multipart decoder cache
+	multipartDecoderCache sync.Map
 	// Mount fields
 	mountFields *mountFields
 	// Route stack divided by HTTP methods
 	stack [][]*Route
 	// Route stack divided by HTTP methods and route prefixes
 	treeStack []map[string][]*Route
-	// custom binders
-	customBinders []CustomBinder
 	// customConstraints is a list of external constraints
 	customConstraints []CustomConstraint
 	// sendfiles stores configurations for handling ctx.SendFile operations
@@ -325,6 +329,23 @@ type Config struct { //nolint:govet // Aligning the struct fields is not necessa
 	// Default: xml.Marshal
 	XMLEncoder utils.XMLMarshal `json:"-"`
 
+	// XMLDecoder set by an external client of Fiber it will use the provided implementation of a
+	// XMLUnmarshal
+	//
+	// Allowing for flexibility in using another XML library for encoding
+	// Default: utils.XMLUnmarshal
+	XMLDecoder utils.XMLUnmarshal `json:"-"`
+
+	// App validate. if nil, and context.EnableValidate will always return a error.
+	// Default: nil
+	Validator Validator
+
+	// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only)
+	// WARNING: When prefork is set to true, only "tcp4" and "tcp6" can be chose.
+	//
+	// Default: NetworkTCP4
+	Network string
+
 	// If you find yourself behind some sort of proxy, like a load balancer,
 	// then certain header information may be sent to you using special X-Forwarded-* headers or the Forwarded header.
 	// For example, the Host HTTP header is usually used to return the requested host.
@@ -366,12 +387,6 @@ type Config struct { //nolint:govet // Aligning the struct fields is not necessa
 	// Optional. Default: DefaultColors
 	ColorScheme Colors `json:"color_scheme"`
 
-	// If you want to validate header/form/query... automatically when to bind, you can define struct validator.
-	// Fiber doesn't have default validator, so it'll skip validator step if you don't use any validator.
-	//
-	// Default: nil
-	StructValidator StructValidator
-
 	// RequestMethods provides customizibility for HTTP methods. You can add/remove methods as you wish.
 	//
 	// Optional. Default: DefaultMethods
@@ -439,12 +454,11 @@ func New(config ...Config) *App {
 	// Create a new app
 	app := &App{
 		// Create config
-		config:        Config{},
-		getBytes:      utils.UnsafeBytes,
-		getString:     utils.UnsafeString,
-		latestRoute:   &Route{},
-		customBinders: []CustomBinder{},
-		sendfiles:     []*sendFileStore{},
+		config:      Config{},
+		getBytes:    utils.UnsafeBytes,
+		getString:   utils.UnsafeString,
+		latestRoute: &Route{},
+		sendfiles:   []*sendFileStore{},
 	}
 
 	// Create Ctx pool
@@ -503,9 +517,15 @@ func New(config ...Config) *App {
 	if app.config.JSONDecoder == nil {
 		app.config.JSONDecoder = json.Unmarshal
 	}
+
 	if app.config.XMLEncoder == nil {
 		app.config.XMLEncoder = xml.Marshal
 	}
+
+	if app.config.XMLDecoder == nil {
+		app.config.XMLDecoder = xml.Unmarshal
+	}
+
 	if len(app.config.RequestMethods) == 0 {
 		app.config.RequestMethods = DefaultMethods
 	}
@@ -554,12 +574,6 @@ func (app *App) RegisterCustomConstraint(constraint CustomConstraint) {
 	app.customConstraints = append(app.customConstraints, constraint)
 }
 
-// RegisterCustomBinder Allows to register custom binders to use as Bind().Custom("name").
-// They should be compatible with CustomBinder interface.
-func (app *App) RegisterCustomBinder(binder CustomBinder) {
-	app.customBinders = append(app.customBinders, binder)
-}
-
 // SetTLSHandler Can be used to set ClientHelloInfo when using TLS with Listener.
 func (app *App) SetTLSHandler(tlsHandler *TLSHandler) {
 	// Attach the tlsHandler to the config

bind.go

@@ -1,193 +1,99 @@
 package fiber
 
 import (
-	"github.com/gofiber/fiber/v3/binder"
-	"github.com/gofiber/utils/v2"
-)
-
-// CustomBinder An interface to register custom binders.
-type CustomBinder interface {
-	Name() string
-	MIMETypes() []string
-	Parse(c Ctx, out any) error
-}
+	"encoding"
+	"fmt"
+	"reflect"
 
-// StructValidator is an interface to register custom struct validator for binding.
-type StructValidator interface {
-	Validate(out any) error
-}
+	"github.com/gofiber/fiber/v3/internal/bind"
+)
 
-// Bind struct
-type Bind struct {
-	ctx    Ctx
-	should bool
+type Binder interface {
+	UnmarshalFiberCtx(ctx Ctx) error
 }
 
-// Should To handle binder errors manually, you can prefer Should method.
-// It's default behavior of binder.
-func (b *Bind) Should() *Bind {
-	b.should = true
-
-	return b
+// decoder should set a field on reqValue
+// it's created with field index
+type decoder interface {
+	Decode(ctx Ctx, reqValue reflect.Value) error
+	Kind() string
 }
 
-// Must If you want to handle binder errors automatically, you can use Must.
-// If there's an error it'll return error and 400 as HTTP status.
-func (b *Bind) Must() *Bind {
-	b.should = false
-
-	return b
+type fieldCtxDecoder struct {
+	index     int
+	fieldName string
+	fieldType reflect.Type
 }
 
-// Check Should/Must errors and return it by usage.
-func (b *Bind) returnErr(err error) error {
-	if !b.should {
-		b.ctx.Status(StatusBadRequest)
-		return NewError(StatusBadRequest, "Bad request: "+err.Error())
-	}
-
-	return err
-}
+func (d *fieldCtxDecoder) Decode(ctx Ctx, reqValue reflect.Value) error {
+	v := reflect.New(d.fieldType)
+	unmarshaler := v.Interface().(Binder)
 
-// Struct validation.
-func (b *Bind) validateStruct(out any) error {
-	validator := b.ctx.App().config.StructValidator
-	if validator != nil {
-		return validator.Validate(out)
+	if err := unmarshaler.UnmarshalFiberCtx(ctx); err != nil {
+		return err
 	}
 
+	reqValue.Field(d.index).Set(v.Elem())
 	return nil
 }
 
-// Custom To use custom binders, you have to use this method.
-// You can register them from RegisterCustomBinder method of Fiber instance.
-// They're checked by name, if it's not found, it will return an error.
-// NOTE: Should/Must is still valid for Custom binders.
-func (b *Bind) Custom(name string, dest any) error {
-	binders := b.ctx.App().customBinders
-	for _, customBinder := range binders {
-		if customBinder.Name() == name {
-			return b.returnErr(customBinder.Parse(b.ctx, dest))
-		}
-	}
-
-	return ErrCustomBinderNotFound
-}
-
-// Header binds the request header strings into the struct, map[string]string and map[string][]string.
-func (b *Bind) Header(out any) error {
-	if err := b.returnErr(binder.HeaderBinder.Bind(b.ctx.Request(), out)); err != nil {
-		return err
-	}
-
-	return b.validateStruct(out)
+func (d *fieldCtxDecoder) Kind() string {
+	return "ctx"
 }
 
-// RespHeader binds the response header strings into the struct, map[string]string and map[string][]string.
-func (b *Bind) RespHeader(out any) error {
-	if err := b.returnErr(binder.RespHeaderBinder.Bind(b.ctx.Response(), out)); err != nil {
-		return err
-	}
-
-	return b.validateStruct(out)
+type fieldTextDecoder struct {
+	fieldIndex       int
+	fieldName        string
+	tag              string // query,param,header,respHeader ...
+	reqKey           string
+	dec              bind.TextDecoder
+	get              func(c Ctx, key string, defaultValue ...string) string
+	subFieldDecoders []decoder
+	isTextMarshaler  bool
+	fragments        []requestKeyFragment
 }
 
-// Cookie binds the requesr cookie strings into the struct, map[string]string and map[string][]string.
-// NOTE: If your cookie is like key=val1,val2; they'll be binded as an slice if your map is map[string][]string. Else, it'll use last element of cookie.
-func (b *Bind) Cookie(out any) error {
-	if err := b.returnErr(binder.CookieBinder.Bind(b.ctx.Context(), out)); err != nil {
-		return err
-	}
+func (d *fieldTextDecoder) Decode(ctx Ctx, reqValue reflect.Value) error {
+	field := reqValue.Field(d.fieldIndex)
 
-	return b.validateStruct(out)
-}
-
-// Query binds the query string into the struct, map[string]string and map[string][]string.
-func (b *Bind) Query(out any) error {
-	if err := b.returnErr(binder.QueryBinder.Bind(b.ctx.Context(), out)); err != nil {
-		return err
-	}
-
-	return b.validateStruct(out)
-}
-
-// JSON binds the body string into the struct.
-func (b *Bind) JSON(out any) error {
-	if err := b.returnErr(binder.JSONBinder.Bind(b.ctx.Body(), b.ctx.App().Config().JSONDecoder, out)); err != nil {
-		return err
+	// Support for sub fields
+	if len(d.subFieldDecoders) > 0 {
+		for _, subFieldDecoder := range d.subFieldDecoders {
+			err := subFieldDecoder.Decode(ctx, field)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
 	}
 
-	return b.validateStruct(out)
-}
-
-// XML binds the body string into the struct.
-func (b *Bind) XML(out any) error {
-	if err := b.returnErr(binder.XMLBinder.Bind(b.ctx.Body(), out)); err != nil {
-		return err
+	text := d.get(ctx, d.reqKey)
+	if text == "" {
+		return nil
 	}
 
-	return b.validateStruct(out)
-}
-
-// Form binds the form into the struct, map[string]string and map[string][]string.
-func (b *Bind) Form(out any) error {
-	if err := b.returnErr(binder.FormBinder.Bind(b.ctx.Context(), out)); err != nil {
-		return err
-	}
+	if d.isTextMarshaler {
+		unmarshaler, ok := field.Addr().Interface().(encoding.TextUnmarshaler)
+		if !ok {
+			return fmt.Errorf("field %s does not implement encoding.TextUnmarshaler", d.fieldName)
+		}
 
-	return b.validateStruct(out)
-}
+		err := unmarshaler.UnmarshalText([]byte(text))
+		if err != nil {
+			return fmt.Errorf("unable to decode '%s' as %s: %w", text, d.reqKey, err)
+		}
 
-// URI binds the route parameters into the struct, map[string]string and map[string][]string.
-func (b *Bind) URI(out any) error {
-	if err := b.returnErr(binder.URIBinder.Bind(b.ctx.Route().Params, b.ctx.Params, out)); err != nil {
-		return err
+		return nil
 	}
 
-	return b.validateStruct(out)
-}
-
-// MultipartForm binds the multipart form into the struct, map[string]string and map[string][]string.
-func (b *Bind) MultipartForm(out any) error {
-	if err := b.returnErr(binder.FormBinder.BindMultipart(b.ctx.Context(), out)); err != nil {
-		return err
+	err := d.dec.UnmarshalString(text, field)
+	if err != nil {
+		return fmt.Errorf("unable to decode '%s' as %s: %w", text, d.reqKey, err)
 	}
 
-	return b.validateStruct(out)
+	return nil
 }
 
-// Body binds the request body into the struct, map[string]string and map[string][]string.
-// It supports decoding the following content types based on the Content-Type header:
-// application/json, application/xml, application/x-www-form-urlencoded, multipart/form-data
-// If none of the content types above are matched, it'll take a look custom binders by checking the MIMETypes() method of custom binder.
-// If there're no custom binder for mşme type of body, it will return a ErrUnprocessableEntity error.
-func (b *Bind) Body(out any) error {
-	// Get content-type
-	ctype := utils.ToLower(utils.UnsafeString(b.ctx.Context().Request.Header.ContentType()))
-	ctype = binder.FilterFlags(utils.ParseVendorSpecificContentType(ctype))
-
-	// Check custom binders
-	binders := b.ctx.App().customBinders
-	for _, customBinder := range binders {
-		for _, mime := range customBinder.MIMETypes() {
-			if mime == ctype {
-				return b.returnErr(customBinder.Parse(b.ctx, out))
-			}
-		}
-	}
-
-	// Parse body accordingly
-	switch ctype {
-	case MIMEApplicationJSON:
-		return b.JSON(out)
-	case MIMETextXML, MIMEApplicationXML:
-		return b.XML(out)
-	case MIMEApplicationForm:
-		return b.Form(out)
-	case MIMEMultipartForm:
-		return b.MultipartForm(out)
-	}
-
-	// No suitable content type found
-	return ErrUnprocessableEntity
+func (d *fieldTextDecoder) Kind() string {
+	return "text"
 }