Allow array to return only valid items and not fail whole array

[bmeverett]

When validating an array, I would like to only return the valid items in an array and not fail if one item fails.

This is a very basic example

const schema = z.object({
  arr: z.array(z.number())
})

const result = schema.safeParse({arr: [1,2,"3"]})

I would like this to return only the valid items

arr: [1,2]

I tried using refine on the array, but it seems to only be called when the array validates correctly. Is there a way to do this, or is this something you'd be willing to support?

[lucassarcanjo]

Hi @bmeverett,

I don't know if Zod maintainers will support this specific claim in the lib, but you can build a custom validator that uses error.issues to filter it manually based on invalid properties/items issued by zod.

I've implemented something like that just as a proof of concept:

const validator = (schema: z.Schema<any, any>) => (data: object) => {
  const response = schema.safeParse(data);

  if (response.success === false) {
    const errorPaths = response.error.issues.map((issue) => issue.path);

    let filteredData = data;
    errorPaths.forEach(
      (error) => (filteredData = filterByPath(filteredData, error))
    );

    return filteredData;
  }

  return data;
};

const result = validator(schema)(input);

The most difficult part is the filterByPath() function, which I've got something that works but maybe it's not perfect in performance terms and maybe does not cover all cases.

I would suggest you develop your own for your needs. For reference, you can see my implementation here in StackBlitz.

[JacobWeisenburger]

@bmeverett
Is this what you're looking for?

const schema = z.object( {
    arr: z.any().array().transform(
        arr => arr.map( item =>
            z.number().safeParse( item ).success ? item : undefined
        ).filter( Boolean )
    ),
} )

console.log( schema.parse( { arr: [ 1, 2, '3' ] } ) ) // { arr: [ 1, 2 ] }

[bmeverett]

Thanks @JacobWeisenburger and @lucassarcanjo I think I can work with these.

[alexgleason]

Here's what I ended up with, based on @JacobWeisenburger's answer:

function filteredArray<T>(schema: z.ZodType<T>) {
  return z.any().array().transform((arr) => (
    arr.map((item) => schema.safeParse(item).success ? item as T : undefined)
      .filter((item): item is T => Boolean(item))
  ));
}

Usage:

const noteSchema = z.object({
  tag: filteredArray(tagSchema).catch([]),
});

The type of note.tag is correct when used this way.

[AkisArou]

Here's what I ended up with, based on @JacobWeisenburger's answer:

function filteredArray<T>(schema: z.ZodType<T>) {
  return z.any().array().transform((arr) => (
    arr.map((item) => schema.safeParse(item).success ? item as T : undefined)
      .filter((item): item is T => Boolean(item))
  ));
}

Usage:

const noteSchema = z.object({
  tag: filteredArray(tagSchema).catch([]),
});

The type of note.tag is correct when used this way.

I modified your function a little bit, so any transformation and coercion applies.

function filteredArray<T>(schema: z.ZodType<T>) {
	return z
		.any()
		.array()
		.transform((arr) =>
			arr
				.map((item) => {
					const res = schema.safeParse(item);
					return res.success ? (res.data as T) : undefined;
				})
				.filter((item): item is T => Boolean(item)),
		);
}

[mysuf]

This is probably reason for me to leave Zod behind. Proposed solutions drop error messages or require to traverse paths. Basically, there is no way to make parsing more greedy.

I wonder why safeParse isn't implementing this. It's up to us developer how he handle the result. He can always throw provided error if result's data are insufficient.

My expectations from safeParse:

1. It should pass validation for all required (non-optional) fields and arrays with nonempty/min/max/length validator, otherwise returns { status: false, error }
2. It should try to parse all optional fields and array entries, on invalid: logs issue, skips in case of array entry otherwise returns default()/undefined

From compatibility point of view it would require to change ReturnType<safeParse> to:
{ status: false; data: T | undefined; error: ZodError } | { success: true; data: T; }