test: implemented ProtoJSON decoder mapper

Author: ralvarezdev

decoder/protojson/decoder.go

@@ -11,15 +11,50 @@ import (
 type (
 	Decoder struct {
 		unmarshalOptions protojson.UnmarshalOptions
+		cache bool
+		cachedMappers map[string]*Mapper
+	}
+	
+	// Options are the additional settings for the decoder implementation
+	Options struct {
+		// cache indicates whether to cache the precompute unmarshal by reflection functions
+		cache bool
 	}
 )
 
+// NewOptions creates a new Options instance
+// 
+// Parameters:
+// 
+//  - cache: indicates whether to cache the precompute unmarshal by reflection functions
+// 
+// Returns:
+// 
+// - *Options: the new Options instance
+func NewOptions(
+	cache bool,
+) *Options {
+	return &Options{
+		cache: cache,
+	}
+}
+
 // NewDecoder creates a new Decoder instance
+// 
+// Parameters:
+// 
+//  - options: the additional settings for the decoder implementation
 //
 // Returns:
 //
 //   - *Decoder: The decoder instance
-func NewDecoder() *Decoder {
+func NewDecoder(options *Options) *Decoder {
+	// Initialize cache setting
+	cache := false
+	if options != nil {
+		cache = options.cache
+	}
+	
 	// Initialize unmarshal options
 	unmarshalOptions := protojson.UnmarshalOptions{
 		DiscardUnknown: true,
@@ -28,6 +63,7 @@ func NewDecoder() *Decoder {
 
 	return &Decoder{
 		unmarshalOptions: unmarshalOptions,
+		cache:            cache,
 	}
 }
 
@@ -55,6 +91,7 @@ func (d Decoder) Decode(
 	if err != nil {
 		return err
 	}
+	
 	return d.DecodeReader(reader, dest)
 }
 
@@ -81,9 +118,15 @@ func (d Decoder) DecodeReader(
 	if dest == nil {
 		return gojsondecoder.ErrNilDestination
 	}
+	
+	// Read all data from the reader
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		return err
+	}
 
 	return UnmarshalByReflection(
-		reader,
+		data,
 		dest,
 		&d.unmarshalOptions,
 	)

decoder/protojson/errors.go

@@ -0,0 +1,15 @@
+package protojson
+
+import (
+	"errors"
+)
+
+const (
+	ErrFieldNotHandled = "field not handled on decoding: %s"
+)
+
+var (
+	ErrNilMapper 			= errors.New("decoder mapper is nil")
+	ErrNilDestinationInstance = errors.New("nil destination instance")
+	ErrNilDestination = 		errors.New("nil destination")
+)

decoder/protojson/mapper.go

@@ -0,0 +1,265 @@
+package protojson
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	goreflect "github.com/ralvarezdev/go-reflect"
+	gostringsjson "github.com/ralvarezdev/go-strings/json"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+type (
+	// Mapper is the struct to hold precomputed marshal by reflection functions
+	Mapper struct{
+		reflectType reflect.Type
+		isProtoMessage bool
+		regularFields map[string]struct{}
+		protoMessageFields map[string]struct{}
+		jsonFieldNames map[string]string
+		nestedStructs map[string]*Mapper
+	}
+)
+
+// NewMapper creates a new Mapper instance
+// 
+// Parameters:
+// 
+// - destinationInstance: the destination instance to create the mapper for
+// 
+// Returns:
+// 
+// - *Mapper: the new Mapper instance
+// - error: the error if any
+func NewMapper(
+	destinationInstance any,
+) (*Mapper, error) {
+	// Check if the destination instance is nil
+	if destinationInstance == nil {
+		return nil, ErrNilDestinationInstance
+	}
+	
+	// Check if the destination is a proto.Message
+	_, ok := destinationInstance.(proto.Message)
+	if ok {
+		return &Mapper{
+			isProtoMessage: true,
+		}, nil
+	}
+	
+	// Create the maps to hold field information
+	regularFields := make(map[string]struct{})
+	protoMessageFields := make(map[string]struct{})
+	nestedStructs := make(map[string]*Mapper)
+	jsonFieldNames := make(map[string]string)
+	
+	// Get the reflect type and value of the destination instance
+	reflectType := goreflect.GetDereferencedType(destinationInstance)
+	reflectValue := goreflect.GetDereferencedValue(destinationInstance)
+	
+	// Check if the type is a struct
+	for i := 0; i < reflectValue.NumField(); i++ {
+		// Get the field and its type
+		structField := reflectType.Field(i)
+		fieldValue := reflectValue.Field(i)
+		fieldName := structField.Name
+
+		// Check if the field can be set
+		if !fieldValue.CanSet() {
+			continue
+		}
+		
+		// Get the JSON tag of the field
+		jsonTag, err := gostringsjson.GetJSONTag(&structField, fieldName)
+		if err != nil {
+			return nil, err
+		}
+		
+		// Get the JSON field name from the tag
+		jsonFieldName, err := gostringsjson.GetJSONTagName(jsonTag, fieldName)
+		if err != nil {
+			return nil, err
+		}
+		
+		// Store the JSON field name
+		jsonFieldNames[fieldName] = jsonFieldName
+		
+		// Get the field interface
+		fieldValueInterface := fieldValue.Interface()
+		
+		// Check if the field is a proto.Message
+		if _, ok := fieldValueInterface.(proto.Message); ok {
+			// Store the proto.Message field
+			protoMessageFields[fieldName] = struct{}{}
+			continue
+		}
+		
+		// Dereference pointer if necessary
+		if fieldValue.Kind() == reflect.Ptr {
+			fieldValue = fieldValue.Elem()
+		}
+		
+		// Check if the field is a struct
+		if fieldValue.Kind() == reflect.Struct {
+			// Create a nested mapper for the struct field
+			nestedMapper, err := NewMapper(fieldValueInterface)
+			if err != nil {
+				return nil, err
+			}
+			nestedStructs[fieldName] = nestedMapper
+			continue
+		}
+		
+		// Regular field
+		regularFields[fieldName] = struct{}{}
+	}
+	return &Mapper{
+		reflectType:       reflectType,
+		isProtoMessage:     false,
+		regularFields:      regularFields,
+		protoMessageFields: protoMessageFields,
+		nestedStructs:      nestedStructs,
+	}, nil
+}
+
+// UnmarshalByReflection unmarshal JSON data into a destination using reflection
+//
+// Parameters:
+//
+//   - body: The JSON data to unmarshal
+//   - dest: The destination to unmarshal the JSON data into
+//   - unmarshalOptions: Options for unmarshalling proto messages (optional, can be nil)
+//
+// Returns:
+//
+//   - error: The error if any
+func (m *Mapper) UnmarshalByReflection(
+	body []byte,
+	dest any,
+	unmarshalOptions *protojson.UnmarshalOptions,
+) error {	
+	// Check if the mapper is nil
+	if m == nil {
+		return ErrNilMapper
+	}
+	
+	// Check if the destination is nil
+	if dest == nil {
+		return ErrNilDestination
+	}
+	
+	// Check if the unmarshal options are nil, if so initialize them
+	if unmarshalOptions == nil {
+		unmarshalOptions = &protojson.UnmarshalOptions{}
+	}
+
+	// Check if the destination is a proto.Message
+	if m.isProtoMessage {
+		// Unmarshal directly into the proto.Message
+		if unmarshalErr := unmarshalOptions.Unmarshal(
+			body,
+			dest.(proto.Message),
+		); unmarshalErr != nil {
+			return unmarshalErr
+		}
+		return nil
+	}
+		
+	// Initialize the map to hold intermediate JSON data
+	var tempDest map[string]any
+	if unmarshalErr := json.Unmarshal(body, &tempDest); unmarshalErr != nil {
+		return unmarshalErr
+	}
+	
+	// Get the reflect value of the destination
+	reflectValue := goreflect.GetDereferencedValue(dest)
+	
+	// Decode nested proto messages
+	mappedBody := make(map[string]any)
+	for i := 0; i < reflectValue.NumField(); i++ {
+		// Get the field and its type
+		structField := m.reflectType.Field(i)
+		fieldName := structField.Name
+		fieldType := structField.Type
+		fieldValue := reflectValue.Field(i)
+		
+		// Get the JSON tag of the field
+		jsonFieldName, ok := m.jsonFieldNames[fieldName]
+		if !ok {
+			// If no JSON field name is found, skip the field, it means it cannot be set
+			continue
+		}
+		
+		// Get the corresponding body field
+		bodyField, ok := tempDest[jsonFieldName]
+		if !ok {
+			continue
+		}
+		
+		// Check if the field is a regular field
+		if _, ok := m.regularFields[fieldName]; ok {
+			// Directly map the body field
+			mappedBody[fieldName] = bodyField
+			continue
+		}
+		
+		// Check if the field is a proto.Message
+		if _, ok := m.protoMessageFields[fieldName]; ok {
+			// Marshal the body field to JSON
+			marshaledField, err := json.Marshal(bodyField)
+			if err != nil {
+				return err
+			}
+			
+			// Create a new instance of the proto.Message if it's a pointer and is nil
+			if fieldValue.Kind() == reflect.Ptr {
+				fieldValue.Set(reflect.New(fieldType.Elem()))
+			}
+			
+			// Get the interface of the field value
+			fieldValueInterface := fieldValue.Interface()
+
+			// Unmarshal the JSON into the proto.Message field
+			if unmarshalErr := unmarshalOptions.Unmarshal(
+				marshaledField,
+				fieldValueInterface.(proto.Message),
+			); unmarshalErr != nil {
+				return unmarshalErr
+			}
+			
+			// Map the proto.Message field
+			mappedBody[fieldName] = fieldValueInterface
+			continue
+		}
+
+		// Check if the field is a nested struct
+		if nestedMapper, ok := m.nestedStructs[fieldName]; ok {
+			// Marshal the body field to JSON
+			marshaledNestedBody, err := json.Marshal(bodyField)
+			if err != nil {
+				return err
+			}
+			
+			// Get the interface of the field value
+			fieldValueInterface := fieldValue.Addr().Interface()
+			
+			// Unmarshal the body field by reflection
+			nestedMapper.UnmarshalByReflection(marshaledNestedBody, fieldValueInterface, unmarshalOptions)
+		
+			// Set the mapped nested struct
+			mappedBody[fieldName] = fieldValueInterface
+			continue
+		}
+			
+		// The field type is not handled, return an error
+		return fmt.Errorf(ErrFieldNotHandled, fieldName)
+	}
+	
+	// Reflect the destination value
+	destValue := goreflect.GetDereferencedValue(dest)
+
+	// Map the body to the struct field
+	return goreflect.ValueToReflectStruct(mappedBody, destValue, false)
+}