object.go

package check

import (
	"fmt"
	"sort"
)

// ObjectSchema validates map[string]any objects with named fields.
type ObjectSchema struct {
	optional bool
	fields   map[string]Schema
	strict   bool // if true, disallow extra keys
}

func NewObject(fields map[string]Schema) *ObjectSchema {
	return &ObjectSchema{fields: fields}
}

// clone returns a copy of this schema to preserve immutability in chains.
func (s *ObjectSchema) clone() *ObjectSchema {
	copy := *s
	if s.fields != nil {
		copyFields := make(map[string]Schema)
		for k, v := range s.fields {
			copyFields[k] = v
		}
		copy.fields = copyFields
	}
	return &copy
}

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

// Strict rejects objects with keys not defined in the schema.
func (s *ObjectSchema) Strict() *ObjectSchema {
	s = s.clone()
	s.strict = true
	return s
}

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

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

	// Safe: Validate already confirmed it's a map[string]any
	obj := value.(map[string]any)
	out := make(map[string]any, len(s.fields))

	for key, schema := range s.fields {
		val := obj[key]
		parsed, _ := schema.Parse(val)
		if parsed != nil || val != nil {
			out[key] = parsed
		}
	}
	return out, nil
}

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

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

	var errs []ValidationError

	// Validate each defined field
	for key, schema := range s.fields {
		val, exists := obj[key]
		if !exists {
			val = nil
		}
		fieldErrs := schema.Validate(val)
		errs = append(errs, prefixErrors(key, fieldErrs)...)
	}

	// Strict mode: reject extra keys
	if s.strict {
		extras := []string{}
		for key := range obj {
			if _, defined := s.fields[key]; !defined {
				extras = append(extras, key)
			}
		}
		sort.Strings(extras)
		for _, key := range extras {
			errs = append(errs, ValidationError{
				Path:    key,
				Message: "unknown field",
				Value:   obj[key],
			})
		}
	}

	return errs
}