fix: resolve panic when using aliases with OR operator (#766)

When using RegisterAlias with OR operator (|), the validator panics with
"Undefined validation function" error. This happens because aliases are
only checked when parsing comma-separated tags, not when parsing OR-
separated values.

This fix adds alias lookup in the OR parsing logic. When an alias is
found within an OR expression, it is recursively parsed and properly
inserted into the validation chain.

Fixes #766

Author: shindonghwi

cache.go

@@ -289,6 +289,34 @@ func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias s
 				if wrapper, ok := v.validations[current.tag]; ok {
 					current.fn = wrapper.fn
 					current.runValidationWhenNil = wrapper.runValidationOnNil
+				} else if aliasTag, isAlias := v.aliases[current.tag]; isAlias {
+					// Handle alias within OR expression (issue #766)
+					// Recursively parse the alias tag
+					aliasFirst, aliasLast := v.parseFieldTagsRecursive(aliasTag, fieldName, current.tag, true)
+
+					// Copy the first parsed alias tag's validation data to current
+					current.tag = aliasFirst.tag
+					current.fn = aliasFirst.fn
+					current.runValidationWhenNil = aliasFirst.runValidationWhenNil
+					current.hasParam = aliasFirst.hasParam
+					current.param = aliasFirst.param
+					current.typeof = aliasFirst.typeof
+					current.hasAlias = true
+					// Note: isBlockEnd is NOT copied here; it will be set at the end of the OR loop
+
+					// If alias expanded to multiple tags, insert them into the chain
+					if aliasFirst.next != nil {
+						// Save what comes after current in the OR chain
+						nextInChain := current.next
+						// Link the rest of the alias chain
+						current.next = aliasFirst.next
+						// Connect the last alias tag to what was after current
+						aliasLast.next = nextInChain
+						// Clear isBlockEnd since this may not be the last tag in the OR expression
+						aliasLast.isBlockEnd = false
+						// Update current to point to the last tag in the alias chain
+						current = aliasLast
+					}
 				} else {
 					panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, current.tag, fieldName)))
 				}

validator_test.go

@@ -696,6 +696,104 @@ func TestAliasTags(t *testing.T) {
 	PanicMatches(t, func() { validate.RegisterAlias("exists!", "gt=5,lt=10") }, "Alias 'exists!' either contains restricted characters or is the same as a restricted tag needed for normal operation")
 }
 
+// TestAliasWithOrOperator tests using registered aliases within OR expressions (issue #766)
+func TestAliasWithOrOperator(t *testing.T) {
+	validate := New()
+
+	// Test 1: Built-in alias "iscolor" with OR - alias at end
+	type Test1 struct {
+		Field string `validate:"numeric|iscolor"`
+	}
+
+	t1 := Test1{Field: "#fff"}
+	errs := validate.Struct(t1)
+	Equal(t, errs, nil) // Should pass - valid hex color
+
+	t1.Field = "123"
+	errs = validate.Struct(t1)
+	Equal(t, errs, nil) // Should pass - numeric
+
+	t1.Field = "invalid!"
+	errs = validate.Struct(t1)
+	NotEqual(t, errs, nil) // Should fail - neither numeric nor color
+
+	// Test 2: Built-in alias with OR - alias at start
+	type Test2 struct {
+		Field string `validate:"iscolor|numeric"`
+	}
+
+	t2 := Test2{Field: "456"}
+	errs = validate.Struct(t2)
+	Equal(t, errs, nil) // Should pass - numeric
+
+	t2.Field = "rgb(255,0,0)"
+	errs = validate.Struct(t2)
+	Equal(t, errs, nil) // Should pass - valid rgb color
+
+	// Test 3: Custom alias with OR
+	validate.RegisterAlias("customnum", "numeric")
+
+	type Test3 struct {
+		Field string `validate:"alpha|customnum"`
+	}
+
+	t3 := Test3{Field: "789"}
+	errs = validate.Struct(t3)
+	Equal(t, errs, nil) // Should pass - numeric via alias
+
+	t3.Field = "abc"
+	errs = validate.Struct(t3)
+	Equal(t, errs, nil) // Should pass - alpha
+
+	// Test 4: Multiple aliases in OR
+	validate.RegisterAlias("customalpha", "alpha")
+
+	type Test4 struct {
+		Field string `validate:"customnum|customalpha"`
+	}
+
+	t4 := Test4{Field: "xyz"}
+	errs = validate.Struct(t4)
+	Equal(t, errs, nil) // Should pass - alpha via alias
+
+	// Test 5: Three-way OR with alias in middle
+	type Test5 struct {
+		Field string `validate:"alpha|customnum|email"`
+	}
+
+	t5 := Test5{Field: "test@example.com"}
+	errs = validate.Struct(t5)
+	Equal(t, errs, nil) // Should pass - email
+
+	// Test 6: Alias with parameter
+	validate.RegisterAlias("customgt5", "gt=5")
+
+	type Test6 struct {
+		Field int `validate:"eq=0|customgt5"`
+	}
+
+	t6 := Test6{Field: 0}
+	errs = validate.Struct(t6)
+	Equal(t, errs, nil) // Should pass - eq=0
+
+	t6.Field = 10
+	errs = validate.Struct(t6)
+	Equal(t, errs, nil) // Should pass - gt=5 via alias
+
+	t6.Field = 3
+	errs = validate.Struct(t6)
+	NotEqual(t, errs, nil) // Should fail - not 0 and not > 5
+
+	// Test 7: Another built-in alias with OR (country_code)
+	type Test7 struct {
+		Field string `validate:"numeric|country_code"`
+	}
+
+	t7 := Test7{Field: "US"}
+	errs = validate.Struct(t7)
+	Equal(t, errs, nil) // Should pass - valid country code
+}
+
 func TestNilValidator(t *testing.T) {
 	type TestStruct struct {
 		Test string `validate:"required"`