union.go

package check

import "fmt"

// UnionSchema validates that a value matches at least one of the given schemas.
type UnionSchema struct {
	optional bool
	schemas  []Schema
}

func NewUnion(schemas ...Schema) *UnionSchema {
	return &UnionSchema{schemas: schemas}
}

// clone returns a copy of this schema to preserve immutability in chains.
func (s *UnionSchema) clone() *UnionSchema {
	copy := *s
	if s.schemas != nil {
		copySchemas := make([]Schema, len(s.schemas))
		for i, v := range s.schemas {
			copySchemas[i] = v
		}
		copy.schemas = copySchemas
	}
	return &copy
}

func (s *UnionSchema) Optional() *UnionSchema {
	s = s.clone()
	s.optional = true
	return s
}

func (s *UnionSchema) IsOptional() bool { return s.optional }

func (s *UnionSchema) Parse(value any) (any, error) {
	if value == nil {
		if s.optional {
			return nil, nil
		}
		return nil, ValidationErrors([]ValidationError{{Message: "required value is missing"}})
	}

	for _, schema := range s.schemas {
		if result, err := schema.Parse(value); err == nil {
			return result, nil
		}
	}

	return nil, ValidationErrors([]ValidationError{{
		Message: fmt.Sprintf("value does not match any of the %d schemas in union", len(s.schemas)),
		Value:   value,
	}})
}

func (s *UnionSchema) Validate(value any) []ValidationError {
	if value == nil {
		if s.optional {
			return nil
		}
		return []ValidationError{{Message: "required value is missing"}}
	}

	for _, schema := range s.schemas {
		if errs := schema.Validate(value); len(errs) == 0 {
			return nil
		}
	}

	return []ValidationError{{
		Message: fmt.Sprintf("value does not match any of the %d schemas in union", len(s.schemas)),
		Value:   value,
	}}
}