ZodError[] doesn't contain error from refine() or superRefine()

[wkd-kapsule]

Hi there ✌🏾,

Basically, I have set up my schema for products with a few custom error messages and a superRefine() to throw an error if the comparedAt price is lower than the actual price. I use safeParse() to do the validation and get the errors.

Everything is working fine until I have 2 errors not coming from the superRefine() AND the one coming from the superRefine().
In that case, the error coming from superRefine() won't show up in the ZodError[]. I have tried the refine() and superRefine() ways, both lead to the same outcome.

Take a look at the logging of the errors (don't pay attention to the double rendering):

1st step: I have only 2 errors, both not coming from superRefine()

2nd step: I add another not-from superRefine() error to make sure that the ZodError[] is actually able to contain more than 2 errors.

3rd step: I add the superRefine() error. I had to solve the price error to make it higher than the comparedAt price. That's why the price error isn't present anymore, but the comparedAt one should be there.

4th step: I solve the name error and only then the superRefine() error shows up.

5th step: I add the name error again and the superRefine() one disappears from the ZodError[] whereas it is still invalid.

Here's my schema:

export const ZodProduct = z
  .object({
    name: z.string({required_error: 'Please, set a name.'}).min(1),
    images: z.object({
      mainImage: z.string().min(1, 'Please, set a main image.'),
      secondaryImages: z.array(z.string().min(1)).optional(),
    }),
    price: z
      .number({required_error: 'Please, set a price.'})
      .min(0, 'The price cannot be negative.'),
    comparedAt: z.number().min(0, 'The compared price cannot be negative.'),
    weight: z.number().min(0),
    width: z.number().min(0),
    height: z.number().min(0),
    length: z.number().min(0),
    sku: z.string().min(1),
  })
  .partial({
    comparedAt: true,
    weight: true,
    width: true,
    height: true,
    length: true,
    sku: true,
  })
  .superRefine((data, ctx) => {
    if (data.comparedAt && data.comparedAt <= data.price) {
      ctx.addIssue({
        type: 'number',
        code: 'too_small',
        minimum: data.price,
        inclusive: false,
        path: ['comparedAt'],
        message: 'The compared price should be higher than the actual one.',
      })
    }
  })

[JacobWeisenburger]

I can't seem to understand what the problem is. Please explain what is not working correctly and produce test data that causes the problem.

[wkd-kapsule]

I can't seem to understand what the problem is. Please explain what is not working correctly and produce test data that causes the problem.

As stated in the post, the issue is that the error triggered by superRefine() is not included in the ZodError[] that I get after parsing the data IF that same ZodError[] also includes 2 "regular" errors (meaning that they were set within the schema's fields themselves and not the superRefine()).

If the ZodError[] contains less than 2 of these "regular" errors, then it will also include the one from superRefine().
Just to make sure I'm fully clear: the issue isn't that an error is detected or not when it should or shouldn't be. All the invalid data is caught by the parser as expected. My issue is when I want to handle the errors, the ZodError[] supposed to contain all of them will "hide" the one from superRefine() given the situation explained above.

In the screenshots from the logs, at no. 3 the comparedAt error should be included in the flatten() of errors, but it isn't because the array already contains 2 "regular" errors. When I remove one of them at no. 4, the comparedAt field's error gets included in the ZodError[].

[JacobWeisenburger]

Please send a full reproducible code example.

[wkd-kapsule]

Please send a full reproducible code example.

Alright. Take this schema:

export const ZodProduct = z
  .object({
    name: z.string({required_error: 'Please, set a name.'}).min(1),
    images: z.object({
      mainImage: z.string().min(1, 'Please, set a main image.'),
      secondaryImages: z.array(z.string().min(1)).optional(),
    }),
    price: z
      .number({required_error: 'Please, set a price.'})
      .min(0, 'The price cannot be negative.'),
    comparedAt: z.number().min(0, 'The compared price cannot be negative.'),
    weight: z.number().min(0),
    width: z.number().min(0),
    height: z.number().min(0),
    length: z.number().min(0),
    sku: z.string().min(1),
  })
  .partial({
    comparedAt: true,
    weight: true,
    width: true,
    height: true,
    length: true,
    sku: true,
  })
  .superRefine((data, ctx) => {
    if (data.comparedAt && data.comparedAt <= data.price) {
      ctx.addIssue({
        type: 'number',
        code: 'too_small',
        minimum: data.price,
        inclusive: false,
        path: ['comparedAt'],
        message: 'The compared price should be higher than the actual one.',
      })
    }
  })

Now safeParse() this data:

const data = {
  name: undefined,
  images: {
    mainImage: undefined,
    secondaryImages: undefined,
  },
  price: 42,
  comparedAt: 33,
  weigth: undefined,
  width: undefined,
  heigth: undefined,
  length: undefined,
  sku: undefined,
}

This should trigger 3 errors: on the name, mainImage and comparedAt fields.

Yet, the ZodError[] won't include the comparedAt field's error.

Set a name (non-empty string) and the safeParse() will include the comparedAt field's error.

[scotttrinh]

There are only two errors for the given data with the given schema: name and images.mainImage:

test("check", () => {
  const result = ZodProduct.safeParse(data);
  assert.ok(!result.success);
  assert.deepEqual(
    result.error.errors.map(({ path }) => path),
    [["name"], ["images", "mainImage"]],
  );
});

CodeSandbox

[JacobWeisenburger]

superRefine, transform, and refine, don't run if the prior schema fails. I'm pretty sure this is intended behavior.

Here is a much more simplified example to better illustrate the issue:

const schema = z.object( { foo: z.string() } )
    .superRefine( () => { console.log( 'superRefine' ) } )

console.log( 'test1' )
schema.safeParse( {} ) // doesn't run superRefine because the z.object fails

console.log()
console.log( 'test2' )
schema.safeParse( { foo: undefined } ) // doesn't run superRefine because the z.object fails

console.log()
console.log( 'test3' )
schema.safeParse( { foo: 'bar' } ) // runs superRefine because the z.object passes

/* 
console:
test1

test2

test3
superRefine
*/

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[wkd-kapsule]

Hey,

As I tried to explain in my first post, I actually get the error from superRefine() even when the data fails. But I only get it if the data fails for less than 2 errors.

Take a look back at this screenshot of the logging of the fields that failed the parsing (I use flatten() to get a cleaner errors object):

At number 4, we can see the comparedAt field, from superRefine(), even though the data failed at images.
The comparedAt field also failed at number 3 but wasn't present in the errors because there was already 2 errors from the data object, nameand images. When at number 4 there was only 1 error from the data object, then the comparedAt was included in the errors.

So to sum it up: superRefine() gets triggered even though the data fails but gets included in the errors object ONLY if the data fails for less than 2 errors.

[JacobWeisenburger]

You have yet to provide a full reproducible code example. So I'm going to mark this as answered.

[wkd-kapsule]

What do you mean by fully reproducible code? The schema + the data object to parse aren't enough for you to reproduce my situation on your side?

[JacobWeisenburger]

whatever code you used to produce this screen shot:

because, I don't see that when I run the code you gave earlier.

[spiasecki]

Is there a way to make superRefine run alongside the schema validation and show all errors at once.

In my use case I need to compare multiple properties from the object against each other and show all of them at once.