.omit() inoperative with .passthrough()

[adrien-febvay]

.omit() doesn't do anything when using .passthrough(): the omitted keys are still there.

import { z } from 'zod'; // zod@3.20.6

// Our schema, just two known keys `a` and `b`
const schema = z.object({ a: z.number(), b: z.number() });

// We want to omit `b`, but preserve unknown keys
// No luck here: we get { a: 1, b: 2, x: 654 }
console.log(schema.omit({ b: true }).passthrough().parse({ a: 1, b: 2, x: 654 }));

// Still not what we want: { a: 1, b: 2, y: 286 }
console.log(schema.passthrough().omit({ b: true }).parse({ a: 1, b: 2, y: 286 }));

// Workaround for expected result: { a: 1, z: 123 }
console.log(schema.passthrough().transform(({ b, ...res }) => res).parse({ a: 1, b: 2, z: 123 }));

Am I doing something wrong? Am I not supposed to chain those two methods?

I understood that .passthrough() would just pass unknown keys, not omitted ones:

https://www.npmjs.com/package/zod#passthrough
By default Zod object schemas strip out unrecognized keys during parsing.
Instead, if you want to pass through unknown keys, use .passthrough().

[JacobWeisenburger]

https://github.com/colinhacks/zod#pickomit
.omit omits keys from the schema, not from the parsed/validated data. Therefore it makes b an unknown key, thus causing it to be passed through.

This is the way that I would do what you are trying to do:

const schema = z.object( { a: z.number(), b: z.number() } )
    .passthrough()
    .transform( ( { b, ...rest } ) => rest )

console.log( schema.parse( { a: 1, b: 2, z: 123 } ) )
// { a: 1, z: 123 }

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

[adrien-febvay]

Thanks, that's what I did on the last line of my code above.

It indeed makes sense from the schema point of view, but it's not intuitive and kind of misleading when the methods are in the following order:

z.object({ a: z.number(), b: z.number() }).passthrough().omit({ b: true })

There .passthrough() appears to apply to a schema where b was known. Therefore I expected it to remember the known keys when it was called, and then to refrain from copying them at parsing.

On the other hand, I didn't expect a transformation from .omit(), just to make the parsing ignore b and not pick it during parsing. I guess I messed up the title of this thread.

Having .passthrough() to take account of the schema on which it is called instead of another schema created later on would have made sense. It would also have been a nice way to perform a very simple transformation.

However, .passthrough().omit() would also removes the constraints on the omitted keys. It could be a win-win situation when you absolutely don't care about some keys, but one might see it as misleading too and prefer to keep all transformations in .transform().

Thanks again for your time.