Merge pull request #29 from hellofresh/patch/easyjson

Improve JSON Marshalling and Unmarshalling

Author: boekkooi-fresh

aggregate/changed.go

@@ -91,16 +91,14 @@ func (a *Changed) Metadata() metadata.Metadata {
 }
 
 // WithMetadata Returns new instance of the change with key and value added to metadata
-func (a *Changed) WithMetadata(key string, value interface{}) goengine.Message {
-	newAggregateChanged := *a
-	newAggregateChanged.metadata = metadata.WithValue(a.metadata, key, value)
+func (a Changed) WithMetadata(key string, value interface{}) goengine.Message {
+	a.metadata = metadata.WithValue(a.metadata, key, value)
 
-	return &newAggregateChanged
+	return &a
 }
 
-func (a *Changed) withVersion(version uint) *Changed {
-	newAggregateChanged := *a
-	newAggregateChanged.version = version
+func (a Changed) withVersion(version uint) *Changed {
+	a.version = version
 
-	return &newAggregateChanged
+	return &a
 }

aggregate/changed_test.go

@@ -6,6 +6,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/hellofresh/goengine"
 	"github.com/hellofresh/goengine/aggregate"
 	"github.com/hellofresh/goengine/metadata"
@@ -127,3 +129,22 @@ func TestReconstituteChange(t *testing.T) {
 		}
 	})
 }
+
+func TestChanged_WithMetadata(t *testing.T) {
+	expectedMetadata := metadata.WithValue(metadata.New(), "test", "value")
+	msg, err := aggregate.ReconstituteChange(
+		aggregate.GenerateID(),
+		goengine.GenerateUUID(),
+		struct{}{},
+		metadata.New(),
+		time.Now(),
+		1,
+	)
+	require.NoError(t, err)
+
+	msgWithTest := msg.WithMetadata("test", "value")
+
+	assert.Equal(t, expectedMetadata, msgWithTest.Metadata())
+	assert.Equal(t, metadata.New(), msg.Metadata(), "Original metadata should not be changed")
+	assert.NotEqual(t, msg, msgWithTest, "Origional changed message should not be changed")
+}

driver/sql/projection.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 
 	"github.com/hellofresh/goengine"
+	"github.com/mailru/easyjson/jlexer"
 )
 
 type (
@@ -57,3 +58,45 @@ type (
 	// EventStreamLoader loads a event stream based on the provided notification and state
 	EventStreamLoader func(ctx context.Context, conn *sql.Conn, notification *ProjectionNotification, position int64) (goengine.EventStream, error)
 )
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (p *ProjectionNotification) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	p.UnmarshalEasyJSON(&r)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (p *ProjectionNotification) UnmarshalEasyJSON(in *jlexer.Lexer) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return
+	}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		if in.IsNull() {
+			in.Skip()
+			in.WantComma()
+			continue
+		}
+		switch key {
+		case "no":
+			p.No = in.Int64()
+		case "aggregate_id":
+			p.AggregateID = in.String()
+		default:
+			in.SkipRecursive()
+		}
+		in.WantComma()
+	}
+	in.Delim('}')
+	if isTopLevel {
+		in.Consumed()
+	}
+}

extension/pq/listener.go

@@ -2,13 +2,13 @@ package pq
 
 import (
 	"context"
-	"encoding/json"
 	"strings"
 	"time"
 
 	"github.com/hellofresh/goengine"
 	"github.com/hellofresh/goengine/driver/sql"
 	"github.com/lib/pq"
+	"github.com/mailru/easyjson"
 )
 
 // Ensure Listener implements sql.Listener
@@ -138,7 +138,7 @@ func (s *Listener) unmarshalNotification(n *pq.Notification) *sql.ProjectionNoti
 	}
 
 	notification := &sql.ProjectionNotification{}
-	if err := json.Unmarshal([]byte(n.Extra), notification); err != nil {
+	if err := easyjson.Unmarshal([]byte(n.Extra), notification); err != nil {
 		logger.WithError(err).Error("received invalid notification data")
 		return nil
 	}

metadata/metadata.go

@@ -3,19 +3,31 @@ package metadata
 import (
 	"encoding/json"
 
+	"github.com/mailru/easyjson"
 	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+	"github.com/pkg/errors"
 )
 
-// Metadata is an immutable map[string]interface{} implementation
-type Metadata interface {
-	// Value returns the value associated with this context for key, or nil
-	// if no value is associated with key. Successive calls to Value with
-	// the same key returns the same result.
-	Value(key string) interface{}
+type (
+	// Metadata is an immutable map[string]interface{} implementation
+	Metadata interface {
+		// Value returns the value associated with this context for key, or nil
+		// if no value is associated with key. Successive calls to Value with
+		// the same key returns the same result.
+		Value(key string) interface{}
 
-	// AsMap return the Metadata as a map[string]interface{}
-	AsMap() map[string]interface{}
-}
+		// AsMap return the Metadata as a map[string]interface{}
+		AsMap() map[string]interface{}
+	}
+
+	// jsonMarshaler is an interface used to speed up the json marshalling process
+	jsonMarshaler interface {
+		// MarshalJSONKeyValue writes the Metadata Key and Value and all it's parent Key Value pairs into the writer
+		// If last is true it MUST omit the `,` from the last Key Value pair
+		MarshalJSONKeyValue(out *jwriter.Writer, last bool)
+	}
+)
 
 // New return a new Metadata instance without any information
 func New() Metadata {
@@ -43,8 +55,12 @@ type emptyData int
 var (
 	// Ensure emptyData implements the Metadata interface
 	_ Metadata = new(emptyData)
-	// Ensure valueData implements the json.Marshaler interface
+	// Ensure valueData implements the jsonMarshaler interface
+	_ jsonMarshaler = new(emptyData)
+	// Ensure emptyData implements the json.Marshaler interface
 	_ json.Marshaler = new(emptyData)
+	// Ensure emptyData implements the easyjson.Marshaler interface
+	_ easyjson.Marshaler = new(emptyData)
 )
 
 func (*emptyData) Value(key string) interface{} {
@@ -59,6 +75,14 @@ func (v *emptyData) MarshalJSON() ([]byte, error) {
 	return []byte("{}"), nil
 }
 
+func (v *emptyData) MarshalEasyJSON(w *jwriter.Writer) {
+	w.RawByte('{')
+	w.RawByte('}')
+}
+
+func (v *emptyData) MarshalJSONKeyValue(*jwriter.Writer, bool) {
+}
+
 // valueData represents a key, value pair in a metadata chain
 type valueData struct {
 	Metadata
@@ -69,8 +93,12 @@ type valueData struct {
 var (
 	// Ensure valueData implements the Metadata interface
 	_ Metadata = new(valueData)
+	// Ensure valueData implements the jsonMarshaler interface
+	_ jsonMarshaler = new(valueData)
 	// Ensure valueData implements the json.Marshaler interface
 	_ json.Marshaler = new(valueData)
+	// Ensure valueData implements the easyjson.Marshaler interface
+	_ easyjson.Marshaler = new(valueData)
 )
 
 func (v *valueData) Value(key string) interface{} {
@@ -95,7 +123,33 @@ func (v *valueData) AsMap() map[string]interface{} {
 }
 
 func (v *valueData) MarshalJSON() ([]byte, error) {
-	return json.Marshal(v.AsMap())
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+func (v *valueData) MarshalEasyJSON(w *jwriter.Writer) {
+	w.RawByte('{')
+	v.MarshalJSONKeyValue(w, true)
+	w.RawByte('}')
+}
+
+func (v *valueData) MarshalJSONKeyValue(out *jwriter.Writer, last bool) {
+	marshalJSONKeyValues(out, v.Metadata)
+
+	out.String(v.key)
+	out.RawByte(':')
+	if vm, ok := v.val.(easyjson.Marshaler); ok {
+		vm.MarshalEasyJSON(out)
+	} else if vm, ok := v.val.(json.Marshaler); ok {
+		out.Raw(vm.MarshalJSON())
+	} else {
+		out.Raw(json.Marshal(v.val))
+	}
+
+	if !last {
+		out.RawByte(',')
+	}
 }
 
 // UnmarshalJSON unmarshals the provided json into a Metadata instance
@@ -127,3 +181,42 @@ func UnmarshalJSON(json []byte) (Metadata, error) {
 
 	return metadata, in.Error()
 }
+
+func marshalJSONKeyValues(out *jwriter.Writer, parent Metadata) {
+	if parent == nil {
+		return
+	}
+
+	if m, ok := parent.(jsonMarshaler); ok {
+		m.MarshalJSONKeyValue(out, false)
+		return
+	}
+
+	var (
+		parentJSON []byte
+		err        error
+	)
+	if vm, ok := parent.(easyjson.Marshaler); ok {
+		w := &jwriter.Writer{}
+		vm.MarshalEasyJSON(out)
+		parentJSON = w.Buffer.BuildBytes()
+		err = w.Error
+	} else if vm, ok := parent.(json.Marshaler); ok {
+		parentJSON, err = vm.MarshalJSON()
+	} else {
+		parentJSON, err = json.Marshal(parent)
+	}
+
+	if err != nil {
+		out.Raw(parentJSON, err)
+		return
+	}
+
+	plen := len(parentJSON)
+	if parentJSON[1] != '{' || parentJSON[plen-1] != '}' {
+		out.Raw(parentJSON, errors.Errorf("JSON unmarshal failed for Metadata of type %T", parent))
+		return
+	}
+
+	out.Raw(parentJSON[1:plen-2], nil)
+}

metadata/metadata_test.go

@@ -4,10 +4,13 @@ package metadata_test
 
 import (
 	"encoding/json"
+	"strings"
 	"testing"
 	"time"
+	"unicode"
 
 	"github.com/hellofresh/goengine/metadata"
+	"github.com/mailru/easyjson"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -198,33 +201,40 @@ var jsonTestCases = []struct {
 	},
 }
 
-func TestMetadata_MarshalJSON(t *testing.T) {
+func TestMarshalJSON(t *testing.T) {
 	for _, testCase := range jsonTestCases {
 		t.Run(testCase.title, func(t *testing.T) {
+			expectedJSON := strings.Map(func(r rune) rune {
+				if unicode.IsSpace(r) {
+					return -1
+				}
+				return r
+			}, testCase.json)
+
 			m := testCase.metadata()
 
 			mJSON, err := json.Marshal(m)
 
-			assert.JSONEq(t, testCase.json, string(mJSON))
+			assert.Equal(t, expectedJSON, string(mJSON))
 			assert.NoError(t, err)
 		})
 	}
 }
 
-func TestJSONMetadata_UnmarshalJSON(t *testing.T) {
+func TestUnmarshalJSON(t *testing.T) {
 	for _, testCase := range jsonTestCases {
 		t.Run(testCase.title, func(t *testing.T) {
 			m, err := metadata.UnmarshalJSON([]byte(testCase.json))
 
 			// Need to use AsMap otherwise we can have inconsistent tests results.
 			if assert.NoError(t, err) {
-				assert.Equal(t, testCase.metadata().AsMap(), m.AsMap())
+				assert.Equal(t, testCase.metadata(), m)
 			}
 		})
 	}
 }
 
-func BenchmarkJSONMetadata_UnmarshalJSON(b *testing.B) {
+func BenchmarkUnmarshalJSON(b *testing.B) {
 	payload := []byte(`{"_aggregate_id": "b9ebca7a-c1eb-40dd-94a4-fac7c5e84fb5", "_aggregate_type": "bank_account", "_aggregate_version": 1}`)
 
 	b.ResetTimer()
@@ -235,3 +245,18 @@ func BenchmarkJSONMetadata_UnmarshalJSON(b *testing.B) {
 		}
 	}
 }
+
+func BenchmarkMarshalJSON(b *testing.B) {
+	m := metadata.New()
+	m = metadata.WithValue(m, "_aggregate_id", "b9ebca7a-c1eb-40dd-94a4-fac7c5e84fb5")
+	m = metadata.WithValue(m, "_aggregate_type", "bank_account")
+	m = metadata.WithValue(m, "_aggregate_version", 1)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := easyjson.Marshal(m.(easyjson.Marshaler))
+		if err != nil {
+			b.Fail()
+		}
+	}
+}