Port in expiration parsing into composable schema DSL

pkg/composableschemadsl/dslshape/dslshape.go

@@ -11,6 +11,7 @@ const (
 	NodeTypeError   NodeType = iota // error occurred; value is text of error
 	NodeTypeFile                    // The file root node
 	NodeTypeComment                 // A single or multiline comment
+	NodeTypeUseFlag                 // A use flag
 
 	NodeTypeDefinition       // A definition.
 	NodeTypeCaveatDefinition // A caveat definition.
@@ -24,6 +25,7 @@ const (
 	NodeTypeTypeReference         // A type reference
 	NodeTypeSpecificTypeReference // A reference to a specific type.
 	NodeTypeCaveatReference       // A caveat reference under a type.
+	NodeTypeTraitReference        // A trait reference under a typr.
 
 	NodeTypeUnionExpression
 	NodeTypeIntersectExpression
@@ -75,6 +77,13 @@ const (
 	// The value of the comment, including its delimeter(s)
 	NodeCommentPredicateValue = "comment-value"
 
+	//
+	// NodeTypeUseFlag
+	//
+
+	// The name of the use flag.
+	NodeUseFlagPredicateName = "use-flag-name"
+
 	//
 	// NodeTypeDefinition
 	//
@@ -159,13 +168,23 @@ const (
 	// A caveat under a type reference.
 	NodeSpecificReferencePredicateCaveat = "caveat"
 
+	// A trait under a type reference.
+	NodeSpecificReferencePredicateTrait = "trait"
+
 	//
 	// NodeTypeCaveatReference
 	//
 
 	// The caveat name under the caveat.
 	NodeCaveatPredicateCaveat = "caveat-name"
 
+	//
+	// NodeTypeTraitReference
+	//
+
+	// The trait name under the trait.
+	NodeTraitPredicateTrait = "trait-name"
+
 	//
 	// NodeTypePermission
 	//

pkg/composableschemadsl/lexer/flaggablelexer.go

@@ -0,0 +1,59 @@
+package lexer
+
+// FlaggableLexler wraps a lexer, automatically translating tokens based on flags, if any.
+type FlaggableLexler struct {
+	lex                *Lexer                 // a reference to the lexer used for tokenization
+	enabledFlags       map[string]transformer // flags that are enabled
+	seenDefinition     bool
+	afterUseIdentifier bool
+}
+
+// NewFlaggableLexler returns a new FlaggableLexler for the given lexer.
+func NewFlaggableLexler(lex *Lexer) *FlaggableLexler {
+	return &FlaggableLexler{
+		lex:          lex,
+		enabledFlags: map[string]transformer{},
+	}
+}
+
+// Close stops the lexer from running.
+func (l *FlaggableLexler) Close() {
+	l.lex.Close()
+}
+
+// NextToken returns the next token found in the lexer.
+func (l *FlaggableLexler) NextToken() Lexeme {
+	nextToken := l.lex.nextToken()
+
+	// Look for `use somefeature`
+	if nextToken.Kind == TokenTypeIdentifier {
+		// Only allowed until we've seen a definition of some kind.
+		if !l.seenDefinition {
+			if l.afterUseIdentifier {
+				if transformer, ok := Flags[nextToken.Value]; ok {
+					l.enabledFlags[nextToken.Value] = transformer
+				}
+
+				l.afterUseIdentifier = false
+			} else {
+				l.afterUseIdentifier = nextToken.Value == "use"
+			}
+		}
+	}
+
+	if nextToken.Kind == TokenTypeKeyword && nextToken.Value == "definition" {
+		l.seenDefinition = true
+	}
+	if nextToken.Kind == TokenTypeKeyword && nextToken.Value == "caveat" {
+		l.seenDefinition = true
+	}
+
+	for _, handler := range l.enabledFlags {
+		updated, ok := handler(nextToken)
+		if ok {
+			return updated
+		}
+	}
+
+	return nextToken
+}

pkg/composableschemadsl/lexer/flaggablelexer_test.go

@@ -0,0 +1,74 @@
+package lexer
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/authzed/spicedb/pkg/composableschemadsl/input"
+)
+
+var flaggableLexerTests = []lexerTest{
+	{"use expiration", "use expiration", []Lexeme{
+		{TokenTypeKeyword, 0, "use", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "expiration", ""},
+		tEOF,
+	}},
+	{"use expiration and", "use expiration and", []Lexeme{
+		{TokenTypeKeyword, 0, "use", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "expiration", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "and", ""},
+		tEOF,
+	}},
+	{"expiration as non-keyword", "foo expiration", []Lexeme{
+		{TokenTypeIdentifier, 0, "foo", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "expiration", ""},
+		tEOF,
+	}},
+	{"and as non-keyword", "foo and", []Lexeme{
+		{TokenTypeIdentifier, 0, "foo", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "and", ""},
+		tEOF,
+	}},
+	{"invalid use flag", "use foobar", []Lexeme{
+		{TokenTypeKeyword, 0, "use", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeIdentifier, 0, "foobar", ""},
+		tEOF,
+	}},
+	{"use flag after definition", "definition use expiration", []Lexeme{
+		{TokenTypeKeyword, 0, "definition", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "use", ""},
+		{TokenTypeWhitespace, 0, " ", ""},
+		{TokenTypeKeyword, 0, "expiration", ""},
+		tEOF,
+	}},
+}
+
+func TestFlaggableLexer(t *testing.T) {
+	for _, test := range append(slices.Clone(lexerTests), flaggableLexerTests...) {
+		t.Run(test.name, func(t *testing.T) {
+			tokens := performFlaggedLex(&test)
+			if !equal(tokens, test.tokens) {
+				t.Errorf("%s: got\n\t%+v\nexpected\n\t%v", test.name, tokens, test.tokens)
+			}
+		})
+	}
+}
+
+func performFlaggedLex(t *lexerTest) (tokens []Lexeme) {
+	lexer := NewFlaggableLexler(Lex(input.Source(t.name), t.input))
+	for {
+		token := lexer.NextToken()
+		tokens = append(tokens, token)
+		if token.Kind == TokenTypeEOF || token.Kind == TokenTypeError {
+			break
+		}
+	}
+	return
+}

pkg/composableschemadsl/lexer/flags.go

@@ -0,0 +1,26 @@
+package lexer
+
+// FlagExpiration indicates that `expiration` is supported as a first-class
+// feature in the schema.
+const FlagExpiration = "expiration"
+
+type transformer func(lexeme Lexeme) (Lexeme, bool)
+
+// Flags is a map of flag names to their corresponding transformers.
+var Flags = map[string]transformer{
+	FlagExpiration: func(lexeme Lexeme) (Lexeme, bool) {
+		// `expiration` becomes a keyword.
+		if lexeme.Kind == TokenTypeIdentifier && lexeme.Value == "expiration" {
+			lexeme.Kind = TokenTypeKeyword
+			return lexeme, true
+		}
+
+		// `and` becomes a keyword.
+		if lexeme.Kind == TokenTypeIdentifier && lexeme.Value == "and" {
+			lexeme.Kind = TokenTypeKeyword
+			return lexeme, true
+		}
+
+		return lexeme, false
+	},
+}

pkg/composableschemadsl/lexer/lex_def.go

@@ -82,6 +82,18 @@ var keywords = map[string]struct{}{
 	"all":        {},
 	"any":        {},
 	"partial":    {},
+	"use":        {},
+	"expiration": {},
+	// Parking lot for future keywords
+	"and":     {},
+	"or":      {},
+	"not":     {},
+	"under":   {},
+	"static":  {},
+	"if":      {},
+	"where":   {},
+	"private": {},
+	"public":  {},
 }
 
 // IsKeyword returns whether the specified input string is a reserved keyword.

pkg/composableschemadsl/lexer/lex_test.go

@@ -66,6 +66,18 @@ var lexerTests = []lexerTest{
 	{"keyword", "all", []Lexeme{{TokenTypeKeyword, 0, "all", ""}, tEOF}},
 	{"keyword", "nil", []Lexeme{{TokenTypeKeyword, 0, "nil", ""}, tEOF}},
 	{"keyword", "partial", []Lexeme{{TokenTypeKeyword, 0, "partial", ""}, tEOF}},
+	{"keyword", "use", []Lexeme{{TokenTypeKeyword, 0, "use", ""}, tEOF}},
+	{"keyword", "expiration", []Lexeme{{TokenTypeKeyword, 0, "expiration", ""}, tEOF}},
+	{"keyword", "and", []Lexeme{{TokenTypeKeyword, 0, "and", ""}, tEOF}},
+	{"keyword", "or", []Lexeme{{TokenTypeKeyword, 0, "or", ""}, tEOF}},
+	{"keyword", "not", []Lexeme{{TokenTypeKeyword, 0, "not", ""}, tEOF}},
+	{"keyword", "under", []Lexeme{{TokenTypeKeyword, 0, "under", ""}, tEOF}},
+	{"keyword", "static", []Lexeme{{TokenTypeKeyword, 0, "static", ""}, tEOF}},
+	{"keyword", "if", []Lexeme{{TokenTypeKeyword, 0, "if", ""}, tEOF}},
+	{"keyword", "where", []Lexeme{{TokenTypeKeyword, 0, "where", ""}, tEOF}},
+	{"keyword", "private", []Lexeme{{TokenTypeKeyword, 0, "private", ""}, tEOF}},
+	{"keyword", "public", []Lexeme{{TokenTypeKeyword, 0, "public", ""}, tEOF}},
+
 	{"identifier", "define", []Lexeme{{TokenTypeIdentifier, 0, "define", ""}, tEOF}},
 	{"typepath", "foo/bar", []Lexeme{
 		{TokenTypeIdentifier, 0, "foo", ""},