Map refined error to multiple fields

[p-runge]

I am validating an array and was wondering if there is a way to map an error to multiple items (all that fail the validation).

I am trying this:

MySchema.refine(
    (data) => {
      const {
        product: { pages },
        positions,
      } = data;
      return positions.every(({ page }) => {
        return page <= pages;
      });
    },
    ({ product: { pages }, positions }) => {
      const failedPositionIndexes = positions
        .map(({ page }, index) => ({ page, index }))
        .filter(({ page }) => page > pages)
        .map(({ index }) => index);

      return {
        message: `Product has only ${pages} pages`,
        path: failedPositionIndexes.map((index) => `positions.${index}.page`),
      };
    }
  );

Passing an array to path joins all the items to a nested path string. But is there a way to actually mark multiple fields with a refinement?

[JacobWeisenburger]

Cannot find name 'MySchema'.

can you please send a full reproducible example?

[p-runge]

Well not really because I don't know how this would work if it does somehow at all. That's my question.

Maybe this reduced example describes my question a bit better:

const MySchema = z.object({
  foo: z.string(),
  bar: z.string(),
}).refine(({foo, bar}) => false, {
  message: "Both props shall show this error message for some reason",
  path: ["foo", "bar"],
});

Again, the syntax with path: ["foo", "bar"], does map the error to "foo.bar", which is fine. But I am looking for a way to actually show that error message at both fields, foo and bar. So can I tell Zod that somehow, and if so, how do I do that? I didn't find anything regarding in the docs.

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.object( {
    product: z.object( {
        pages: z.number(),
    } ),
    positions: z.object( {
        page: z.number(),
    } ).array(),
} ).transform(
    ( data, ctx ) => {
        const { product: { pages }, positions } = data

        const failedPositionIndexes = positions.reduce(
            ( indexes, { page }, index ) => page > pages
                ? [ ...indexes, index ]
                : indexes,
            [] as number[]
        )

        if ( failedPositionIndexes )
            failedPositionIndexes.forEach( ( index ) => ctx.addIssue( {
                code: 'custom',
                message: `Product has only ${ pages } page${ pages != 1 ? 's' : '' }`,
                path: [ 'positions', index, 'page' ],
            } ) )

        return data
    }
)

const result = schema.safeParse( {
    product: {
        pages: 3,
    },
    positions: [
        { page: 1 },
        { page: 2 },
        { page: 3 },
        { page: 4 },
        { page: 5 },
    ],
} )
!result.success && console.log( result.error.issues )
// [
//     {
//         code: 'custom',
//         message: 'Product has only 3 pages',
//         path: [ 'positions', 3, 'page' ]
//     },
//     {
//         code: 'custom',
//         message: 'Product has only 3 pages',
//         path: [ 'positions', 4, 'page' ]
//     }
// ]

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

[p-runge]

Since I don't want to mutate my data, .transform() was not really my way to go, but mentioning ctx.addIssue made me look for other appearances of it making me look deeper into .superRefine which I didn't quite use before and which came in handy for what I need here.

So I solved my issue like this:

MySchema.superRefine(({ product: { pages }, positions }, ctx) => {
    positions.forEach(({ page }, index) => {
      if (page > pages) {
        ctx.addIssue({
          type: "number",
          code: z.ZodIssueCode.too_big,
          maximum: pages,
          inclusive: true,
          message: `Product has only ${pages} pages`,
          path: ["positions", index, "page"],
        });
      }
    });
  });

[JacobWeisenburger]

MySchema.superRefine(({ product: { pages }, positions }, ctx) => {
    positions.forEach(({ page }, index) => {
      if (page > pages) {
        ctx.addIssue({
          type: "number",
          code: z.ZodIssueCode.too_big,
          maximum: pages,
          inclusive: true,
          message: `Product has only ${pages} pages`,
          path: ["positions", index, "page"],
        });
      }
    });
  });

[icebearlabs]

@JacobWeisenburger this has helped me a great deal, thank you for the idea