Include an array of sub-issues in "invalid_union" issues

Author: jviide

.changeset/fast-pens-bake.md

@@ -0,0 +1,5 @@
+---
+"@badrap/valita": patch
+---
+
+Include an array of sub-issues in "invalid_union" issues

src/index.ts

@@ -87,7 +87,13 @@ type Issue = Readonly<
   | { code: "missing_value"; path: Key[] }
   | { code: "invalid_literal"; path: Key[]; expected: Literal[] }
   | { code: "unrecognized_keys"; path: Key[]; keys: Key[] }
-  | { code: "invalid_union"; path: Key[]; tree: IssueTree }
+  | {
+      code: "invalid_union";
+      path: Key[];
+      issues: Issue[];
+      /** @deprecated Instead of `.tree` use `.issues`. */
+      tree: IssueTree;
+    }
   | {
       code: "invalid_length";
       path: Key[];
@@ -123,7 +129,7 @@ function cloneIssueWithPath(tree: IssueLeaf, path: Key[]): Issue {
     case "unrecognized_keys":
       return { code, path, keys: tree.keys };
     case "invalid_union":
-      return { code, path, tree: tree.tree };
+      return { code, path, tree: tree.tree, issues: collectIssues(tree.tree) };
     case "custom_error":
       return { code, path, error: tree.error };
   }

tests/union.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, expectTypeOf } from "vitest";
+import { describe, it, expect, expectTypeOf, assert } from "vitest";
 import * as v from "../src";
 
 describe("union()", () => {
@@ -8,12 +8,14 @@ describe("union()", () => {
     expect(t.parse(1)).to.equal(1);
     expect(() => t.parse({})).to.throw(v.ValitaError);
   });
+
   it("ignores never()", () => {
     const t = v.union(v.string(), v.never());
     expect(t.parse("test")).to.equal("test");
     expect(() => t.parse(1)).to.throw(v.ValitaError);
     expectTypeOf<v.Infer<typeof t>>().toEqualTypeOf<string>();
   });
+
   it("picks the first successful parse", () => {
     const t = v.union(
       v
@@ -24,6 +26,7 @@ describe("union()", () => {
     );
     expect(t.parse("test")).to.equal(2);
   });
+
   it("respects the order of overlapping parsers", () => {
     const a = v.literal(1).map(() => "literal");
     const b = v.number().map(() => "number");
@@ -35,18 +38,21 @@ describe("union()", () => {
     expect(v.union(c, b, a).parse(1)).to.equal("unknown");
     expect(v.union(c, a, b).parse(1)).to.equal("unknown");
   });
+
   it("deduplicates strictly equal parsers", () => {
     const a = v.unknown().assert(() => false, "test");
     expect(() => v.union(a, a).parse(1))
       .to.throw(v.ValitaError)
       .with.property("issues")
       .with.lengthOf(1);
   });
+
   it("keeps the matching order when deduplicating", () => {
     const a = v.unknown().map(() => "a");
     const b = v.unknown().map(() => "b");
     expect(v.union(a, b, a).parse(1)).to.equal("a");
   });
+
   it("accepts more than two subvalidators", () => {
     const t = v.union(
       v.string(),
@@ -62,6 +68,7 @@ describe("union()", () => {
     expect(t.parse(true)).to.equal(true);
     expect(() => t.parse({})).to.throw(v.ValitaError);
   });
+
   it("accepts optional input if it maps to non-optional output", () => {
     const t = v.object({
       a: v.union(
@@ -74,6 +81,7 @@ describe("union()", () => {
     });
     expect(t.parse({})).toEqual({ a: 1 });
   });
+
   it("reports the expected type even for literals when the base type doesn't match", () => {
     const t = v.union(v.literal(1), v.literal("test"));
     expect(() => t.parse(true))
@@ -84,6 +92,7 @@ describe("union()", () => {
         expected: [1, "test"],
       });
   });
+
   it("reports the expected literals when the base type matches", () => {
     const t = v.union(v.literal(1), v.literal("test"));
     expect(() => t.parse(2))
@@ -94,6 +103,7 @@ describe("union()", () => {
         expected: [1, "test"],
       });
   });
+
   it("reports the errors from a branch that doesn't overlap with any other branch", () => {
     const t = v.union(v.literal(1), v.number(), v.object({ a: v.number() }));
     expect(() => t.parse({ a: "test" }))
@@ -105,6 +115,7 @@ describe("union()", () => {
         expected: ["number"],
       });
   });
+
   it("reports expected types in the order they were first listed", () => {
     const t1 = v.union(v.literal(2), v.string(), v.literal(2));
     expect(() => t1.parse(true))
@@ -126,6 +137,7 @@ describe("union()", () => {
         expected: ["string", "number"],
       });
   });
+
   it("reports expected literals in the order they were first listed", () => {
     const t1 = v.union(v.literal(2), v.literal(1), v.literal(2));
     expect(() => t1.parse(3))
@@ -147,6 +159,7 @@ describe("union()", () => {
         expected: [1, 2],
       });
   });
+
   it("matches unknowns if nothing else matches", () => {
     const t = v.union(
       v.literal(1),
@@ -161,6 +174,7 @@ describe("union()", () => {
         error: "test",
       });
   });
+
   it("considers never() to not overlap with anything", () => {
     const t = v.union(
       v.never(),
@@ -174,6 +188,7 @@ describe("union()", () => {
         error: "unknown",
       });
   });
+
   it("considers unknown() to overlap with everything except never()", () => {
     const t = v.union(
       v.literal(1),
@@ -187,6 +202,7 @@ describe("union()", () => {
         code: "invalid_union",
       });
   });
+
   it("considers unknown() to overlap with objects", () => {
     const t = v.union(
       v.unknown(),
@@ -195,6 +211,7 @@ describe("union()", () => {
     );
     expect(t.parse({ type: "c" })).to.deep.equal({ type: "c" });
   });
+
   it("considers array() and tuple() to overlap", () => {
     const t = v.union(v.array(v.number()), v.tuple([v.string()]));
     expect(() => t.parse(2))
@@ -205,13 +222,15 @@ describe("union()", () => {
         expected: ["array"],
       });
   });
+
   it("keeps transformed values", () => {
     const t = v.union(
       v.literal("test1").map(() => 1),
       v.literal("test2").map(() => 2),
     );
     expect(t.parse("test1")).to.deep.equal(1);
   });
+
   describe("of objects", () => {
     it("discriminates based on base types", () => {
       const t = v.union(
@@ -227,6 +246,7 @@ describe("union()", () => {
           expected: ["number", "string"],
         });
     });
+
     it("discriminates based on literal values", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -241,6 +261,7 @@ describe("union()", () => {
           expected: [1, 2],
         });
     });
+
     it("discriminates based on mixture of base types and literal values", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -255,6 +276,7 @@ describe("union()", () => {
           expected: ["number", "string"],
         });
     });
+
     it("considers unknown() to overlap with everything except never()", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -265,6 +287,7 @@ describe("union()", () => {
         .with.nested.property("issues[0]")
         .that.deep.includes({ code: "invalid_union" });
     });
+
     it("considers literals to overlap with their base types", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -275,6 +298,7 @@ describe("union()", () => {
         .with.nested.property("issues[0]")
         .that.deep.includes({ code: "invalid_union" });
     });
+
     it("considers optional() its own type", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -288,10 +312,12 @@ describe("union()", () => {
           expected: ["number", "undefined"],
         });
     });
+
     it("matches missing values to optional()", () => {
       const t = v.union(v.object({ a: v.unknown().optional() }));
       expect(t.parse({})).to.deep.equal({});
     });
+
     it("considers equal literals to overlap", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -302,6 +328,7 @@ describe("union()", () => {
         .with.nested.property("issues[0]")
         .that.deep.includes({ code: "invalid_union" });
     });
+
     it("allows mixing literals and non-literals as long as they don't overlap", () => {
       const t = v.union(
         v.object({ type: v.literal(1) }),
@@ -312,6 +339,7 @@ describe("union()", () => {
       expect(t.parse({ type: 2 })).toEqual({ type: 2 });
       expect(t.parse({ type: "test" })).toEqual({ type: "test" });
     });
+
     it("folds multiple overlapping types together in same branch", () => {
       const t = v.union(
         v.object({
@@ -331,6 +359,7 @@ describe("union()", () => {
           expected: ["test"],
         });
     });
+
     it("considers two optionals to overlap", () => {
       const t = v.union(
         v.object({ type: v.literal(1).optional() }),
@@ -340,6 +369,7 @@ describe("union()", () => {
         .to.throw(v.ValitaError)
         .with.nested.property("issues[0].code", "invalid_union");
     });
+
     it("considers two optionals and undefineds to overlap", () => {
       const t = v.union(
         v.object({ type: v.undefined() }),
@@ -349,6 +379,7 @@ describe("union()", () => {
         .to.throw(v.ValitaError)
         .with.nested.property("issues[0].code", "invalid_union");
     });
+
     it("considers two unions with partially same types to overlap", () => {
       const t = v.union(
         v.object({ type: v.union(v.literal(1), v.literal(2)) }),
@@ -358,12 +389,35 @@ describe("union()", () => {
         .to.throw(v.ValitaError)
         .with.nested.property("issues[0].code", "invalid_union");
     });
+
     it("keeps transformed values", () => {
       const t = v.union(
         v.object({ type: v.literal("test1").map(() => 1) }),
         v.object({ type: v.literal("test2").map(() => 2) }),
       );
       expect(t.parse({ type: "test1" })).to.deep.equal({ type: 1 });
     });
+
+    it("includes an array of sub-issues in 'invalid_union' issues", () => {
+      const t = v.union(
+        v.object({ type: v.literal(1).optional() }),
+        v.object({ type: v.literal(2).optional() }),
+      );
+      const result = t.try({ type: 3 });
+      assert(!result.ok);
+      assert(result.issues[0].code === "invalid_union");
+      expect(result.issues[0].issues).toEqual([
+        {
+          code: "invalid_literal",
+          expected: [1],
+          path: ["type"],
+        },
+        {
+          code: "invalid_literal",
+          expected: [2],
+          path: ["type"],
+        },
+      ]);
+    });
   });
 });