feat(encoding)!: simplify encoding interface and reduce allocs

Author: abemedia

README.md

@@ -181,7 +181,7 @@ as your request & response structs.
 
 ### Adding custom encoding
 
-Adding your own is easy. See [encoding/json/json.go](./encoding/json/json.go).
+Adding your own is easy. See [encoding/xml/xml.go](./encoding/xml/xml.go) for an example.
 
 ## Request parsing
 

encoding/decode.go

@@ -1,46 +1,28 @@
 package encoding
 
 import (
-	"context"
+	"bytes"
 
+	"github.com/abemedia/go-don/internal/byteconv"
 	"github.com/valyala/fasthttp"
 )
 
-type (
-	Unmarshaler        = func(data []byte, v any) error
-	ContextUnmarshaler = func(ctx context.Context, data []byte, v any) error
-	RequestParser      = func(ctx *fasthttp.RequestCtx, v any) error
-)
-
-type DecoderConstraint interface {
-	Unmarshaler | ContextUnmarshaler | RequestParser
-}
+type RequestDecoder = func(ctx *fasthttp.RequestCtx, v any) error
 
 // RegisterDecoder registers a request decoder for a given media type.
-func RegisterDecoder[T DecoderConstraint](dec T, mime string, aliases ...string) {
-	switch d := any(dec).(type) {
-	case Unmarshaler:
-		decoders[mime] = func(ctx *fasthttp.RequestCtx, v any) error {
-			return d(ctx.Request.Body(), v)
-		}
-
-	case ContextUnmarshaler:
-		decoders[mime] = func(ctx *fasthttp.RequestCtx, v any) error {
-			return d(ctx, ctx.Request.Body(), v)
-		}
-
-	case RequestParser:
-		decoders[mime] = d
-	}
-
+func RegisterDecoder(dec RequestDecoder, mime string, aliases ...string) {
+	decoders[mime] = dec
 	for _, alias := range aliases {
-		decoders[alias] = decoders[mime]
+		decoders[alias] = dec
 	}
 }
 
 // GetDecoder returns the request decoder for a given media type.
-func GetDecoder(mime string) RequestParser {
-	return decoders[mime]
+func GetDecoder(mime []byte) RequestDecoder {
+	if i := bytes.IndexByte(mime, ';'); i > 0 {
+		mime = mime[:i]
+	}
+	return decoders[byteconv.Btoa(bytes.TrimSpace(mime))]
 }
 
-var decoders = map[string]RequestParser{}
+var decoders = map[string]RequestDecoder{}

encoding/decode_test.go

@@ -1,7 +1,6 @@
 package encoding_test
 
 import (
-	"context"
 	"io"
 	"reflect"
 	"testing"
@@ -12,45 +11,19 @@ import (
 )
 
 func TestRegisterDecoder(t *testing.T) {
-	t.Run("Unmarshaler", func(t *testing.T) {
-		testRegisterDecoder(t, func(data []byte, v any) error {
-			if len(data) == 0 {
-				return io.EOF
-			}
-			reflect.ValueOf(v).Elem().SetBytes(data)
-			return nil
-		}, "unmarshaler", "unmarshaler-alias")
-	})
-
-	t.Run("ContextUnmarshaler", func(t *testing.T) {
-		testRegisterDecoder(t, func(ctx context.Context, data []byte, v any) error {
-			if len(data) == 0 {
-				return io.EOF
-			}
-			reflect.ValueOf(v).Elem().SetBytes(data)
-			return nil
-		}, "context-unmarshaler", "context-unmarshaler-alias")
-	})
-
-	t.Run("RequestParser", func(t *testing.T) {
-		testRegisterDecoder(t, func(ctx *fasthttp.RequestCtx, v any) error {
-			b := ctx.Request.Body()
-			if len(b) == 0 {
-				return io.EOF
-			}
-			reflect.ValueOf(v).Elem().SetBytes(b)
-			return nil
-		}, "request-parser", "request-parser-alias")
-	})
-}
-
-func testRegisterDecoder[T encoding.DecoderConstraint](t *testing.T, dec T, contentType, alias string) {
-	t.Helper()
+	dec := func(ctx *fasthttp.RequestCtx, v any) error {
+		b := ctx.Request.Body()
+		if len(b) == 0 {
+			return io.EOF
+		}
+		reflect.ValueOf(v).Elem().SetBytes(b)
+		return nil
+	}
 
-	encoding.RegisterDecoder(dec, contentType, alias)
+	encoding.RegisterDecoder(dec, "mime", "alias")
 
-	for _, v := range []string{contentType, alias} {
-		decode := encoding.GetDecoder(v)
+	for _, v := range []string{"mime", "alias", "mime; charset=utf-8", "alias; charset=utf-8"} {
+		decode := encoding.GetDecoder([]byte(v))
 		if decode == nil {
 			t.Error("decoder not found")
 			continue

encoding/encode.go

@@ -1,59 +1,37 @@
 package encoding
 
 import (
-	"context"
-	"strings"
+	"bytes"
 
+	"github.com/abemedia/go-don/internal/byteconv"
 	"github.com/valyala/fasthttp"
 )
 
-type (
-	Marshaler        = func(v any) ([]byte, error)
-	ContextMarshaler = func(ctx context.Context, v any) ([]byte, error)
-	ResponseEncoder  = func(ctx *fasthttp.RequestCtx, v any) error
-)
-
-type EncoderConstraint interface {
-	Marshaler | ContextMarshaler | ResponseEncoder
-}
+type ResponseEncoder = func(ctx *fasthttp.RequestCtx, v any) error
 
 // RegisterEncoder registers a response encoder on a given media type.
-func RegisterEncoder[T EncoderConstraint](enc T, mime string, aliases ...string) {
-	switch e := any(enc).(type) {
-	case Marshaler:
-		encoders[mime] = func(ctx *fasthttp.RequestCtx, v any) error {
-			b, err := e(v)
-			if err != nil {
-				return err
-			}
-			ctx.Response.SetBodyRaw(b)
-			return nil
-		}
-
-	case ContextMarshaler:
-		encoders[mime] = func(ctx *fasthttp.RequestCtx, v any) error {
-			b, err := e(ctx, v)
-			if err != nil {
-				return err
-			}
-			ctx.Response.SetBodyRaw(b)
-			return nil
-		}
-
-	case ResponseEncoder:
-		encoders[mime] = e
-	}
-
+func RegisterEncoder(enc ResponseEncoder, mime string, aliases ...string) {
+	encoders[mime] = enc
 	for _, alias := range aliases {
-		encoders[alias] = encoders[mime]
+		encoders[alias] = enc
 	}
 }
 
 // GetEncoder returns the response encoder for a given media type.
-func GetEncoder(mime string) ResponseEncoder {
-	mimeParts := strings.Split(mime, ",")
-	for _, part := range mimeParts {
-		if enc, ok := encoders[part]; ok {
+func GetEncoder(mime []byte) ResponseEncoder {
+	var contentType []byte
+	for len(mime) > 0 {
+		if i := bytes.IndexByte(mime, ','); i >= 0 {
+			contentType = mime[:i]
+			mime = mime[i+1:]
+		} else {
+			contentType = mime
+			mime = nil
+		}
+		if i := bytes.IndexByte(contentType, ';'); i > 0 {
+			contentType = contentType[:i]
+		}
+		if enc := encoders[byteconv.Btoa(bytes.TrimSpace(contentType))]; enc != nil {
 			return enc
 		}
 	}

encoding/encode_test.go

@@ -1,7 +1,6 @@
 package encoding_test
 
 import (
-	"context"
 	"io"
 	"testing"
 
@@ -11,45 +10,19 @@ import (
 )
 
 func TestRegisterEncoder(t *testing.T) {
-	t.Run("Marshaler", func(t *testing.T) {
-		testRegisterEncoder(t, func(v any) ([]byte, error) {
-			b := v.([]byte)
-			if len(b) == 0 {
-				return nil, io.EOF
-			}
-			return b, nil
-		}, "unmarshaler", "marshaler-alias")
-	})
-
-	t.Run("ContextMarshaler", func(t *testing.T) {
-		testRegisterEncoder(t, func(ctx context.Context, v any) ([]byte, error) {
-			b := v.([]byte)
-			if len(b) == 0 {
-				return nil, io.EOF
-			}
-			return b, nil
-		}, "context-marshaler", "context-marshaler-alias")
-	})
-
-	t.Run("ResponseEncoder", func(t *testing.T) {
-		testRegisterEncoder(t, func(ctx *fasthttp.RequestCtx, v any) error {
-			b := v.([]byte)
-			if len(b) == 0 {
-				return io.EOF
-			}
-			ctx.Response.SetBodyRaw(b)
-			return nil
-		}, "response-encoder", "response-encoder-alias")
-	})
-}
-
-func testRegisterEncoder[T encoding.EncoderConstraint](t *testing.T, dec T, contentType, alias string) {
-	t.Helper()
+	enc := func(ctx *fasthttp.RequestCtx, v any) error {
+		b := v.([]byte)
+		if len(b) == 0 {
+			return io.EOF
+		}
+		ctx.Response.SetBodyRaw(b)
+		return nil
+	}
 
-	encoding.RegisterEncoder(dec, contentType, alias)
+	encoding.RegisterEncoder(enc, "response-encoder", "response-encoder-alias")
 
-	for _, v := range []string{contentType, alias} {
-		encode := encoding.GetEncoder(v)
+	for _, v := range []string{"response-encoder", "response-encoder-alias"} {
+		encode := encoding.GetEncoder([]byte(v))
 		if encode == nil {
 			t.Error("encoder not found")
 			continue
@@ -76,12 +49,12 @@ func TestGetEncoderMultipleContentTypes(t *testing.T) {
 
 	encoding.RegisterEncoder(encFn, "application/xml")
 
-	enc := encoding.GetEncoder("text/html,application/xhtml+xml,application/xml")
+	enc := encoding.GetEncoder([]byte("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"))
 	if enc == nil {
 		t.Fatal("encoder not found")
 	}
 
-	enc = encoding.GetEncoder("application/xhtml+xml")
+	enc = encoding.GetEncoder([]byte("application/xhtml+xml"))
 	if enc != nil {
 		t.Fatal("encoder should not be found")
 	}

encoding/json/json.go

@@ -4,11 +4,21 @@ package json
 import (
 	"github.com/abemedia/go-don/encoding"
 	"github.com/goccy/go-json"
+	"github.com/valyala/fasthttp"
 )
 
+func decode(ctx *fasthttp.RequestCtx, v any) error {
+	return json.Unmarshal(ctx.Request.Body(), v)
+}
+
+func encode(ctx *fasthttp.RequestCtx, v any) error {
+	ctx.SetContentType("application/json")
+	return json.NewEncoder(ctx).Encode(v)
+}
+
 func init() {
 	mediaType := "application/json"
 
-	encoding.RegisterDecoder(json.Unmarshal, mediaType)
-	encoding.RegisterEncoder(json.Marshal, mediaType)
+	encoding.RegisterDecoder(decode, mediaType)
+	encoding.RegisterEncoder(encode, mediaType)
 }

encoding/json/json_test.go

@@ -12,7 +12,7 @@ type item struct {
 
 var opt = test.EncodingOptions[item]{
 	Mime:   "application/json",
-	Raw:    `{"foo":"bar"}`,
+	Raw:    `{"foo":"bar"}` + "\n",
 	Parsed: item{Foo: "bar"},
 }
 

encoding/msgpack/msgpack.go

@@ -3,13 +3,32 @@ package msgpack
 
 import (
 	"github.com/abemedia/go-don/encoding"
+	"github.com/valyala/fasthttp"
 	"github.com/vmihailenco/msgpack/v5"
 )
 
+func decode(ctx *fasthttp.RequestCtx, v any) error {
+	dec := msgpack.GetDecoder()
+	dec.UsePreallocateValues(true)
+	dec.Reset(ctx.RequestBodyStream())
+	err := dec.Decode(v)
+	msgpack.PutDecoder(dec)
+	return err
+}
+
+func encode(ctx *fasthttp.RequestCtx, v any) error {
+	ctx.SetContentType("application/msgpack")
+	b, err := msgpack.Marshal(v)
+	if err == nil {
+		ctx.Response.SetBodyRaw(b)
+	}
+	return err
+}
+
 func init() {
 	mediaType := "application/msgpack"
 	aliases := []string{"application/x-msgpack", "application/vnd.msgpack"}
 
-	encoding.RegisterDecoder(msgpack.Unmarshal, mediaType, aliases...)
-	encoding.RegisterEncoder(msgpack.Marshal, mediaType, aliases...)
+	encoding.RegisterDecoder(decode, mediaType, aliases...)
+	encoding.RegisterEncoder(encode, mediaType, aliases...)
 }