encoding/jsonpb/encode.go

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package jsonpb

import (
	"encoding/base64"
	"math"
	"sort"

	"github.com/golang/protobuf/v2/internal/encoding/json"
	"github.com/golang/protobuf/v2/internal/errors"
	"github.com/golang/protobuf/v2/internal/pragma"
	"github.com/golang/protobuf/v2/proto"
	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)

// Marshal writes the given proto.Message in JSON format using default options.
func Marshal(m proto.Message) ([]byte, error) {
	return MarshalOptions{}.Marshal(m)
}

// MarshalOptions is a configurable JSON format marshaler.
type MarshalOptions struct {
	pragma.NoUnkeyedLiterals

	// Set Compact to true to have output in a single line with no line breaks.
	Compact bool
}

// Marshal writes the given proto.Message in JSON format using options in MarshalOptions object.
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
	var nerr errors.NonFatal
	v, err := o.marshalMessage(m.ProtoReflect())
	if !nerr.Merge(err) {
		return nil, err
	}

	indent := "  "
	if o.Compact {
		indent = ""
	}

	b, err := json.Marshal(v, indent)
	if !nerr.Merge(err) {
		return nil, err
	}
	return b, nerr.E
}

// marshalMessage converts a protoreflect.Message to a json.Value.
func (o MarshalOptions) marshalMessage(m pref.Message) (json.Value, error) {
	var nerr errors.NonFatal
	var msgFields [][2]json.Value

	msgType := m.Type()
	fieldDescs := msgType.Fields()
	knownFields := m.KnownFields()
	size := fieldDescs.Len()
	for i := 0; i < size; i++ {
		fd := fieldDescs.Get(i)
		num := fd.Number()

		if !knownFields.Has(num) {
			if fd.Cardinality() == pref.Required {
				// Treat unset required fields as a non-fatal error.
				nerr.AppendRequiredNotSet(string(fd.FullName()))
			}
			continue
		}

		name := json.ValueOf(fd.JSONName())
		pval := knownFields.Get(num)
		var err error
		msgFields, err = o.appendField(msgFields, name, pval, fd)
		if !nerr.Merge(err) {
			return json.Value{}, err
		}
	}

	return json.ValueOf(msgFields), nerr.E
}

// appendField marshals a protoreflect.Value and appends it to the given
// [][2]json.Value.
func (o MarshalOptions) appendField(msgFields [][2]json.Value, name json.Value, pval pref.Value, fd pref.FieldDescriptor) ([][2]json.Value, error) {
	var nerr errors.NonFatal
	var jval json.Value
	var err error

	if fd.Cardinality() == pref.Repeated {
		// Map or repeated fields.
		if fd.IsMap() {
			jval, err = o.marshalMap(pval.Map(), fd)
			if !nerr.Merge(err) {
				return msgFields, err
			}
		} else {
			jval, err = o.marshalList(pval.List(), fd)
			if !nerr.Merge(err) {
				return msgFields, err
			}
		}
	} else {
		// Required or optional fields.
		jval, err = o.marshalSingular(pval, fd)
		if !nerr.Merge(err) {
			return msgFields, err
		}
	}

	msgFields = append(msgFields, [2]json.Value{name, jval})
	return msgFields, nerr.E
}

// marshalSingular converts a non-repeated field value to json.Value.
// This includes all scalar types, enums, messages, and groups.
func (o MarshalOptions) marshalSingular(val pref.Value, fd pref.FieldDescriptor) (json.Value, error) {
	kind := fd.Kind()
	switch kind {
	case pref.BoolKind, pref.StringKind,
		pref.Int32Kind, pref.Sint32Kind, pref.Uint32Kind,
		pref.Sfixed32Kind, pref.Fixed32Kind:
		return json.ValueOf(val.Interface()), nil

	case pref.Int64Kind, pref.Sint64Kind, pref.Uint64Kind,
		pref.Sfixed64Kind, pref.Fixed64Kind:
		return json.ValueOf(val.String()), nil

	case pref.FloatKind, pref.DoubleKind:
		n := val.Float()
		switch {
		case math.IsNaN(n):
			return json.ValueOf("NaN"), nil
		case math.IsInf(n, +1):
			return json.ValueOf("Infinity"), nil
		case math.IsInf(n, -1):
			return json.ValueOf("-Infinity"), nil
		default:
			return json.ValueOf(n), nil
		}

	case pref.BytesKind:
		return json.ValueOf(base64.StdEncoding.EncodeToString(val.Bytes())), nil

	case pref.EnumKind:
		num := val.Enum()
		if desc := fd.EnumType().Values().ByNumber(num); desc != nil {
			return json.ValueOf(string(desc.Name())), nil
		}
		// Use numeric value if there is no enum value descriptor.
		return json.ValueOf(int32(num)), nil

	case pref.MessageKind, pref.GroupKind:
		return o.marshalMessage(val.Message())
	}

	return json.Value{}, errors.New("%v has unknown kind: %v", fd.FullName(), kind)
}

// marshalList converts a protoreflect.List to json.Value.
func (o MarshalOptions) marshalList(list pref.List, fd pref.FieldDescriptor) (json.Value, error) {
	var nerr errors.NonFatal
	size := list.Len()
	values := make([]json.Value, 0, size)

	for i := 0; i < size; i++ {
		item := list.Get(i)
		val, err := o.marshalSingular(item, fd)
		if !nerr.Merge(err) {
			return json.Value{}, err
		}
		values = append(values, val)
	}

	return json.ValueOf(values), nerr.E
}

type mapEntry struct {
	key   pref.MapKey
	value pref.Value
}

// marshalMap converts a protoreflect.Map to json.Value.
func (o MarshalOptions) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) (json.Value, error) {
	msgFields := fd.MessageType().Fields()
	keyType := msgFields.ByNumber(1)
	valType := msgFields.ByNumber(2)

	// Get a sorted list based on keyType first.
	entries := make([]mapEntry, 0, mmap.Len())
	mmap.Range(func(key pref.MapKey, val pref.Value) bool {
		entries = append(entries, mapEntry{key: key, value: val})
		return true
	})
	sortMap(keyType.Kind(), entries)

	// Convert to list of [2]json.Value.
	var nerr errors.NonFatal
	values := make([][2]json.Value, 0, len(entries))
	for _, entry := range entries {
		jkey := json.ValueOf(entry.key.String())
		jval, err := o.marshalSingular(entry.value, valType)
		if !nerr.Merge(err) {
			return json.Value{}, err
		}
		values = append(values, [2]json.Value{jkey, jval})
	}
	return json.ValueOf(values), nerr.E
}

// sortMap orders list based on value of key field for deterministic output.
func sortMap(keyKind pref.Kind, values []mapEntry) {
	less := func(i, j int) bool {
		return values[i].key.String() < values[j].key.String()
	}
	switch keyKind {
	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind,
		pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
		less = func(i, j int) bool {
			return values[i].key.Int() < values[j].key.Int()
		}
	case pref.Uint32Kind, pref.Fixed32Kind,
		pref.Uint64Kind, pref.Fixed64Kind:
		less = func(i, j int) bool {
			return values[i].key.Uint() < values[j].key.Uint()
		}
	}
	sort.Slice(values, less)
}