How to have .optional() survive during transform()

[sp88011]

How would I keep a property as truly optional ({ a?:..}) in my resulting object after doing a .transform().

Take the example below, the property is correctly inferred as optional (a?:...) after parsing but before transforming.
However, after transforming, it no longer is optional.

const objectA = z.object({ a: z.number().optional() })

type A = z.infer<typeof objectA>;
// { a?: number  | undefined } <-- optional


const objectB = z.object({ a: z.number().optional() }).transform((x) => {
  return { a: x.a?.toString() };
});


type B = z.infer<typeof objectB>;
// { a: string  | undefined } <-- no longer optional

[JacobWeisenburger]

Is this what you are looking for?

const objectA = z.object( { a: z.number().optional() } )

type A = z.infer<typeof objectA>
// type A = { a?: number | undefined }

const objectB = z.object( { a: z.number().optional() } ).transform( ( x ) => {
    const a = x.a?.toString()
    if ( a ) return { a }
    return {}
} )

type B = z.infer<typeof objectB>
// type B = { a: string } | { a?: undefined }

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

[carlos-lopez-SaRa]

This comment saved my bacon, I had to do this to work around the issue itself, basically I had to typecast the object before merging it with the return of the transform:

[sp88011]

Thanks! Yes, that's technically the result I want..but I'm not clear about the way to get there outside of this simple example.

I'm transforming many properties at once, some of which may be undefined. How would I do this with many properties?

const objectB = z.object( {
 a: z.number().optional(),
b: z.string().optional(),
c. z.string(),
...
x: z.string().optional(),
})

.transform( ( x ) => {

// a should be {a?: undefined}
// b should be {b?: undefined}
// c should be {c: string}
//etc.

} )

[JacobWeisenburger]

In zod, an optional property means that it could be undefined. I understand that it is confusing, because in typescript undefined and optional are 2 similar things, but not the same.