Skip to content

Commit f02b354

Browse files
gcantigcanti
authoredOct 8, 2024··
Enhanced Error Reporting for Discriminated Union Tuple Schemas (#3753)
·
effect@3.14.5@effect/ai@0.1.0
1 parent 597b301 commit f02b354

File tree

4 files changed

+257
-5
lines changed

4 files changed

+257
-5
lines changed
 

‎.changeset/cyan-pillows-listen.md

+50
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
---
2+
"@effect/schema": patch
3+
---
4+
5+
Enhanced Error Reporting for Discriminated Union Tuple Schemas, closes #3752
6+
7+
Previously, irrelevant error messages were generated for each member of the union. Now, when a discriminator is present in the input, only the relevant member will trigger an error.
8+
9+
Before
10+
11+
```ts
12+
import * as Schema from "@effect/schema/Schema"
13+
14+
const schema = Schema.Union(
15+
Schema.Tuple(Schema.Literal("a"), Schema.String),
16+
Schema.Tuple(Schema.Literal("b"), Schema.Number)
17+
).annotations({ identifier: "MyUnion" })
18+
19+
console.log(Schema.decodeUnknownSync(schema)(["a", 0]))
20+
/*
21+
throws:
22+
ParseError: MyUnion
23+
├─ readonly ["a", string]
24+
│ └─ [1]
25+
│ └─ Expected string, actual 0
26+
└─ readonly ["b", number]
27+
└─ [0]
28+
└─ Expected "b", actual "a"
29+
*/
30+
```
31+
32+
After
33+
34+
```ts
35+
import * as Schema from "@effect/schema/Schema"
36+
37+
const schema = Schema.Union(
38+
Schema.Tuple(Schema.Literal("a"), Schema.String),
39+
Schema.Tuple(Schema.Literal("b"), Schema.Number)
40+
).annotations({ identifier: "MyUnion" })
41+
42+
console.log(Schema.decodeUnknownSync(schema)(["a", 0]))
43+
/*
44+
throws:
45+
ParseError: MyUnion
46+
└─ readonly ["a", string]
47+
└─ [1]
48+
└─ Expected string, actual 0
49+
*/
50+
```

‎packages/schema/src/ParseResult.ts

+15-2
Original file line numberDiff line numberDiff line change
@@ -1392,7 +1392,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
13921392
let candidates: Array<AST.AST> = []
13931393
if (len > 0) {
13941394
// if there is at least one key then input must be an object
1395-
if (Predicate.isRecord(input)) {
1395+
if (isObject(input)) {
13961396
for (let i = 0; i < len; i++) {
13971397
const name = ownKeys[i]
13981398
const buckets = searchTree.keys[name].buckets
@@ -1418,7 +1418,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
14181418
}
14191419
} else {
14201420
const literals = AST.Union.make(searchTree.keys[name].literals)
1421-
const fakeps = new AST.PropertySignature(name, literals, false, true) // TODO: inherit message annotation from the union?
1421+
const fakeps = new AST.PropertySignature(name, literals, false, true)
14221422
es.push([
14231423
stepKey++,
14241424
new Composite(
@@ -1520,6 +1520,8 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
15201520
}
15211521
}
15221522

1523+
const isObject = (input: unknown): input is { [x: PropertyKey]: unknown } => typeof input === "object" && input !== null
1524+
15231525
const fromRefinement = <A>(ast: AST.AST, refinement: (u: unknown) => u is A): Parser => (u) =>
15241526
refinement(u) ? Either.right(u) : Either.left(new Type(ast, u))
15251527

@@ -1547,6 +1549,17 @@ export const getLiterals = (
15471549
}
15481550
return out
15491551
}
1552+
case "TupleType": {
1553+
const out: Array<[PropertyKey, AST.Literal]> = []
1554+
for (let i = 0; i < ast.elements.length; i++) {
1555+
const element = ast.elements[i]
1556+
const type = isDecoding ? AST.encodedAST(element.type) : AST.typeAST(element.type)
1557+
if (AST.isLiteral(type) && !element.isOptional) {
1558+
out.push([i, type])
1559+
}
1560+
}
1561+
return out
1562+
}
15501563
case "Refinement":
15511564
return getLiterals(ast.from, isDecoding)
15521565
case "Suspend":

‎packages/schema/test/ParseResult.test.ts

+97-1
Original file line numberDiff line numberDiff line change
@@ -242,11 +242,16 @@ describe("ParseIssue.actual", () => {
242242
expect(P.getLiterals(S.String.ast, true)).toEqual([])
243243
})
244244

245-
it("TypeLiteral", () => {
245+
it("Struct", () => {
246246
expect(P.getLiterals(S.Struct({ _tag: S.Literal("a") }).ast, true))
247247
.toEqual([["_tag", new AST.Literal("a")]])
248248
})
249249

250+
it("Tuple", () => {
251+
expect(P.getLiterals(S.Tuple(S.Literal("a"), S.String).ast, true))
252+
.toEqual([[0, new AST.Literal("a")]])
253+
})
254+
250255
it("Refinement", () => {
251256
expect(
252257
P.getLiterals(
@@ -369,6 +374,97 @@ describe("ParseIssue.actual", () => {
369374
})
370375
})
371376

377+
it("struct + struct (multiple tags)", () => {
378+
const A = S.Struct({ _tag: S.Literal("A"), _tag2: S.Literal("A1"), c: S.String })
379+
const B = S.Struct({ _tag: S.Literal("A"), _tag2: S.Literal("A2"), d: S.Number })
380+
expect(
381+
P.getSearchTree([A.ast, B.ast], true)
382+
).toEqual({
383+
keys: {
384+
_tag: {
385+
buckets: {
386+
A: [A.ast]
387+
},
388+
literals: [new AST.Literal("A")]
389+
},
390+
_tag2: {
391+
buckets: {
392+
A2: [B.ast]
393+
},
394+
literals: [new AST.Literal("A2")]
395+
}
396+
},
397+
otherwise: []
398+
})
399+
})
400+
401+
it("tuple + tuple (same tag key)", () => {
402+
const a = S.Tuple(S.Literal("a"), S.String)
403+
const b = S.Tuple(S.Literal("b"), S.Number)
404+
expect(
405+
P.getSearchTree([a.ast, b.ast], true)
406+
).toEqual({
407+
keys: {
408+
0: {
409+
buckets: {
410+
a: [a.ast],
411+
b: [b.ast]
412+
},
413+
literals: [new AST.Literal("a"), new AST.Literal("b")]
414+
}
415+
},
416+
otherwise: []
417+
})
418+
})
419+
420+
it("tuple + tuple (different tag key)", () => {
421+
const a = S.Tuple(S.Literal("a"), S.String)
422+
const b = S.Tuple(S.Number, S.Literal("b"))
423+
expect(
424+
P.getSearchTree([a.ast, b.ast], true)
425+
).toEqual({
426+
keys: {
427+
0: {
428+
buckets: {
429+
a: [a.ast]
430+
},
431+
literals: [new AST.Literal("a")]
432+
},
433+
1: {
434+
buckets: {
435+
b: [b.ast]
436+
},
437+
literals: [new AST.Literal("b")]
438+
}
439+
},
440+
otherwise: []
441+
})
442+
})
443+
444+
it("tuple + tuple (multiple tags)", () => {
445+
const a = S.Tuple(S.Literal("a"), S.Literal("b"), S.String)
446+
const b = S.Tuple(S.Literal("a"), S.Literal("c"), S.Number)
447+
expect(
448+
P.getSearchTree([a.ast, b.ast], true)
449+
).toEqual({
450+
keys: {
451+
0: {
452+
buckets: {
453+
a: [a.ast]
454+
},
455+
literals: [new AST.Literal("a")]
456+
},
457+
1: {
458+
buckets: {
459+
c: [b.ast]
460+
},
461+
literals: [new AST.Literal("c")]
462+
}
463+
},
464+
otherwise: []
465+
})
466+
})
467+
372468
it("should handle multiple tags", () => {
373469
const a = S.Struct({ category: S.Literal("catA"), tag: S.Literal("a") })
374470
const b = S.Struct({ category: S.Literal("catA"), tag: S.Literal("b") })

‎packages/schema/test/Schema/Union/Union.test.ts

+95-2
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ describe("Union", () => {
3737
await Util.expectDecodeUnknownFailure(schema, 1, "Expected never, actual 1")
3838
})
3939

40-
it("members with literals but the input doesn't have any", async () => {
40+
it("struct members", async () => {
4141
const schema = S.Union(
4242
S.Struct({ a: S.Literal(1), c: S.String }),
4343
S.Struct({ b: S.Literal(2), d: S.Number })
@@ -82,7 +82,7 @@ describe("Union", () => {
8282
)
8383
})
8484

85-
it("members with multiple tags", async () => {
85+
it("struct members with multiple tags", async () => {
8686
const schema = S.Union(
8787
S.Struct({ category: S.Literal("catA"), tag: S.Literal("a") }),
8888
S.Struct({ category: S.Literal("catA"), tag: S.Literal("b") }),
@@ -157,6 +157,99 @@ describe("Union", () => {
157157
└─ is missing`
158158
)
159159
})
160+
161+
it("tuple members", async () => {
162+
const schema = S.Union(
163+
S.Tuple(S.Literal("a"), S.String),
164+
S.Tuple(S.Literal("b"), S.Number)
165+
).annotations({ identifier: "MyUnion" })
166+
167+
await Util.expectDecodeUnknownSuccess(schema, ["a", "s"])
168+
await Util.expectDecodeUnknownSuccess(schema, ["b", 1])
169+
170+
await Util.expectDecodeUnknownFailure(schema, null, `Expected MyUnion, actual null`)
171+
await Util.expectDecodeUnknownFailure(
172+
schema,
173+
[],
174+
`MyUnion
175+
└─ { readonly 0: "a" | "b" }
176+
└─ ["0"]
177+
└─ is missing`
178+
)
179+
await Util.expectDecodeUnknownFailure(
180+
schema,
181+
["c"],
182+
`MyUnion
183+
└─ { readonly 0: "a" | "b" }
184+
└─ ["0"]
185+
└─ Expected "a" | "b", actual "c"`
186+
)
187+
await Util.expectDecodeUnknownFailure(
188+
schema,
189+
["a", 0],
190+
`MyUnion
191+
└─ readonly ["a", string]
192+
└─ [1]
193+
└─ Expected string, actual 0`
194+
)
195+
})
196+
197+
it("tuple members with multiple tags", async () => {
198+
const schema = S.Union(
199+
S.Tuple(S.Literal("a"), S.Literal("b"), S.String),
200+
S.Tuple(S.Literal("a"), S.Literal("c"), S.Number),
201+
S.Tuple(S.Literal("a"), S.Literal("d"), S.Boolean)
202+
).annotations({ identifier: "MyUnion" })
203+
204+
await Util.expectDecodeUnknownSuccess(schema, ["a", "b", "s"])
205+
await Util.expectDecodeUnknownSuccess(schema, ["a", "c", 1])
206+
207+
await Util.expectDecodeUnknownFailure(schema, null, `Expected MyUnion, actual null`)
208+
await Util.expectDecodeUnknownFailure(
209+
schema,
210+
[],
211+
`MyUnion
212+
├─ { readonly 0: "a" }
213+
│ └─ ["0"]
214+
│ └─ is missing
215+
└─ { readonly 1: "c" | "d" }
216+
└─ ["1"]
217+
└─ is missing`
218+
)
219+
await Util.expectDecodeUnknownFailure(
220+
schema,
221+
["c"],
222+
`MyUnion
223+
├─ { readonly 0: "a" }
224+
│ └─ ["0"]
225+
│ └─ Expected "a", actual "c"
226+
└─ { readonly 1: "c" | "d" }
227+
└─ ["1"]
228+
└─ is missing`
229+
)
230+
await Util.expectDecodeUnknownFailure(
231+
schema,
232+
["a", "c"],
233+
`MyUnion
234+
├─ readonly ["a", "b", string]
235+
│ └─ [2]
236+
│ └─ is missing
237+
└─ readonly ["a", "c", number]
238+
└─ [2]
239+
└─ is missing`
240+
)
241+
await Util.expectDecodeUnknownFailure(
242+
schema,
243+
["a", "b", 0],
244+
`MyUnion
245+
├─ { readonly 1: "c" | "d" }
246+
│ └─ ["1"]
247+
│ └─ Expected "c" | "d", actual "b"
248+
└─ readonly ["a", "b", string]
249+
└─ [2]
250+
└─ Expected string, actual 0`
251+
)
252+
})
160253
})
161254

162255
describe("encoding", () => {

0 commit comments

Comments
 (0)
Please sign in to comment.