array.go

package check

import "fmt"

// ArraySchema validates slices/arrays where each element matches an inner schema.
type ArraySchema struct {
	optional  bool
	element   Schema
	minLen    *int
	maxLen    *int
	customFns []func([]any) error
}

func NewArray(element Schema) *ArraySchema {
	return &ArraySchema{element: element}
}

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

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

func (s *ArraySchema) MinLength(n int) *ArraySchema {
	s = s.clone()
	s.minLen = &n
	return s
}

func (s *ArraySchema) MaxLength(n int) *ArraySchema {
	s = s.clone()
	s.maxLen = &n
	return s
}

func (s *ArraySchema) Custom(fn func([]any) error) *ArraySchema {
	s = s.clone()
	s.customFns = append(s.customFns, fn)
	return s
}

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

func (s *ArraySchema) Parse(value any) (any, error) {
	errs := s.Validate(value)
	if len(errs) > 0 {
		return nil, ValidationErrors(errs)
	}
	if value == nil {
		return nil, nil
	}
	arr := toSlice(value)
	out := make([]any, len(arr))
	for i, item := range arr {
		parsed, _ := s.element.Parse(item)
		out[i] = parsed
	}
	return out, nil
}

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

	arr := toSlice(value)
	if arr == nil {
		return []ValidationError{{Message: fmt.Sprintf("expected array, got %T", value), Value: value}}
	}

	var errs []ValidationError

	if s.minLen != nil && len(arr) < *s.minLen {
		errs = append(errs, ValidationError{
			Message: fmt.Sprintf("array must have at least %d item(s) (got %d)", *s.minLen, len(arr)),
			Value:   len(arr),
		})
	}

	if s.maxLen != nil && len(arr) > *s.maxLen {
		errs = append(errs, ValidationError{
			Message: fmt.Sprintf("array must have at most %d item(s) (got %d)", *s.maxLen, len(arr)),
			Value:   len(arr),
		})
	}

	for i, item := range arr {
		itemErrs := s.element.Validate(item)
		errs = append(errs, prefixErrors(fmt.Sprintf("[%d]", i), itemErrs)...)
	}

	for _, fn := range s.customFns {
		if err := fn(arr); err != nil {
			errs = append(errs, ValidationError{Message: err.Error(), Value: arr})
		}
	}

	return errs
}

// toSlice attempts to convert any value to []any.
func toSlice(v any) []any {
	switch val := v.(type) {
	case []any:
		return val
	case []string:
		out := make([]any, len(val))
		for i, s := range val {
			out[i] = s
		}
		return out
	case []int:
		out := make([]any, len(val))
		for i, n := range val {
			out[i] = n
		}
		return out
	case []float64:
		out := make([]any, len(val))
		for i, f := range val {
			out[i] = f
		}
		return out
	case []bool:
		out := make([]any, len(val))
		for i, b := range val {
			out[i] = b
		}
		return out
	}
	return nil
}