fix(valueparser): Use target type in unmarshalling

Author: YaCodesDevelopment

config/config_loader.go

@@ -261,8 +261,8 @@ func LoadConfigStructFromEnv[T any](instance *T, log *logrus.Entry) {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 			value := GetEnv(envKey, "", false, log)
 
-			val, err := valueparser.TryUnmarshal[int64](value)
-			if err != nil {
+			val, err := valueparser.TryUnmarshal[int64](value, field.Type)
+			if err == nil {
 				fieldVal.SetInt(val)
 
 				continue
@@ -277,8 +277,8 @@ func LoadConfigStructFromEnv[T any](instance *T, log *logrus.Entry) {
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 			value := GetEnv(envKey, "", false, log)
 
-			val, err := valueparser.TryUnmarshal[uint64](value)
-			if err != nil {
+			val, err := valueparser.TryUnmarshal[uint64](value, field.Type)
+			if err == nil {
 				fieldVal.SetUint(val)
 
 				continue
@@ -293,8 +293,8 @@ func LoadConfigStructFromEnv[T any](instance *T, log *logrus.Entry) {
 		case reflect.Float32, reflect.Float64:
 			value := GetEnv(envKey, "", false, log)
 
-			val, err := valueparser.TryUnmarshal[float64](value)
-			if err != nil {
+			val, err := valueparser.TryUnmarshal[float64](value, field.Type)
+			if err == nil {
 				fieldVal.SetFloat(val)
 
 				continue
@@ -309,8 +309,8 @@ func LoadConfigStructFromEnv[T any](instance *T, log *logrus.Entry) {
 		case reflect.Bool:
 			value := GetEnv(envKey, "", false, log)
 
-			val, err := valueparser.TryUnmarshal[bool](value)
-			if err != nil {
+			val, err := valueparser.TryUnmarshal[bool](value, field.Type)
+			if err == nil {
 				fieldVal.SetBool(val)
 
 				continue
@@ -325,8 +325,8 @@ func LoadConfigStructFromEnv[T any](instance *T, log *logrus.Entry) {
 		case reflect.String:
 			value := GetEnv(envKey, "", false, log)
 
-			val, err := valueparser.TryUnmarshal[string](value)
-			if err != nil {
+			val, err := valueparser.TryUnmarshal[string](value, field.Type)
+			if err == nil {
 				fieldVal.SetString(val)
 
 				continue

config/utils.go

@@ -1,10 +1,10 @@
 package config
 
 import (
-	"fmt"
 	"reflect"
 	"strings"
 
+	"github.com/YaCodeDev/GoYaCodeDevUtils/valueparser"
 	"github.com/sirupsen/logrus"
 )
 
@@ -47,33 +47,27 @@ func copyMap(src reflect.Value, dst reflect.Value) {
 		return
 	}
 
+	var (
+		convertedKey reflect.Value
+		convertedVal reflect.Value
+		err          error
+	)
+
 	for _, key := range src.MapKeys() {
 		val := src.MapIndex(key)
 
-		convertedKey := convertValue(key, dst.Type().Key())
-		convertedVal := convertValue(val, dst.Type().Elem())
-
-		dst.SetMapIndex(convertedKey, convertedVal)
-	}
-}
+		convertedKey, err = valueparser.ConvertValue(key, dst.Type().Key())
+		if err != nil {
+			panic("Cannot convert key: " + err.Error())
+		}
 
-// convertValue converts a reflect.Value to the specified target type.
-// It checks if the value is valid and convertible to the target type.
-// If the value is valid and convertible, it returns the converted value.
-// If the value is invalid, it returns a zero value of the target type.
-// If the value is valid but not convertible, it panics with an error message.
-// This function is used to ensure that the value being set in a map or slice is of the correct type.
-// It is a helper function for copyMap and copyArray functions.
-func convertValue(val reflect.Value, targetType reflect.Type) reflect.Value {
-	if !val.IsValid() {
-		return reflect.Zero(targetType)
-	}
+		convertedVal, err = valueparser.ConvertValue(val, dst.Type().Elem())
+		if err != nil {
+			panic("Cannot convert value: " + err.Error())
+		}
 
-	if val.Type().ConvertibleTo(targetType) {
-		return val.Convert(targetType)
+		dst.SetMapIndex(convertedKey, convertedVal)
 	}
-
-	panic(fmt.Sprintf("Cannot convert from %s to %s", val.Type(), targetType))
 }
 
 // copyArray copies elements from the source slice to the destination slice.
@@ -99,7 +93,12 @@ func copyArray(src, dst reflect.Value) {
 		val := src.Index(i)
 
 		if val.IsValid() {
-			dst.Index(i).Set(convertValue(val, dst.Type().Elem()))
+			converted, err := valueparser.ConvertValue(val, dst.Type().Elem())
+			if err != nil {
+				panic("Cannot convert value: " + err.Error())
+			}
+
+			dst.Index(i).Set(converted)
 		}
 	}
 }

valueparser/try_unmarshal.go

@@ -2,6 +2,7 @@ package valueparser
 
 import (
 	"encoding"
+	"fmt"
 	"reflect"
 )
 
@@ -15,30 +16,32 @@ import (
 //	if err != nil {
 //		// Handle error
 //	}
-func TryUnmarshal[T ParsableType](value string) (T, error) {
+func TryUnmarshal[T ParsableType](value string, valueType reflect.Type) (T, error) {
 	var zero T
+
 	typ := reflect.TypeOf(zero)
+	ptr := reflect.New(valueType)
 
-	ptr := reflect.New(typ)
 	if unmarshaler, ok := ptr.Interface().(encoding.TextUnmarshaler); ok {
 		if err := unmarshaler.UnmarshalText([]byte(value)); err == nil {
-			if val, ok := ptr.Elem().Interface().(T); ok {
-				return val, nil
-			}
-
-			return zero, ErrInvalidValue
+			return zero, fmt.Errorf("cannot convert value %v to type %s: %w", value, typ, err)
+		}
+	} else if unmarshaler, ok := ptr.Interface().(Unmarshalable); ok {
+		if err := unmarshaler.Unmarshal(value); err != nil {
+			return zero, ErrUnparsableValue
 		}
+	} else {
+		return zero, ErrUnparsableValue
 	}
 
-	if unmarshaler, ok := ptr.Interface().(Unmarshalable); ok {
-		if err := unmarshaler.Unmarshal(value); err == nil {
-			if val, ok := ptr.Elem().Interface().(T); ok {
-				return val, nil
-			}
+	val, err := ConvertValue(ptr.Elem(), typ)
+	if err != nil {
+		return zero, fmt.Errorf("cannot convert value %v to type %s: %w", value, typ, err)
+	}
 
-			return zero, ErrInvalidValue
-		}
+	if val, ok := val.Interface().(T); ok {
+		return val, nil
 	}
 
-	return zero, ErrUnparsableValue
+	return zero, ErrInvalidValue
 }

valueparser/value_convertor.go

@@ -0,0 +1,22 @@
+package valueparser
+
+import (
+	"reflect"
+)
+
+// ConvertValue converts a reflect.Value to the specified target type.
+// It checks if the value is valid and convertible to the target type.
+// If the value is valid and convertible, it returns the converted value.
+// If the value is invalid, it returns a zero value of the target type.
+// If the value is valid but not convertible, it panics with an error message.
+func ConvertValue(val reflect.Value, targetType reflect.Type) (reflect.Value, error) {
+	if !val.IsValid() {
+		return reflect.Zero(targetType), nil
+	}
+
+	if val.Type().ConvertibleTo(targetType) {
+		return val.Convert(targetType), nil
+	}
+
+	return reflect.Value{}, ErrUnparsableValue
+}

valueparser/value_parser.go

@@ -77,16 +77,10 @@ func ParseValue[T ParsableType](value string) (T, error) {
 		return zero, ErrInvalidType
 	}
 
-	val, err := TryUnmarshal[T](value)
+	val, err := TryUnmarshal[T](value, typ)
 	if err != nil {
 		return zero, err
 	}
 
-	var ok bool
-
-	if val, ok = reflect.ValueOf(val).Convert(typ).Interface().(T); ok {
-		return val, nil
-	}
-
-	return zero, ErrInvalidValue
+	return val, nil
 }