0
0
package apigen
import (
"cmp"
"fmt"
"math"
"regexp"
"slices"
"sort"
"strings"
"unicode/utf8"
)
type Issue struct {
Path string
Message string
}
func (i Issue) String() string {
path := i.Path
path = cmp.Or(path, "(root)")
return path + ": " + i.Message
}
const (
msgMissing = "missing required field"
msgUnknown = "unknown field"
)
func (m *Model) Validate(typeName string, value any) []Issue {
s, ok := m.Named[typeName]
if !ok {
return []Issue{{Message: fmt.Sprintf("no type named %s", typeName)}}
}
var out []Issue
check(s, value, "", &out)
return out
}
func joinPath(path, key string) string {
if path == "" {
return key
}
return path + "." + key
}
func describe(v any) string {
switch v.(type) {
case nil:
return "null"
case map[string]any:
return "an object"
case []any:
return "an array"
case string:
return "a string"
case bool:
return "a boolean"
case float64:
return "a number"
default:
return fmt.Sprintf("%T", v)
}
}
func expected(want string, got any) string {
return fmt.Sprintf("expected %s, got %s", want, describe(got))
}
func check(s *Schema, value any, path string, out *[]Issue) {
add := func(p, msg string) { *out = append(*out, Issue{Path: p, Message: msg}) }
switch s.Type {
case TypeObject:
obj, ok := value.(map[string]any)
if !ok {
add(path, expected("an object", value))
return
}
if s.PreserveUnknown {
return
}
if s.AdditionalProperties != nil {
keys := make([]string, 0, len(obj))
for k := range obj {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
check(s.AdditionalProperties, obj[k], joinPath(path, k), out)
}
return
}
if !s.Closed {
return
}
declared := map[string]bool{}
for _, p := range s.Properties {
declared[p.Name] = true
v, present := obj[p.Name]
if !present {
if p.Required {
add(joinPath(path, p.Name), msgMissing)
}
continue
}
check(p.Schema, v, joinPath(path, p.Name), out)
}
var unknown []string
for k := range obj {
if !declared[k] {
unknown = append(unknown, k)
}
}
sort.Strings(unknown)
for _, k := range unknown {
add(joinPath(path, k), msgUnknown)
}
case TypeArray:
arr, ok := value.([]any)
if !ok {
add(path, expected("an array", value))
return
}
for i, v := range arr {
check(s.Items, v, fmt.Sprintf("%s[%d]", path, i), out)
}
checkList(s, arr, path, add)
case TypeString:
str, ok := value.(string)
if !ok {
add(path, expected("a string", value))
return
}
if s.MaxLength != nil && int64(utf8.RuneCountInString(str)) > *s.MaxLength {
add(path, fmt.Sprintf("%d characters is over the maxLength %d", utf8.RuneCountInString(str), *s.MaxLength))
}
if s.Pattern != "" {
if re, err := regexp.Compile(s.Pattern); err == nil && !re.MatchString(str) {
add(path, fmt.Sprintf("%q does not match the pattern %s", str, s.Pattern))
}
}
if len(s.Enum) == 0 {
return
}
if slices.Contains(s.Enum, str) {
return
}
add(path, fmt.Sprintf("%q is not one of %s", str, strings.Join(s.Enum, ", ")))
case TypeInteger:
n, ok := value.(float64)
if !ok || n != math.Trunc(n) || math.IsInf(n, 0) {
add(path, expected("an integer", value))
return
}
if s.Minimum != nil && n < float64(*s.Minimum) {
add(path, fmt.Sprintf("%v is below the minimum %d", n, *s.Minimum))
}
if s.Maximum != nil && n > float64(*s.Maximum) {
add(path, fmt.Sprintf("%v is above the maximum %d", n, *s.Maximum))
}
case TypeBoolean:
if _, ok := value.(bool); !ok {
add(path, expected("a boolean", value))
}
default:
add(path, fmt.Sprintf("schema type %q has no validator", s.Type))
}
}
func checkList(s *Schema, arr []any, path string, add func(p, msg string)) {
switch s.ListType {
case ListTypeSet:
seen := map[any]bool{}
for i, v := range arr {
if seen[v] {
add(fmt.Sprintf("%s[%d]", path, i), "duplicate entry in a set")
}
seen[v] = true
}
case ListTypeMap:
seen := map[string]bool{}
for i, v := range arr {
obj, ok := v.(map[string]any)
if !ok {
continue
}
var key strings.Builder
for _, k := range s.ListMapKeys {
key.WriteString(fmt.Sprintf("%v\x00", obj[k]))
}
if seen[key.String()] {
add(fmt.Sprintf("%s[%d]", path, i), "duplicate map key "+strings.Join(s.ListMapKeys, ","))
}
seen[key.String()] = true
}
}
}