Skip to content

Commit e92f1ec

Browse files
josephschorrjosephschorr
authored
Add parsing support for expiration (#51)
* Add buf command and move to v1.40.0 of the API * Add support for expiration in relationship parsing and string generation
1 parent 5a360ce commit e92f1ec

File tree

10 files changed

+256
-385
lines changed

10 files changed

+256
-385
lines changed

‎buf.gen.yaml

+1-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ plugins:
88
- "generate_dependencies"
99
- "optimize_code_size"
1010
inputs:
11-
- module: "buf.build/authzed/api:v1.38.0"
11+
- module: "buf.build/authzed/api:v1.40.0"
1212
paths:
1313
- "authzed/api/v0"
1414
- git_repo: "https://github.com/authzed/spicedb"

‎package.json

+2-1
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,8 @@
9797
"cy:run": "cypress run --browser chrome",
9898
"cy:open": "cypress open",
9999
"update:spicedb": "./scripts/update-spicedb.sh",
100-
"update:zed": "./scripts/update-zed.sh"
100+
"update:zed": "./scripts/update-zed.sh",
101+
"update:buf": "buf generate"
101102
},
102103
"browserslist": {
103104
"production": [

‎src/spicedb-common/components/graph/typeset.ts

+2-3
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,11 @@
1-
import { RelationTuple as Relationship } from "../../protodefs/core/v1/core";
21
import {
3-
ObjectOrCaveatDefinition,
42
ParsedObjectDefinition,
53
ParsedPermission,
64
ParsedRelation,
75
ParsedSchema,
86
TextRange,
97
} from "../../parsers/dsl/dsl";
8+
import { RelationTuple as Relationship } from "../../protodefs/core/v1/core";
109

1110
export interface RelationLink {
1211
key: string;
@@ -35,7 +34,7 @@ export class TypeSet {
3534
);
3635

3736
this.types = Object.fromEntries(
38-
objectDefs.map((def: ObjectOrCaveatDefinition, index: number) => {
37+
objectDefs.map((def: ParsedObjectDefinition, index: number) => {
3938
return [def.name, new TypeHandle(def as ParsedObjectDefinition, index)];
4039
}),
4140
);

‎src/spicedb-common/parsers/dsl/dsl.test.ts

+74-14
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
import { describe, expect, it } from "vitest";
2+
import { assert } from "../../../test/utils";
13
import {
24
ParsedArrowExpression,
35
ParsedBinaryExpression,
@@ -6,10 +8,9 @@ import {
68
ParsedNilExpression,
79
ParsedObjectDefinition,
810
ParsedRelationRefExpression,
11+
ParsedUseFlag,
912
parseSchema,
1013
} from "./dsl";
11-
import { assert } from "../../../test/utils";
12-
import { describe, it, expect } from "vitest";
1314

1415
describe("parsing", () => {
1516
it("parses empty schema", () => {
@@ -19,28 +20,54 @@ describe("parsing", () => {
1920
expect(parsed?.definitions?.length).toEqual(0);
2021
});
2122

23+
it("parses use flag", () => {
24+
const schema = `use expiration`;
25+
const parsed = parseSchema(schema);
26+
27+
expect(parsed?.definitions?.length).toEqual(1);
28+
expect((parsed?.definitions[0] as ParsedUseFlag).featureName).toEqual(
29+
"expiration",
30+
);
31+
});
32+
33+
it("parses use flag and definition", () => {
34+
const schema = `use expiration
35+
36+
definition foo {}
37+
`;
38+
const parsed = parseSchema(schema);
39+
40+
expect(parsed?.definitions?.length).toEqual(2);
41+
});
42+
2243
it("parses empty definition", () => {
2344
const schema = `definition foo {}`;
2445
const parsed = parseSchema(schema);
2546

2647
expect(parsed?.definitions?.length).toEqual(1);
27-
expect(parsed?.definitions[0].name).toEqual("foo");
48+
expect((parsed?.definitions[0] as ParsedObjectDefinition).name).toEqual(
49+
"foo",
50+
);
2851
});
2952

3053
it("parses empty definition with multiple path segements", () => {
3154
const schema = `definition foo/bar/baz {}`;
3255
const parsed = parseSchema(schema);
3356

3457
expect(parsed?.definitions?.length).toEqual(1);
35-
expect(parsed?.definitions[0].name).toEqual("foo/bar/baz");
58+
expect((parsed?.definitions[0] as ParsedObjectDefinition).name).toEqual(
59+
"foo/bar/baz",
60+
);
3661
});
3762

3863
it("parses basic caveat", () => {
3964
const schema = `caveat foo (someParam string, anotherParam int) { someParam == 42 }`;
4065
const parsed = parseSchema(schema);
4166

4267
expect(parsed?.definitions?.length).toEqual(1);
43-
expect(parsed?.definitions[0].name).toEqual("foo");
68+
expect((parsed?.definitions[0] as ParsedCaveatDefinition).name).toEqual(
69+
"foo",
70+
);
4471

4572
const definition = parsed?.definitions[0] as ParsedCaveatDefinition;
4673
expect(definition.parameters.map((p) => p.name)).toEqual([
@@ -56,8 +83,9 @@ describe("parsing", () => {
5683
const parsed = parseSchema(schema);
5784

5885
expect(parsed?.definitions?.length).toEqual(1);
59-
expect(parsed?.definitions[0].name).toEqual("foo");
60-
86+
expect((parsed?.definitions[0] as ParsedCaveatDefinition).name).toEqual(
87+
"foo",
88+
);
6189
const definition = parsed?.definitions[0] as ParsedCaveatDefinition;
6290
expect(definition.parameters.map((p) => p.name)).toEqual([
6391
"someParam",
@@ -70,7 +98,9 @@ describe("parsing", () => {
7098
const parsed = parseSchema(schema);
7199

72100
expect(parsed?.definitions?.length).toEqual(1);
73-
expect(parsed?.definitions[0].name).toEqual("foo/bar");
101+
expect((parsed?.definitions[0] as ParsedObjectDefinition).name).toEqual(
102+
"foo/bar",
103+
);
74104
});
75105

76106
it("parses multiple definitions", () => {
@@ -80,8 +110,37 @@ describe("parsing", () => {
80110
const parsed = parseSchema(schema);
81111

82112
expect(parsed?.definitions?.length).toEqual(2);
83-
expect(parsed?.definitions[0].name).toEqual("foo");
84-
expect(parsed?.definitions[1].name).toEqual("bar");
113+
114+
expect((parsed?.definitions[0] as ParsedCaveatDefinition).name).toEqual(
115+
"foo",
116+
);
117+
expect((parsed?.definitions[1] as ParsedCaveatDefinition).name).toEqual(
118+
"bar",
119+
);
120+
});
121+
122+
it("parses relation with expiration", () => {
123+
const schema = `
124+
use expiration
125+
126+
definition foo {
127+
relation viewer: user with expiration
128+
}`;
129+
const parsed = parseSchema(schema);
130+
131+
expect(parsed?.definitions?.length).toEqual(2);
132+
});
133+
134+
it("parses relation with caveat and expiration", () => {
135+
const schema = `
136+
use expiration
137+
138+
definition foo {
139+
relation viewer: user with somecaveat and expiration
140+
}`;
141+
const parsed = parseSchema(schema);
142+
143+
expect(parsed?.definitions?.length).toEqual(2);
85144
});
86145

87146
it("parses definition with relation", () => {
@@ -356,7 +415,8 @@ describe("parsing", () => {
356415
});
357416

358417
it("full", () => {
359-
const schema = `definition user {}
418+
const schema = `use expiration
419+
definition user {}
360420
361421
caveat somecaveat(somecondition int) {
362422
somecondition == 42
@@ -367,14 +427,14 @@ describe("parsing", () => {
367427
*/
368428
definition document {
369429
relation writer: user
370-
relation reader: user | user with somecaveat
430+
relation reader: user | user with somecaveat | user with expiration | user with somecaveat and expiration
371431
372432
permission writer = writer
373433
permission read = reader + writer // has both
374434
}`;
375435

376436
const parsed = parseSchema(schema);
377-
expect(parsed?.definitions?.length).toEqual(3);
437+
expect(parsed?.definitions?.length).toEqual(4);
378438
});
379439

380440
it("full with wildcard", () => {
@@ -394,7 +454,7 @@ describe("parsing", () => {
394454
const parsed = parseSchema(schema);
395455
expect(parsed?.definitions?.length).toEqual(2);
396456
const documentDef = parsed?.definitions.find(
397-
(def) => def.name === "document",
457+
(def) => (def as ParsedObjectDefinition).name === "document",
398458
) as ParsedObjectDefinition;
399459
expect(documentDef?.relations.length).toEqual(2);
400460
expect(documentDef?.permissions.length).toEqual(2);

‎src/spicedb-common/parsers/dsl/dsl.ts

+66-12
Original file line numberDiff line numberDiff line change
@@ -50,17 +50,18 @@ export const parseSchema = (value: string): ParsedSchema | undefined => {
5050
};
5151

5252
/**
53-
* ObjectOrCaveatDefinition are the types of definitions found at the root of a schema.
53+
* TopLevelDefinition are the types of definitions found at the root of a schema.
5454
*/
55-
export type ObjectOrCaveatDefinition =
55+
export type TopLevelDefinition =
5656
| ParsedObjectDefinition
57-
| ParsedCaveatDefinition;
57+
| ParsedCaveatDefinition
58+
| ParsedUseFlag;
5859

5960
/**
6061
* parse performs a parse on the schema string, returning the full parse result.
6162
*/
6263
export function parse(input: string): ParseResult {
63-
const result = whitespace.then(definitionOrCaveat.atLeast(0)).parse(input);
64+
const result = whitespace.then(topLevel.atLeast(0)).parse(input);
6465
return {
6566
error: !result.status
6667
? {
@@ -73,7 +74,7 @@ export function parse(input: string): ParseResult {
7374
? {
7475
kind: "schema",
7576
stringValue: input,
76-
definitions: (result as Parsimmon.Success<ObjectOrCaveatDefinition[]>)
77+
definitions: (result as Parsimmon.Success<TopLevelDefinition[]>)
7778
.value,
7879
}
7980
: undefined,
@@ -138,7 +139,7 @@ export function flatMapExpression<T>(
138139
*/
139140
export interface ReferenceNode {
140141
node: ParsedRelationRefExpression | TypeRef | undefined;
141-
def: ObjectOrCaveatDefinition;
142+
def: TopLevelDefinition;
142143
}
143144

144145
/**
@@ -151,7 +152,7 @@ export function findReferenceNode(
151152
columnPosition: number,
152153
): ReferenceNode | undefined {
153154
const found = schema.definitions
154-
.map((def: ObjectOrCaveatDefinition) => {
155+
.map((def: TopLevelDefinition) => {
155156
if (!rangeContains(def, lineNumber, columnPosition)) {
156157
return undefined;
157158
}
@@ -177,7 +178,7 @@ export function mapParsedSchema(
177178
return;
178179
}
179180

180-
schema.definitions.forEach((def: ObjectOrCaveatDefinition) => {
181+
schema.definitions.forEach((def: TopLevelDefinition) => {
181182
mapParseNodes(def, mapper);
182183
});
183184
}
@@ -189,7 +190,13 @@ export function mapParsedSchema(
189190
export interface ParsedSchema {
190191
kind: "schema";
191192
stringValue: string;
192-
definitions: ObjectOrCaveatDefinition[];
193+
definitions: TopLevelDefinition[];
194+
}
195+
196+
export interface ParsedUseFlag {
197+
kind: "use";
198+
featureName: string;
199+
range: TextRange;
193200
}
194201

195202
export interface ParsedCaveatDefinition {
@@ -291,6 +298,12 @@ export interface TypeRef {
291298
relationName: string | undefined;
292299
wildcard: boolean;
293300
withCaveat: WithCaveat | undefined;
301+
withExpiration: WithExpiration | undefined;
302+
range: TextRange;
303+
}
304+
305+
export interface WithExpiration {
306+
kind: "withexpiration";
294307
range: TextRange;
295308
}
296309

@@ -307,6 +320,7 @@ export interface TypeExpr {
307320
}
308321

309322
export type ParsedNode =
323+
| ParsedUseFlag
310324
| ParsedCaveatDefinition
311325
| ParsedCaveatParameter
312326
| ParsedCaveatParameterTypeRef
@@ -378,14 +392,40 @@ const dot = lexeme(string("."));
378392
const terminator = newline.or(semicolon);
379393

380394
// Type reference and expression.
395+
396+
const andExpiration = Parsimmon.seqMap(
397+
Parsimmon.index,
398+
seq(lexeme(string("and")), lexeme(string("expiration"))),
399+
Parsimmon.index,
400+
function (startIndex, data, endIndex) {
401+
return {
402+
kind: "withexpiration",
403+
range: { startIndex: startIndex, endIndex: endIndex },
404+
};
405+
},
406+
);
407+
381408
const withCaveat = Parsimmon.seqMap(
382409
Parsimmon.index,
383-
seq(lexeme(string("with")), path),
410+
seq(lexeme(string("with")), path, andExpiration.atMost(1)),
384411
Parsimmon.index,
385412
function (startIndex, data, endIndex) {
386413
return {
387414
kind: "withcaveat",
388415
path: data[1],
416+
withExpiration: data.length > 2 ? data[2] : null,
417+
range: { startIndex: startIndex, endIndex: endIndex },
418+
};
419+
},
420+
);
421+
422+
const withExpiration = Parsimmon.seqMap(
423+
Parsimmon.index,
424+
seq(lexeme(string("with")), lexeme(string("expiration"))),
425+
Parsimmon.index,
426+
function (startIndex, data, endIndex) {
427+
return {
428+
kind: "withexpiration",
389429
range: { startIndex: startIndex, endIndex: endIndex },
390430
};
391431
},
@@ -397,7 +437,7 @@ const typeRef = Parsimmon.seqMap(
397437
seq(path, colon, lexeme(string("*"))).or(
398438
seq(path, hash.then(identifier).atMost(1)),
399439
),
400-
withCaveat.atMost(1),
440+
withCaveat.or(withExpiration).atMost(1),
401441
),
402442
Parsimmon.index,
403443
function (startIndex, data, endIndex) {
@@ -612,6 +652,20 @@ const relation = Parsimmon.seqMap(
612652

613653
const relationOrPermission = relation.or(permission);
614654

655+
// Use flags
656+
const useFlag = Parsimmon.seqMap(
657+
Parsimmon.index,
658+
seq(lexeme(string("use")), identifier, terminator.atMost(1)),
659+
Parsimmon.index,
660+
function (startIndex, data, endIndex) {
661+
return {
662+
kind: "use",
663+
featureName: data[1],
664+
range: { startIndex: startIndex, endIndex: endIndex },
665+
};
666+
},
667+
);
668+
615669
// Object Definitions.
616670
const definition = Parsimmon.seqMap(
617671
Parsimmon.index,
@@ -725,7 +779,7 @@ const caveat = Parsimmon.seqMap(
725779
},
726780
);
727781

728-
const definitionOrCaveat = definition.or(caveat);
782+
const topLevel = definition.or(caveat).or(useFlag);
729783

730784
function findReferenceNodeInDef(
731785
def: ParsedObjectDefinition,

0 commit comments

Comments
 (0)