use own fork

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

codec.go

@@ -1,18 +1,19 @@
 package grpc
 
 import (
+	b "bytes"
 	"encoding/json"
 	"strings"
 
-	b "bytes"
-
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-	"github.com/micro/go-micro/v3/codec"
-	"github.com/micro/go-micro/v3/codec/bytes"
+	oldjsonpb "github.com/golang/protobuf/jsonpb"
+	oldproto "github.com/golang/protobuf/proto"
+	bytes "github.com/unistack-org/micro-codec-bytes"
+	"github.com/unistack-org/micro/v3/codec"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/encoding"
 	"google.golang.org/grpc/metadata"
+	jsonpb "google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
 )
 
 type jsonCodec struct{}
@@ -20,11 +21,28 @@ type bytesCodec struct{}
 type protoCodec struct{}
 type wrapCodec struct{ encoding.Codec }
 
-var jsonpbMarshaler = &jsonpb.Marshaler{
-	EnumsAsInts:  false,
-	EmitDefaults: false,
-	OrigName:     true,
-}
+var (
+	jsonpbMarshaler = jsonpb.MarshalOptions{
+		UseEnumNumbers:  false,
+		EmitUnpopulated: false,
+		UseProtoNames:   true,
+		AllowPartial:    false,
+	}
+
+	jsonpbUnmarshaler = jsonpb.UnmarshalOptions{
+		DiscardUnknown: false,
+		AllowPartial:   false,
+	}
+
+	oldjsonpbMarshaler = oldjsonpb.Marshaler{
+		OrigName:     true,
+		EmitDefaults: false,
+	}
+
+	oldjsonpbUnmarshaler = oldjsonpb.Unmarshaler{
+		AllowUnknownFields: false,
+	}
+)
 
 var (
 	defaultGRPCCodecs = map[string]encoding.Codec{
@@ -44,39 +62,52 @@ func (w wrapCodec) String() string {
 }
 
 func (w wrapCodec) Marshal(v interface{}) ([]byte, error) {
-	b, ok := v.(*bytes.Frame)
-	if ok {
-		return b.Data, nil
+	switch m := v.(type) {
+	case *bytes.Frame:
+		return m.Data, nil
 	}
 	return w.Codec.Marshal(v)
 }
 
 func (w wrapCodec) Unmarshal(data []byte, v interface{}) error {
-	b, ok := v.(*bytes.Frame)
-	if ok {
-		b.Data = data
+	if len(data) == 0 {
 		return nil
 	}
 	if v == nil {
 		return nil
 	}
+	switch m := v.(type) {
+	case *bytes.Frame:
+		m.Data = data
+		return nil
+	}
 	return w.Codec.Unmarshal(data, v)
 }
 
 func (protoCodec) Marshal(v interface{}) ([]byte, error) {
-	m, ok := v.(proto.Message)
-	if !ok {
-		return nil, codec.ErrInvalidMessage
+	switch m := v.(type) {
+	case proto.Message:
+		return proto.Marshal(m)
+	case oldproto.Message:
+		return oldproto.Marshal(m)
 	}
-	return proto.Marshal(m)
+	return nil, codec.ErrInvalidMessage
 }
 
 func (protoCodec) Unmarshal(data []byte, v interface{}) error {
-	m, ok := v.(proto.Message)
-	if !ok {
-		return codec.ErrInvalidMessage
+	if len(data) == 0 {
+		return nil
 	}
-	return proto.Unmarshal(data, m)
+	if v == nil {
+		return nil
+	}
+	switch m := v.(type) {
+	case proto.Message:
+		return proto.Unmarshal(data, m)
+	case oldproto.Message:
+		return oldproto.Unmarshal(data, m)
+	}
+	return codec.ErrInvalidMessage
 }
 
 func (protoCodec) Name() string {
@@ -84,11 +115,14 @@ func (protoCodec) Name() string {
 }
 
 func (jsonCodec) Marshal(v interface{}) ([]byte, error) {
-	if pb, ok := v.(proto.Message); ok {
-		s, err := jsonpbMarshaler.MarshalToString(pb)
-		return []byte(s), err
+	switch m := v.(type) {
+	case proto.Message:
+		return jsonpbMarshaler.Marshal(m)
+	case oldproto.Message:
+		buf := b.NewBuffer(nil)
+		err := oldjsonpbMarshaler.Marshal(buf, m)
+		return buf.Bytes(), err
 	}
-
 	return json.Marshal(v)
 }
 
@@ -96,8 +130,14 @@ func (jsonCodec) Unmarshal(data []byte, v interface{}) error {
 	if len(data) == 0 {
 		return nil
 	}
-	if pb, ok := v.(proto.Message); ok {
-		return jsonpb.Unmarshal(b.NewReader(data), pb)
+	if v == nil {
+		return nil
+	}
+	switch m := v.(type) {
+	case proto.Message:
+		return jsonpbUnmarshaler.Unmarshal(data, m)
+	case oldproto.Message:
+		return oldjsonpbUnmarshaler.Unmarshal(b.NewReader(data), m)
 	}
 	return json.Unmarshal(data, v)
 }
@@ -107,20 +147,26 @@ func (jsonCodec) Name() string {
 }
 
 func (bytesCodec) Marshal(v interface{}) ([]byte, error) {
-	b, ok := v.(*[]byte)
-	if !ok {
-		return nil, codec.ErrInvalidMessage
+	switch m := v.(type) {
+	case *[]byte:
+		return *m, nil
 	}
-	return *b, nil
+	return nil, codec.ErrInvalidMessage
 }
 
 func (bytesCodec) Unmarshal(data []byte, v interface{}) error {
-	b, ok := v.(*[]byte)
-	if !ok {
-		return codec.ErrInvalidMessage
+	if len(data) == 0 {
+		return nil
 	}
-	*b = data
-	return nil
+	if v == nil {
+		return nil
+	}
+	switch m := v.(type) {
+	case *[]byte:
+		*m = data
+		return nil
+	}
+	return codec.ErrInvalidMessage
 }
 
 func (bytesCodec) Name() string {
@@ -158,8 +204,9 @@ func (g *grpcCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
 
 func (g *grpcCodec) ReadBody(v interface{}) error {
 	// caller has requested a frame
-	if f, ok := v.(*bytes.Frame); ok {
-		return g.ServerStream.RecvMsg(f)
+	switch m := v.(type) {
+	case *bytes.Frame:
+		return g.ServerStream.RecvMsg(m)
 	}
 	return g.ServerStream.RecvMsg(v)
 }