Detailed errors for union schema

I’d like to have more information or even TS-like details for union errors (Add a flag to parse?):

My types:

export const T = z.union([
  A, B, C
])

So what I currently get from this is:

     Error: 1 validation issue(s)

  Issue #0: invalid_union at 
  Invalid input

What I’d like to get is something more similar to this:

'{ t: 1 }' is not assignable to parameter of type '{ a: number } | { b: number }'

Is this sensible|doable|easy|hard?

[chrbala]

It seems like this could be improved with a union resolver function as I proposed in https://github.com/vriad/zod/issues/100#issuecomment-667584554. As long as the input matches well enough (e.g. with a discriminator field) to be recognized as an element of the union in userland, the errors could be simplified to a single case instead of needing to resolve unionErrors within an invalid_union error type.

enum Number {
  FLOAT,
  INT,
}
const floatObj = z.object({
  kind: z.literal(Number.FLOAT),
  value: z.number(),
});
const intObj = z.object({
  kind: z.literal(Number.INT),
  value: z.number().refine(n => n % 1 === 0, "not_int"),
});

const resolver = (val: unknown) =>
  val && typeof val === 'object'
    ? val.kind === Number.FLOAT
      ? floatObj
      : intObj
    : null;

const union = z.union([floatObj, intObj], resolver);

const input = {
  kind: Number.INT,
  value: 5.5,
};

union.parse(input); // same result as intObj.parse(input);

So here, parsing input with into either the union or intObj schemas should result in:

Error: 1 validation issue(s)

  Issue #0: custom_error at value
  not_int

[colinhacks]

Simple answer:

You have access to all this error information already. Zod throws a special subclass of Error called ZodError that contains detailed error information in the .errors property:

import * as z from "zod";

try {
  z.union([z.object({ a: z.number() }), z.object({ b: z.number() })]).parse({ t: 1 });
} catch (err) {
  if (err instanceof z.ZodError) {
    console.log(JSON.stringify(err.errors, null, 2));
  }
}

This wil print:

[
  {
    "code": "invalid_union",
    "unionErrors": [
      {
        "errors": [
          {
            "code": "unrecognized_keys",
            "keys": [
              "t"
            ],
            "path": [],
            "message": "Unrecognized key(s) in object: 't'"
          },
          {
            "code": "invalid_type",
            "expected": "number",
            "received": "undefined",
            "path": [
              "a"
            ],
            "message": "Required"
          }
        ]
      },
      {
        "errors": [
          {
            "code": "unrecognized_keys",
            "keys": [
              "t"
            ],
            "path": [],
            "message": "Unrecognized key(s) in object: 't'"
          },
          {
            "code": "invalid_type",
            "expected": "number",
            "received": "undefined",
            "path": [
              "b"
            ],
            "message": "Required"
          }
        ]
      }
    ],
    "path": [],
    "message": "Invalid input"
  }
]

---

More complicated answer:

Error handling in Zod is complex enough that I split it into it’s own README: https://github.com/vriad/zod/blob/master/ERROR_HANDLING.md

That guide explains how to do this. Getting the exact error information you need can feel a bit like spelunking, but I’m pretty sure this complexity is irreducible. Believe me, I’ve tried 😃

Here’s how to do what you want:

import * as z from ‘.’;

try {
  z.union([z.string(), z.number()]).parse(true);
} catch (err) {
  // check for ZodError
  if (err instanceof z.ZodError) {
    // loop over suberrors
    for (const suberr of err.errors) {
      // check if suberror is an `invalid_union` error
      // inside the for loop, `suberr` will have additional 
      // properties specific to union errors (e.g. `unionErrors`)
      if (suberr.code === z.ZodErrorCode.invalid_union) {
        // suberr.unionErrors is an array of ZodErrors for each union component
        suberr.unionErrors; // ZodError[]
        console.log(suberr.unionErrors.map(e => e.message).join("\n"))
      }
    }
  }
}

If you don’t want to write this error handling code every time you want to handle union errors you should write your own Error Map which lets you customize the message for every kind of error in Zod. You then pass your error map as a parameter to .parse(). Instructions for doing so are all explained in the guide. 👍

You can get a sense for all the error data available to you like this: