Export InvalidUnionError type

I am currently making a utility function for a use case to specially handle union errors. The error object is a bit nested in my situation so feeling the need for that. Can InvalidUnionError be exported as a type from the library? Otherwise finding it a bit difficult to deal with it in TS.

For instance, I have:

function findUnionError(zodError: zod.ZodError): ZodSuberror | undefined {
  return zodError.errors.find(err => {
    return err.code === zod.ZodErrorCode.invalid_union;
  })
}

It will be great if I can do:

function findUnionError(zodError: zod.ZodError): InvalidUnionError | undefined {
  return zodError.errors.find((err) => {
    return err.code === zod.ZodErrorCode.invalid_union;
  }) as InvalidUnionError | undefined;
}

Because later I need to access the .unionErrors property and can’t do it:

I am again needing to do:

function something(err: zod.ZodError): void {
  const errorItem = findUnionError(err);
  if (errorItem !== undefined && errorItem.code === zod.ZodErrorCode.invalid_union) {
    // do something with errorItem.unionErrors
    errorItem.unionErrors
  }
}

which feels like a little extra steps.

[colinhacks]

As of zod@1.11 InvalidUnionError and all other suberror data types are now exported

[maneetgoyal]

@vriad

Are you just trying to print a custom error? If so the recommended way to do this is with a custom error map.

No, I am trying to access a deeply nested error in a ZodSuberror with error code ZodErrorCode.invalid_union. I tried using ZodErrorMap but the thing it seems to be good at is modifying the error messages. In my use case, I am not altering the error message. The issue is that the error message I am interested in extracting is quite deep:

• I get a InvalidUnionError.
• Then I go to its .unionErrors property which is an array of ZodError.
• In that, I am only interested in the ZodError which has the smallest .errors array size.
• In that smallest ZodError, the ZodSuberror I am interested in is again a InvalidUnionError.
• Finally, I am interested in that error message.

const smallestError = findSmallestZodError(subError.unionErrors);
const unionError = findZodUnionError(smallestError);
if ( unionError !== undefined && unionError.path.includes("something")) {
   lodash.set(errors, unionError.path, unionError.unionErrors[0].errors[0].message);
}

---

For achieving it, one of the utility function I made is this:

/**
 * Checks whether a given Zod error has a sunion type sub error
 * @param err
 */
export function findZodUnionError(
  err?: zod.ZodError
): InvalidUnionError | undefined {
  let unionError: InvalidUnionError | undefined;
  if (err !== undefined) {
    unionError = err.errors.find((subErr) => {
      return subErr.code === zod.ZodErrorCode.invalid_union;
    }) as InvalidUnionError | undefined;
  }
  return unionError;
}

So if InvalidUnionError is exported natively, it will be quite useful in my case. Any other suggestion is also greatly appreciated.