map_schema.go

package check

import "fmt"

// MapSchema validates map[string]any where all keys match a key schema
// and all values match a value schema.
type MapSchema struct {
	optional bool
	key      Schema
	value    Schema
	minLen   *int
	maxLen   *int
}

func NewMap(key, value Schema) *MapSchema {
	return &MapSchema{key: key, value: value}
}

// clone returns a copy of this schema to preserve immutability in chains.
func (s *MapSchema) clone() *MapSchema {
	copy := *s
	return &copy
}

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

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

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

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

func (s *MapSchema) Parse(value any) (any, error) {
	errs := s.Validate(value)
	if len(errs) > 0 {
		return nil, ValidationErrors(errs)
	}
	if value == nil {
		return nil, nil
	}
	return value, nil
}

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

	m, ok := value.(map[string]any)
	if !ok {
		return []ValidationError{{Message: fmt.Sprintf("expected map, got %T", value), Value: value}}
	}

	var errs []ValidationError

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

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

	for k, v := range m {
		keyErrs := s.key.Validate(k)
		errs = append(errs, prefixErrors(k+"(key)", keyErrs)...)
		valErrs := s.value.Validate(v)
		errs = append(errs, prefixErrors(k, valErrs)...)
	}

	return errs
}