Add test

Author: colinhacks

packages/zod/src/v4/classic/tests/error-utils.test.ts

@@ -478,3 +478,50 @@ test("inheritance", () => {
   expect(e2).toBeInstanceOf(z.ZodRealError);
   expect(e2).toBeInstanceOf(Error);
 });
+
+test("disc union treeify/format", () => {
+  const schema = z.discriminatedUnion(
+    "foo",
+    [
+      z.object({
+        foo: z.literal("x"),
+        x: z.string(),
+      }),
+      z.object({
+        foo: z.literal("y"),
+        y: z.string(),
+      }),
+    ],
+    {
+      error: "Invalid discriminator",
+    }
+  );
+
+  const error = schema.safeParse({ foo: "invalid" }).error;
+  expect(z.treeifyError(error!)).toMatchInlineSnapshot(`
+    {
+      "errors": [],
+      "properties": {
+        "foo": {
+          "errors": [
+            "Invalid discriminator",
+          ],
+        },
+      },
+    }
+  `);
+  expect(z.prettifyError(error!)).toMatchInlineSnapshot(`
+    "✖ Invalid discriminator
+      → at foo"
+  `);
+  expect(z.formatError(error!)).toMatchInlineSnapshot(`
+    {
+      "_errors": [],
+      "foo": {
+        "_errors": [
+          "Invalid discriminator",
+        ],
+      },
+    }
+  `);
+});

packages/zod/src/v4/core/errors.ts

@@ -255,7 +255,7 @@ export function formatError<T>(error: $ZodError, _mapper?: any) {
   const fieldErrors: $ZodFormattedError<T> = { _errors: [] } as any;
   const processError = (error: { issues: $ZodIssue[] }) => {
     for (const issue of error.issues) {
-      if (issue.code === "invalid_union") {
+      if (issue.code === "invalid_union" && issue.errors.length) {
         issue.errors.map((issues) => processError({ issues }));
       } else if (issue.code === "invalid_key") {
         processError({ issues: issue.issues });
@@ -306,7 +306,8 @@ export function treeifyError<T>(error: $ZodError, _mapper?: any) {
   const result: $ZodErrorTree<T> = { errors: [] } as any;
   const processError = (error: { issues: $ZodIssue[] }, path: PropertyKey[] = []) => {
     for (const issue of error.issues) {
-      if (issue.code === "invalid_union") {
+      if (issue.code === "invalid_union" && issue.errors.length) {
+        // regular union error
         issue.errors.map((issues) => processError({ issues }, issue.path));
       } else if (issue.code === "invalid_key") {
         processError({ issues: issue.issues }, issue.path);

play.ts

@@ -1,40 +1,22 @@
 import { z } from "zod/v4";
 
-const a = z.object({
-  name: z.string(),
-  age: z.number().int().positive(),
-});
-
-console.dir(
-  z.toJSONSchema(a, {
-    override(ctx) {
-      const schema = ctx.zodSchema;
-      if (schema instanceof z.core.$ZodObject && schema._zod.def.catchall === undefined) {
-        delete ctx.jsonSchema.additionalProperties;
-      }
-    },
-  }),
-  { depth: null }
+const schema = z.discriminatedUnion(
+  "foo",
+  [
+    z.object({
+      foo: z.literal("x"),
+      x: z.string(),
+    }),
+    z.object({
+      foo: z.literal("y"),
+      y: z.string(),
+    }),
+  ],
+  {
+    error: "Invalid discriminator",
+  }
 );
 
-const arg = z.string().safeParse("hello"); // should not throw
-z.treeifyError(arg.error!);
-
-// import { z } from "zod/v4";
-
-const output = z.string();
-
-const aa = z.function();
-type aa = Parameters<typeof aa._output>;
-
-const itWorks = z.function({ input: [z.string()] }).implement(output.parse);
-const itWorks2 = z.function({ input: [z.string()] }).implement((args) => output.parse(args));
-const itWorks3 = z.function({ input: [z.string().default("")] }).implement(output.parse);
-const itWorks4 = z.function({ input: [z.string()] }).implement((args) => output.parse(args));
-const nope = z.function({ input: [z.string().default("")] }).implement((args) => output.parse(args));
-
-type ItWorks = ReturnType<typeof itWorks>;
-type ItWorks2 = ReturnType<typeof itWorks2>;
-type ItWorks3 = ReturnType<typeof itWorks3>;
-type ItWorks4 = ReturnType<typeof itWorks4>;
-type Nope = ReturnType<typeof nope>; //unknown
+const error = schema.safeParse({ foo: "invalid" }).error;
+console.log("error:", error);
+console.dir(z.treeifyError(error!), { depth: null });