refactor: added unique type reference comparation between root validations and its mapper

Author: ralvarezdev

mapper/mapper.go

@@ -2,11 +2,16 @@ package mapper
 
 import (
 	"reflect"
+	
+	goreflect "github.com/ralvarezdev/go-reflect"
 )
 
 type (
 	// Mapper is a map of fields to validate from a struct
 	Mapper struct {
+		// uniqueTypeReference is the unique type reference of the struct
+		uniqueTypeReference string
+		
 		// structInstance is the instance of the struct
 		structInstance any
 
@@ -38,24 +43,36 @@ func NewMapper(structInstance any) (*Mapper, error) {
 	}
 
 	// Get the type of the struct instance
-	structInstanceType := reflect.TypeOf(structInstance)
-	structInstanceValue := reflect.ValueOf(structInstance)
-
-	// Dereference pointer if necessary
-	if structInstanceType.Kind() == reflect.Ptr {
-		structInstanceType = structInstanceType.Elem()
-		structInstanceValue = structInstanceValue.Elem()
-	}
+	structInstanceType := goreflect.GetDereferencedType(structInstance)
+	structInstanceValue := goreflect.GetDereferencedValue(structInstance)
 
 	// Ensure it's a struct
 	if structInstanceType.Kind() != reflect.Struct {
 		return nil, ErrInvalidStructInstance
 	}
+	
+	// Get the value of the struct instance
+	structInstanceValueInterface := structInstanceValue.Interface()
+	
+	// Get the unique type identifier for the struct
+	uniqueTypeReference := goreflect.UniqueTypeReference(structInstanceValueInterface)
+
+	return &Mapper{
+		structInstance: structInstanceValueInterface,
+	 	uniqueTypeReference: uniqueTypeReference,
+	}, nil
+}
 
-	// Use the dereferenced value (as interface{})
-	dereferencedStructInstance := structInstanceValue.Interface()
-
-	return &Mapper{structInstance: dereferencedStructInstance}, nil
+// GetUniqueTypeReference returns the unique type reference of the struct
+// 
+// Returns:
+// 
+//  - string: unique type reference of the struct
+func (m *Mapper) GetUniqueTypeReference() string {
+	if m == nil {
+		return ""
+	}
+	return m.uniqueTypeReference
 }
 
 // GetStructInstance returns the instance of the struct

mapper/validation/types.go

@@ -7,6 +7,7 @@ import (
 type (
 	// StructValidations is a struct that holds the struct validations for the generated validations of a struct
 	StructValidations struct {
+		uniqueTypeReference     *string
 		fieldName                *string
 		reflection               *goreflect.Reflection
 		fieldsValidations        map[string]*FieldValidations
@@ -34,9 +35,20 @@ func NewStructValidations(instance any) (*StructValidations, error) {
 	if instance == nil {
 		return nil, ErrNilInstance
 	}
+	
+	// Get the reflection of the instance
+	instanceReflection := goreflect.NewDereferencedReflection(instance)
+	instanceValue := instanceReflection.GetReflectedValue()
+	
+	// Get the interface of the instance
+	instanceValueInterface := instanceValue.Interface()
+	
+	// Get the unique type identifier for the instance
+	uniqueTypeReference := goreflect.UniqueTypeReference(instanceValueInterface)
 
 	return &StructValidations{
-		reflection: goreflect.NewDereferencedReflection(instance),
+		uniqueTypeReference: &uniqueTypeReference,
+		reflection: instanceReflection,
 	}, nil
 }
 
@@ -62,7 +74,7 @@ func NewNestedStructValidations(
 	if fieldName == "" {
 		return NewStructValidations(instance)
 	}
-
+	
 	return &StructValidations{
 		fieldName:  &fieldName,
 		reflection: goreflect.NewDereferencedReflection(instance),
@@ -93,6 +105,18 @@ func (s *StructValidations) GetStructTypeName() string {
 	return s.reflection.GetReflectedTypeName()
 }
 
+// GetUniqueTypeReference returns the unique type reference of the struct
+// 
+// Returns:
+// 
+//  - *string: The unique type reference of the struct
+func (s *StructValidations) GetUniqueTypeReference() *string {
+	if s == nil {
+		return nil
+	}
+	return s.uniqueTypeReference
+}
+
 // HasFailed returns true if there are failed validations
 //
 // Returns:

mapper/validator/errors.go

@@ -4,13 +4,18 @@ import (
 	"errors"
 )
 
+const (
+	ErrFieldTagNameNotFound    = "field tag name not found: %s"
+	ErrFieldIsRequiredNotFound = "field is required not found: %s"
+	ErrStructValidationsAndMapperTypeMismatch = "struct validations and mapper type mismatch, both must be of the same type, mapper type: %s, struct validations type: %s"
+)
+
 var (
 	ErrNilService              = errors.New("mapper validator service cannot be nil")
 	ErrNilDestination          = errors.New("destination cannot be nil")
 	ErrDestinationNotPointer   = errors.New("destination must be a pointer")
 	ErrNilMapper               = errors.New("mapper cannot be nil")
 	ErrNilValidator            = errors.New("mapper validator cannot be nil")
-	ErrFieldTagNameNotFound    = "field tag name not found: %s"
-	ErrFieldIsRequiredNotFound = "field is required not found: %s"
+	ErrStructValidationsIsNotRootLevel  = errors.New("struct validations is not root level")
 	ErrRequiredField           = "%s is required"
 )

mapper/validator/validator.go

@@ -86,6 +86,20 @@ func (d DefaultValidator) ValidateRequiredFields(
 	if mapper == nil {
 		return ErrNilMapper
 	}
+	
+	// Compare the unique type references
+	rootStructValidationsTypeReference := rootStructValidations.GetUniqueTypeReference()
+	mapperTypeReference := mapper.GetUniqueTypeReference()
+	if rootStructValidationsTypeReference == nil {
+		return ErrStructValidationsIsNotRootLevel
+	}
+	if *rootStructValidationsTypeReference != mapperTypeReference {
+		return fmt.Errorf(
+			ErrStructValidationsAndMapperTypeMismatch,
+			mapperTypeReference,
+			*rootStructValidationsTypeReference,
+		)
+	}
 
 	// Check if the struct has fields validations
 	if !mapper.HasFieldsValidations() {