added inline and dot support

Author: siherrmann

helper/jsonMap.go

@@ -66,15 +66,71 @@ func MapJsonMapToStruct(jsonMapInput map[string]any, structToUpdate any) error {
 
 		fieldKey := fieldType.Name
 		jsonKey := fieldType.Tag.Get("json")
+		isInline := false
 		if len(jsonKey) > 0 {
 			// Split on comma to handle omitempty and other options
-			jsonKey = strings.Split(jsonKey, ",")[0]
-			if jsonKey != "-" {
-				fieldKey = jsonKey
+			parts := strings.Split(jsonKey, ",")
+			jsonKeyPrefix := parts[0]
+			for _, p := range parts[1:] {
+				if p == "inline" {
+					isInline = true
+				}
+			}
+			if jsonKeyPrefix != "-" && jsonKeyPrefix != "" {
+				fieldKey = jsonKeyPrefix
 			}
 		}
 
+		if isInline {
+			target := field
+			if field.Kind() == reflect.Ptr {
+				if field.IsNil() {
+					if field.CanSet() {
+						field.Set(reflect.New(field.Type().Elem()))
+					}
+				}
+				target = field.Elem()
+			}
+			if target.CanAddr() {
+				err := MapJsonMapToStruct(jsonMapInput, target.Addr().Interface())
+				if err != nil {
+					return fmt.Errorf("error mapping inline struct %v: %v", fieldType.Name, err.Error())
+				}
+			} else if field.Kind() == reflect.Ptr {
+				err := MapJsonMapToStruct(jsonMapInput, field.Interface())
+				if err != nil {
+					return fmt.Errorf("error mapping inline struct %v: %v", fieldType.Name, err.Error())
+				}
+			}
+			continue
+		}
+
 		if jsonValue, ok := jsonMapInput[fieldKey]; ok {
+			if jsonValueMap, isMap := jsonValue.(map[string]any); isMap && (field.Kind() == reflect.Struct || (field.Kind() == reflect.Ptr && field.Elem().Kind() == reflect.Struct)) {
+				target := field
+				if field.Kind() == reflect.Ptr {
+					if field.IsNil() {
+						if field.CanSet() {
+							field.Set(reflect.New(field.Type().Elem()))
+						}
+					}
+					target = field.Elem()
+				}
+				if target.CanAddr() {
+					err := MapJsonMapToStruct(jsonValueMap, target.Addr().Interface())
+					if err != nil {
+						return fmt.Errorf("error mapping nested struct %v: %v", fieldType.Name, err.Error())
+					}
+					continue
+				} else if field.Kind() == reflect.Ptr {
+					err := MapJsonMapToStruct(jsonValueMap, field.Interface())
+					if err != nil {
+						return fmt.Errorf("error mapping nested struct %v: %v", fieldType.Name, err.Error())
+					}
+					continue
+				}
+			}
+
 			err := SetStructValueByJson(field, jsonValue)
 			if err != nil {
 				return fmt.Errorf("could not set field %v (json key: %v) of %v: %v", fieldType.Name, jsonKey, reflect.TypeOf(structToUpdate), err.Error())

helper/jsonMap_test.go

@@ -613,4 +613,20 @@ func TestMapJsonMapToStruct(t *testing.T) {
 			assert.Nil(t, result.PointerSlice)
 		})
 	})
+
+	t.Run("Inline struct fields", func(t *testing.T) {
+		type InnerStruct struct {
+			Kind string `json:"kind"`
+		}
+		type TestStruct struct {
+			Inner InnerStruct `json:",inline"`
+		}
+
+		inputMap := map[string]any{"kind": "testKind"}
+		var result TestStruct
+		err := MapJsonMapToStruct(inputMap, &result)
+		assert.NoError(t, err)
+
+		assert.Equal(t, "testKind", result.Inner.Kind)
+	})
 }

helper/unpack.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strings"
 )
 
 func UnmarshalRequestToJsonMap(request *http.Request) (map[string]any, error) {
@@ -58,17 +59,48 @@ func UnmapUrlValuesToJsonMap(values url.Values) (map[string]any, error) {
 					arrayOut = append(arrayOut, v)
 				}
 			}
-			mapOut[k] = arrayOut
+			if strings.Contains(k, ".") {
+				setNestedDotValue(mapOut, strings.Split(k, "."), arrayOut)
+			} else {
+				mapOut[k] = arrayOut
+			}
 		} else {
 			value := values.Get(k)
 			var unmarshalled any
+			var valToSet any
 			err := json.Unmarshal([]byte(value), &unmarshalled)
 			if err == nil {
-				mapOut[k] = unmarshalled
+				valToSet = unmarshalled
 			} else {
-				mapOut[k] = value
+				valToSet = value
+			}
+			
+			if strings.Contains(k, ".") {
+				setNestedDotValue(mapOut, strings.Split(k, "."), valToSet)
+			} else {
+				mapOut[k] = valToSet
 			}
 		}
 	}
 	return mapOut, nil
 }
+
+func setNestedDotValue(m map[string]any, keys []string, value any) {
+	if len(keys) == 0 {
+		return
+	}
+	if len(keys) == 1 {
+		m[keys[0]] = value
+		return
+	}
+	key := keys[0]
+	if existing, ok := m[key]; ok {
+		if nestedMap, ok := existing.(map[string]any); ok {
+			setNestedDotValue(nestedMap, keys[1:], value)
+			return
+		}
+	}
+	nestedMap := make(map[string]any)
+	m[key] = nestedMap
+	setNestedDotValue(nestedMap, keys[1:], value)
+}

helper/unpack_test.go

@@ -88,6 +88,19 @@ func TestUnmapUrlValuesToJsonMap(t *testing.T) {
 		assert.Equal(t, map[string]any{"food": "banana", "fruit": "apple"}, mapOut["map"], "Expected map to match")
 	})
 
+	t.Run("Valid URL with dot-notation keys", func(t *testing.T) {
+		values := url.Values{}
+		values.Set("autoscaling.minReplicas", "3")
+		values.Set("autoscaling.featureFlag", "true")
+
+		mapOut, err := UnmapUrlValuesToJsonMap(values)
+		assert.NoError(t, err, "Expected no error unmapping URL values to JsonMap")
+		assert.IsType(t, map[string]any{}, mapOut["autoscaling"], "Expected autoscaling to be a nested map")
+		autoscalingMap := mapOut["autoscaling"].(map[string]any)
+		assert.Equal(t, float64(3), autoscalingMap["minReplicas"], "Expected minReplicas to be 3")
+		assert.Equal(t, true, autoscalingMap["featureFlag"], "Expected featureFlag to be true")
+	})
+
 	t.Run("Empty URL values", func(t *testing.T) {
 		values := url.Values{}
 

model/validation.go

@@ -10,6 +10,7 @@ type Validation struct {
 	Requirement string
 	Groups      []*Group
 	Default     string
+	OmitEmpty   bool
 	// Inner Struct validation
 	InnerValidation []Validation
 	// Parsed AST representation of the requirement to avoid redundant parsing

validationExtract_test.go

@@ -63,6 +63,23 @@ func TestGetValidationsFromStruct(t *testing.T) {
 			},
 			expectedError: false,
 		},
+		{
+			name: "Valid struct with omitempty and inline tags",
+			args: args{
+				input: &struct {
+					Inner struct {
+						Kind string `json:"kind" vld:"equ1"`
+					} `json:",inline" vld:"-"`
+					Field1 string `json:"field1,omitempty" vld:"equ1"`
+				}{},
+				tagType: model.VLD,
+			},
+			expected: []model.Validation{
+				{Key: "kind", Type: model.String, Requirement: "equ1"},
+				{Key: "field1", Type: model.String, Requirement: "equ1", OmitEmpty: true},
+			},
+			expectedError: false,
+		},
 		{
 			name: "Valid struct with inner struct",
 			args: args{

validator.go

@@ -149,6 +149,10 @@ func (r *Validator) ValidateWithValidation(jsonInput map[string]any, validations
 			}
 		}
 
+		if validation.OmitEmpty && jsonValue == "" {
+			continue
+		}
+
 		var err error
 		switch validation.Type {
 		case model.Struct:

validatorExtract.go

@@ -32,8 +32,22 @@ func GetValidationsFromStruct(in any, tagType string) ([]model.Validation, error
 			continue
 		}
 
-		if len(validation.Requirement) > 0 {
-			validations = append(validations, *validation)
+		isInline := false
+		if len(fieldType.Tag.Get("json")) > 0 {
+			parts := strings.Split(fieldType.Tag.Get("json"), ",")
+			for _, part := range parts[1:] {
+				if part == "inline" {
+					isInline = true
+				}
+			}
+		}
+
+		if isInline {
+			validations = append(validations, validation.InnerValidation...)
+		} else {
+			if len(validation.Requirement) > 0 || len(validation.InnerValidation) > 0 {
+				validations = append(validations, *validation)
+			}
 		}
 	}
 	return validations, nil
@@ -46,11 +60,16 @@ func GetValidationFromStructField(tagType string, fieldValue reflect.Value, fiel
 	validation := &model.Validation{}
 	validation.Key = fieldType.Name
 	if len(fieldType.Tag.Get("json")) > 0 {
-		jsonKey := fieldType.Tag.Get("json")
-		// Split on comma to handle omitempty and other options
-		jsonKey = strings.Split(jsonKey, ",")[0]
-		if jsonKey != "-" {
-			validation.Key = jsonKey
+		jsonKeyFull := fieldType.Tag.Get("json")
+		jsonKeyParts := strings.Split(jsonKeyFull, ",")
+		jsonKeyPrefix := jsonKeyParts[0]
+		if jsonKeyPrefix != "-" && jsonKeyPrefix != "" {
+			validation.Key = jsonKeyPrefix
+		}
+		for _, part := range jsonKeyParts[1:] {
+			if part == "omitempty" {
+				validation.OmitEmpty = true
+			}
 		}
 	}
 	validation.Type = model.ReflectKindToValidatorType(fieldValue.Type().Kind())
@@ -92,8 +111,12 @@ func GetValidationFromStructField(tagType string, fieldValue reflect.Value, fiel
 			return nil, fmt.Errorf("error getting inner validation from array: %v", err)
 		}
 		validation.InnerValidation = append(validation.InnerValidation, innerValidation...)
-	} else if helper.IsStruct(fieldValue.Interface()) {
-		innerStruct := reflect.New(fieldValue.Type()).Interface()
+	} else if helper.IsStruct(fieldValue.Interface()) || (fieldValue.Type().Kind() == reflect.Ptr && fieldValue.Type().Elem().Kind() == reflect.Struct) {
+		fieldTypeElem := fieldValue.Type()
+		if fieldTypeElem.Kind() == reflect.Ptr {
+			fieldTypeElem = fieldTypeElem.Elem()
+		}
+		innerStruct := reflect.New(fieldTypeElem).Interface()
 		innerValidation, err := GetValidationsFromStruct(innerStruct, string(tagType))
 		if err != nil {
 			return nil, fmt.Errorf("error getting inner validation from struct: %v", err)

validator_test.go

@@ -312,6 +312,40 @@ func TestValidateWithValidation(t *testing.T) {
 		expected any
 		wantErr  bool
 	}{
+		{
+			name: "Valid omitempty logic with empty string",
+			args: args{
+				jsonMap: map[string]any{
+					"fruit": "",
+				},
+				validations: []model.Validation{
+					{
+						Key:         "fruit",
+						Type:        model.String,
+						Requirement: "equapple",
+						OmitEmpty:   true,
+					},
+				},
+			},
+			expected: map[string]any{},
+			wantErr:  false,
+		},
+		{
+			name: "Valid defFalse logic for missing boolean",
+			args: args{
+				jsonMap: map[string]any{},
+				validations: []model.Validation{
+					{
+						Key:         "isActive",
+						Type:        model.Bool,
+						Requirement: "deffalse",
+						Default:     "false",
+					},
+				},
+			},
+			expected: map[string]any{"isActive": "false"},
+			wantErr:  false,
+		},
 		{
 			name: "Valid validation string",
 			args: args{