lexicon: progress on validation

atproto/lexicon/interop_record_test.go

···
 		if err != nil {
 			t.Fatal(err)
 		}
-
-		assert.Error(cat.ValidateRecord(d, "example.lexicon.record"))
+		err = cat.ValidateRecord(d, "example.lexicon.record")
+		if err == nil {
+			fmt.Println("   FAIL")
+		}
+		assert.Error(err)
 	}
 }

atproto/lexicon/language.go

···
 
 	"github.com/bluesky-social/indigo/atproto/data"
 	"github.com/bluesky-social/indigo/atproto/syntax"
+
+	"github.com/rivo/uniseg"
 )
 
 // Serialization helper for top-level Lexicon schema JSON objects (files)
···
 		return fmt.Errorf("expected an integer")
 	}
 	v := int(v64)
-	// TODO: enforce enum
 	if s.Const != nil && v != *s.Const {
 		return fmt.Errorf("integer val didn't match constant (%d): %d", *s.Const, v)
 	}
 	if (s.Minimum != nil && v < *s.Minimum) || (s.Maximum != nil && v > *s.Maximum) {
 		return fmt.Errorf("integer val outside specified range: %d", v)
+	}
+	if len(s.Enum) != 0 {
+		inEnum := false
+		for _, e := range s.Enum {
+			if e == v {
+				inEnum = true
+				break
+			}
+		}
+		if !inEnum {
+			return fmt.Errorf("integer val not in required enum: %d", v)
+		}
 	}
 	return nil
 }
···
 	if !ok {
 		return fmt.Errorf("expected a string: %v", reflect.TypeOf(d))
 	}
-	// TODO: enforce enum
 	if s.Const != nil && v != *s.Const {
 		return fmt.Errorf("string val didn't match constant (%s): %s", *s.Const, v)
 	}
···
 	if (s.MinLength != nil && len(v) < *s.MinLength) || (s.MaxLength != nil && len(v) > *s.MaxLength) {
 		return fmt.Errorf("string length outside specified range: %d", len(v))
 	}
-	// TODO: grapheme length
+	if len(s.Enum) != 0 {
+		inEnum := false
+		for _, e := range s.Enum {
+			if e == v {
+				inEnum = true
+				break
+			}
+		}
+		if !inEnum {
+			return fmt.Errorf("string val not in required enum: %s", v)
+		}
+	}
+	if s.MinGraphemes != nil || s.MaxGraphemes != nil {
+		lenG := uniseg.GraphemeClusterCount(v)
+		if (s.MinGraphemes != nil && lenG < *s.MinGraphemes) || (s.MaxGraphemes != nil && lenG > *s.MaxGraphemes) {
+			return fmt.Errorf("string length (graphemes) outside specified range: %d", lenG)
+		}
+	}
 	if s.Format != nil {
 		switch *s.Format {
 		case "at-identifier":
···
 	if !ok {
 		return fmt.Errorf("expected a blob")
 	}
-	// TODO: validate accept mimetype
+	if len(s.Accept) > 0 {
+		typeOk := false
+		for _, pat := range s.Accept {
+			if acceptableMimeType(pat, v.MimeType) {
+				typeOk = true
+				break
+			}
+		}
+		if !typeOk {
+			return fmt.Errorf("blob mimetype doesn't match accepted: %s", v.MimeType)
+		}
+	}
 	if s.MaxSize != nil && int(v.Size) > *s.MaxSize {
 		return fmt.Errorf("blob size too large: %d", v.Size)
 	}
···
 	return nil
 }
 
+// XXX: implementation?
 func (s *SchemaParams) Validate(d any) error {
 	return nil
 }
···
 type SchemaToken struct {
 	Type        string  `json:"type,const=token"`
 	Description *string `json:"description,omitempty"`
+	// the fully-qualified identifier of this token
+	Name string
 }
 
 func (s *SchemaToken) CheckSchema() error {
+	return nil
+}
+
+func (s *SchemaToken) Validate(d any) error {
+	str, ok := d.(string)
+	if !ok {
+		return fmt.Errorf("expected a string for token, got: %s", reflect.TypeOf(d))
+	}
+	if s.Name == "" {
+		return fmt.Errorf("token name was not populated at parse time")
+	}
+	if str != s.Name {
+		return fmt.Errorf("token name did not match expected: %s", str)
+	}
 	return nil
 }
 

atproto/lexicon/lexicon.go

···
 			if frag != "main" {
 				return fmt.Errorf("record, query, procedure, and subscription types must be 'main', not: %s", frag)
 			}
+		case SchemaToken:
+			token := def.Inner.(SchemaToken)
+			token.Name = name
+			def.Inner = token
 		}
 		s := Schema{
 			ID:       name,
···
 		}
 		return c.validateData(next.Def, d)
 	case SchemaUnion:
-		//return fmt.Errorf("XXX: union validation not implemented")
-		return nil
+		return c.validateUnion(v, d)
 	case SchemaUnknown:
 		return v.Validate(d)
 	case SchemaToken:
-		str, ok := d.(string)
-		if !ok {
-			return fmt.Errorf("expected a string for token, got: %s", reflect.TypeOf(d))
-		}
-		// XXX: token validation not implemented
-		_ = str
-		return nil
+		return v.Validate(d)
 	default:
 		return fmt.Errorf("unhandled schema type: %s", reflect.TypeOf(v))
 	}
···
 	}
 	return nil
 }
+
+func (c *Catalog) validateUnion(s SchemaUnion, d any) error {
+	closed := s.Closed != nil && *s.Closed == true
+	for _, ref := range s.Refs {
+		def, err := c.Resolve(ref)
+		if err != nil {
+			// TODO: how to actually handle unknown defs?
+			return err
+		}
+		if err = c.validateData(def.Def, d); nil == err { // if success
+			return nil
+		}
+	}
+	if closed {
+		return fmt.Errorf("data did not match any variant of closed union")
+	}
+	// TODO: anything matches if an open union?
+	return nil
+}

atproto/lexicon/mimetype.go

···
+package lexicon
+
+import (
+	"strings"
+)
+
+// checks if val matches pattern, with optional trailing glob on pattern. case-sensitive.
+func acceptableMimeType(pattern, val string) bool {
+	if val == "" || pattern == "" {
+		return false
+	}
+	if strings.HasSuffix(pattern, "*") {
+		prefix := pattern[:len(pattern)-1]
+		return strings.HasPrefix(val, prefix)
+	} else {
+		return pattern == val
+	}
+	return false
+}

atproto/lexicon/mimetype_test.go

···
+package lexicon
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAcceptableMimeType(t *testing.T) {
+	assert := assert.New(t)
+
+	assert.True(acceptableMimeType("image/*", "image/png"))
+	assert.True(acceptableMimeType("text/plain", "text/plain"))
+
+	assert.False(acceptableMimeType("image/*", "text/plain"))
+	assert.False(acceptableMimeType("text/plain", "image/png"))
+	assert.False(acceptableMimeType("text/plain", ""))
+	assert.False(acceptableMimeType("", "text/plain"))
+
+	// TODO: application/json, application/json+thing
+}