add default functionality

Author: siherrmann

model/condition.go

@@ -21,6 +21,7 @@ const (
 	NOT_FROM     ConditionType = "nfr"
 	REGX         ConditionType = "rex"
 	FUNC         ConditionType = "fun"
+	DEF          ConditionType = "def"
 )
 
 var ValidConditionTypes = map[ConditionType]int{
@@ -34,6 +35,7 @@ var ValidConditionTypes = map[ConditionType]int{
 	FROM:         7,
 	NOT_FROM:     8,
 	REGX:         9,
+	DEF:          10,
 }
 
 // LookupConditionType checks our validConditionType map for the scanned condition type.

model/parserAst.go

@@ -10,6 +10,14 @@ type RootNode struct {
 	RootValue *AstValue
 }
 
+// ExtractDefault searches the AST for a 'DEF' condition and returns its value.
+func (r *RootNode) ExtractDefault() string {
+	if r.RootValue == nil {
+		return ""
+	}
+	return r.RootValue.ExtractDefault()
+}
+
 // AstValue (=abstract syntax tree value) holds a Type ("Condition" or "Group") as well as a `ConditionType` and `ConditionValue`.
 // The ConditionType is a [model.ConditionType] and the ConditionValue is any string (numbers are also represented as string).
 type AstValue struct {
@@ -22,6 +30,21 @@ type AstValue struct {
 	End            int
 }
 
+// ExtractDefault recursively searches the AST value for a 'DEF' condition and returns its value.
+func (r *AstValue) ExtractDefault() string {
+	for _, v := range r.ConditionGroup {
+		if v.Type == CONDITION && v.ConditionType == DEF {
+			return v.ConditionValue
+		}
+		if v.Type == GROUP {
+			if def := v.ExtractDefault(); def != "" {
+				return def
+			}
+		}
+	}
+	return ""
+}
+
 // AstValueType is the type for all available AST value types.
 type AstValueType string
 

model/parserAst_test.go

@@ -7,6 +7,51 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestExtractDefault(t *testing.T) {
+	tests := []struct {
+		name     string
+		astValue AstValue
+		expected string
+	}{
+		{
+			name: "No default",
+			astValue: AstValue{
+				ConditionGroup: ConditionGroup{
+					&AstValue{Type: CONDITION, ConditionType: EQUAL, ConditionValue: "1"},
+				},
+			},
+			expected: "",
+		},
+		{
+			name: "With default",
+			astValue: AstValue{
+				ConditionGroup: ConditionGroup{
+					&AstValue{Type: CONDITION, ConditionType: DEF, ConditionValue: "test"},
+				},
+			},
+			expected: "test",
+		},
+		{
+			name: "With default in group",
+			astValue: AstValue{
+				ConditionGroup: ConditionGroup{
+					&AstValue{Type: GROUP, ConditionGroup: ConditionGroup{
+						&AstValue{Type: CONDITION, ConditionType: DEF, ConditionValue: "nested"},
+					}},
+				},
+			},
+			expected: "nested",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := test.astValue.ExtractDefault()
+			assert.Equal(t, test.expected, result, "Expected default string to match")
+		})
+	}
+}
+
 func TestAstGroupToString(t *testing.T) {
 	tests := []struct {
 		name     string

model/validation.go

@@ -12,6 +12,8 @@ type Validation struct {
 	Default     string
 	// Inner Struct validation
 	InnerValidation []Validation
+	// Parsed AST representation of the requirement to avoid redundant parsing
+	RequirementAST *AstValue
 }
 
 // ValidatorMap is a map of validation keys to Validation objects.

validationExtract_test.go

@@ -162,6 +162,17 @@ func TestGetValidationsFromStruct(t *testing.T) {
 				assert.Error(t, err, "Expected error when getting validations")
 			} else {
 				assert.NoError(t, err, "Expected no error when getting validations")
+
+				// Helper to clear ASTs for equality testing
+				var clearASTs func(vs []model.Validation)
+				clearASTs = func(vs []model.Validation) {
+					for i := range vs {
+						vs[i].RequirementAST = nil
+						clearASTs(vs[i].InnerValidation)
+					}
+				}
+				clearASTs(validations)
+
 				assert.Equal(t, test.expected, validations, "Expected validations to match")
 			}
 		})

validator.go

@@ -134,7 +134,10 @@ func (r *Validator) ValidateWithValidation(jsonInput map[string]any, validations
 		var ok bool
 		var jsonValue any
 		if jsonValue, ok = jsonInput[validation.Key]; !ok {
-			if strings.TrimSpace(validation.Requirement) == string(model.NONE) {
+			if validation.Default != "" {
+				jsonValue = validation.Default
+				ok = true
+			} else if strings.TrimSpace(validation.Requirement) == string(model.NONE) {
 				continue
 			} else if len(validation.Groups) == 0 {
 				return map[string]any{}, fmt.Errorf("json %v key not in map", validation.Key)
@@ -189,13 +192,18 @@ func (r *Validator) ValidateWithValidation(jsonInput map[string]any, validations
 			err = r.ValidateValueWithParser(jsonValue, &validation)
 		}
 
-		if err != nil && len(validation.Groups) == 0 {
-			return map[string]any{}, fmt.Errorf("field %v invalid: %v", validation.Key, err.Error())
-		} else if err != nil {
-			for _, group := range validation.Groups {
-				groupErrors[group.Name] = append(groupErrors[group.Name], fmt.Errorf("field %v invalid: %v", validation.Key, err.Error()))
+		if err != nil {
+			if validation.Default != "" {
+				jsonValue = validation.Default
+				err = nil
+			} else if len(validation.Groups) == 0 {
+				return map[string]any{}, fmt.Errorf("field %v invalid: %v", validation.Key, err.Error())
+			} else {
+				for _, group := range validation.Groups {
+					groupErrors[group.Name] = append(groupErrors[group.Name], fmt.Errorf("field %v invalid: %v", validation.Key, err.Error()))
+				}
+				continue
 			}
-			continue
 		}
 
 		validateValues[validation.Key] = jsonValue
@@ -214,13 +222,20 @@ func (r *Validator) ValidateWithValidation(jsonInput map[string]any, validations
 //
 // It returns an error if the validation fails.
 func (r *Validator) ValidateValueWithParser(input any, validation *model.Validation) error {
-	p := parser.NewParser()
-	v, err := p.ParseValidation(validation.Requirement)
-	if err != nil {
-		return err
+	var astValue *model.AstValue
+
+	if validation.RequirementAST != nil {
+		astValue = validation.RequirementAST
+	} else {
+		p := parser.NewParser()
+		v, err := p.ParseValidation(validation.Requirement)
+		if err != nil {
+			return err
+		}
+		astValue = v.RootValue
 	}
 
-	err = r.RunValidatorsOnConditionGroup(input, v.RootValue)
+	err := r.RunValidatorsOnConditionGroup(input, astValue)
 	if err != nil {
 		return err
 	}
@@ -244,7 +259,7 @@ func (r *Validator) RunValidatorsOnConditionGroup(input any, astValue *model.Ast
 			err = r.RunValidatorsOnConditionGroup(input, v)
 		case model.CONDITION:
 			switch v.ConditionType {
-			case model.NONE:
+			case model.NONE, model.DEF:
 				continue
 			case model.EQUAL:
 				err = validators.ValidateEqual(input, v)

validatorExtract.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/siherrmann/validator/helper"
 	"github.com/siherrmann/validator/model"
+	"github.com/siherrmann/validator/parser"
 )
 
 // GetValidationsFromStruct extracts validation rules from a struct based on the provided tag type.
@@ -65,6 +66,15 @@ func GetValidationFromStructField(tagType string, fieldValue reflect.Value, fiel
 		}
 		validation.Requirement = tagSplit[tagIndex]
 		tagIndex++
+
+		// Extract default value & cache AST
+		p := parser.NewParser()
+		root, err := p.ParseValidation(validation.Requirement)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing validation: %v", err)
+		}
+		validation.Default = root.ExtractDefault()
+		validation.RequirementAST = root.RootValue
 	}
 
 	if len(tagSplit) > tagIndex {

validator_test.go

@@ -194,6 +194,46 @@ func TestValidateAndUpdate(t *testing.T) {
 		assert.Equal(t, "test", testStruct.Items[0].Name, "Name should not be updated (has ignore upd tag)")
 		assert.Equal(t, 19, testStruct.Items[0].Age, "Age should be updated (has full upd tag)")
 	})
+	t.Run("Valid struct with missing field having def tag", func(t *testing.T) {
+		testStruct := &struct {
+			Fruit string `json:"fruit" vld:"equapple defunasigned"`
+		}{}
+		err := r.ValidateAndUpdate(map[string]any{}, testStruct, model.VLD)
+		assert.NoError(t, err, "Expected no error but got one")
+		assert.Equal(t, "unasigned", testStruct.Fruit, "Expected output to match default")
+	})
+
+	t.Run("Valid struct with invalid field having def tag", func(t *testing.T) {
+		testStruct := &struct {
+			Fruit string `json:"fruit" vld:"equapple defunasigned"`
+		}{}
+		err := r.ValidateAndUpdate(map[string]any{"fruit": "banana"}, testStruct, model.VLD)
+		assert.NoError(t, err, "Expected no error but got one")
+		assert.Equal(t, "unasigned", testStruct.Fruit, "Expected output to match default")
+	})
+
+	t.Run("Valid struct with valid field having def tag", func(t *testing.T) {
+		testStruct := &struct {
+			Fruit string `json:"fruit" vld:"equapple defunasigned"`
+		}{}
+		err := r.ValidateAndUpdate(map[string]any{"fruit": "apple"}, testStruct, model.VLD)
+		assert.NoError(t, err, "Expected no error but got one")
+		assert.Equal(t, "apple", testStruct.Fruit, "Expected output to match input")
+	})
+
+	t.Run("Valid struct with def tag for int", func(t *testing.T) {
+		testStruct := &struct {
+			Count int `json:"count" vld:"min1 def10"`
+		}{}
+		err := r.ValidateAndUpdate(map[string]any{}, testStruct, model.VLD)
+		assert.NoError(t, err, "Expected no error but got one")
+		assert.Equal(t, 10, testStruct.Count, "Expected output to match default")
+
+		testStruct.Count = 0
+		err = r.ValidateAndUpdate(map[string]any{"count": 0}, testStruct, model.VLD)
+		assert.NoError(t, err, "Expected no error but got one")
+		assert.Equal(t, 10, testStruct.Count, "Expected output to match default")
+	})
 }
 
 func TestValidateAndUpdateWithValidation(t *testing.T) {