Best way to "drop" a property when it doesn't match the schema?

[JaneJeon]

Hi, I have an object that's coming from outside that I need to put into in some guaranteed form, but NOT throw.

Basically, I want to make sure that the object's property matches the validation OR it's not included in the first place.

For a simple example, let's consider an object with a string field foo:

z.object({ foo: z.string().url() }).partial()

However, this doesn't work because if foo is not a URL, it will throw instead of just dropping the property.

Here's how it would ideally go:

schema.parse({ foo: 'bar'}) // -> {}
schema.parse({}) // -> {}
schema.parse({ foo: 'https://example.com' }) // -> { foo: 'https://example.com' }

Even transformers don't work, because I don't want the foo field with an undefined value to be in the object. I just want the key to not even be present in the first place.

So far the only thing that seems like it could work is if I were to create a union of objects (not the foo field) in which the foo field is present and meets validation, or isn't present at all:

z.union([ z.object({}).strip(), z.object({ foo: z.string().url() } ])

However, I have 5 other properties like foo, and that means I'd need a union of 2^5 = 32 schemas, which is just untenable, especially as the number of properties may go up in the future.

Is there any good way to do this other than a MASSIVE union of schemas, i.e. to do this at the field level so that foo either is accepted or is dropped (without throwing)?

Thanks.

[scotttrinh]

I don't think there is a straightforward way to do this, but you could do this at runtime by using safeParse and then iterating over the issues and generating a new object that only picks the valid fields from the input data and then reruns the parsing. Awkward and probably full of edge-cases, but probably something that can be abstracted into a gnarly, gross, generic function and reused.

[flazouh]

If anyone wondering, here is my attempt at doing it:

import { ZodObject, ZodRawShape } from 'zod'
import { ZodIssueCode } from 'zod/lib/ZodError'

function validateFilter<T extends ZodRawShape>(
  schema: ZodObject<T>,
  data: object,
): boolean {
  console.log(`Passed data: ${JSON.stringify(data, null, 2)}`)
  const result = schema.safeParse(data)

  if (result.success) {
    return true
  } else {
    for (const issue of result.error.issues) {
      if (issue.code === ZodIssueCode.unrecognized_keys) {
        for (const key of issue.keys) {
          delete data[key]
        }
      }
    }

    const newResult = schema.safeParse(data)

    if (newResult.success) {
      return true
    } else {
      console.error(
        'Failed to parse data after filtering invalid fields:',
        newResult.error,
      )
      return false
    }
  }
}

[piscopancer]

Hello, any updates on it?

[sienkiewiczkm]

Having this option would be great for URL query string parsing. URL this can be easily malformed by users, but often I would like to ignore invalid parameters, but accept others that are OK.

+1!

[schpet]

the approach i took when parsing urls was

1. provide defaults to fallback to
2. validate each field individually and fallback to defaults

   for (const key in schema.shape) {
   	try {
   		const fieldSchema = schema.shape[key]
   		if (fieldSchema) {
   			const parsedValue = fieldSchema.parse(shapedObject[key])
   			validFields[key as keyof z.infer<T>] = parsedValue
   		}
   	} catch (error) {
   		// If parsing fails, use the defaultData value
   		validFields[key as keyof z.infer<T>] = defaultData[key as keyof z.infer<T>]
   	}
   }

full example:
https://github.com/schpet/zod-urlsearchparams/blob/ae4afe296c0ebb13a9a5d458ce055b9de15d8981/src/index.ts#L163-L197

library repo:
https://github.com/schpet/zod-urlsearchparams