Built-in way to coerce null to undefined

[bluepnume]

Right now I'm doing something like this:

const coerceNullToUndefined = <Type>(value : Type | null | undefined) : Type | undefined => {
    return value === null ? undefined : value;
};

const apiResponseSchema = z.object({
    name: z.string().nullish().transform(coerceNullToUndefined)
});

That makes the resulting value a little more sane; I don't have to worry about dealing with both null and undefined.

It would be awesome if it was possible to have a built-in way to do this, like:

const apiResponseSchema = z.object({
    name: z.string().nullish().coerceNullToUndefined()
});

[JacobWeisenburger]

A little cleaner way to do this is:

const schema = z.string().nullish().transform( x => x ?? undefined )
type Data = z.infer<typeof schema>
// type Data = string | undefined

console.log( schema.parse( 'foo' ) ) // 'foo'
console.log( schema.parse( null ) ) // undefined
console.log( schema.parse( undefined ) ) // undefined

Because this is quite a simple and clean way to do this. I'm not sure we need a built-in way to do this. Thoughts?

[sschneider-ihre-pvs]

But what if you do something like z.coerce.date() with a null value? you would get 1970-01-01T00:00:00.000Z. how do you filter that out?

[JacobWeisenburger]

Is this what you are looking for?

const schema = z.union( [
    z.string(),
    z.number(),
    z.date(),
    z.null().transform( x => x ?? undefined ),
] ).pipe( z.coerce.date() )
type Data = z.infer<typeof schema>
// type Data = Date

console.log( schema.parse( '2024-03-05T00:00:00.000Z' ) ) // 2024-03-05T00:00:00.000Z
console.log( schema.parse( 1709596800000 ) )              // 2024-03-05T00:00:00.000Z
console.log( schema.parse( new Date( 1709596800000 ) ) )  // 2024-03-05T00:00:00.000Z

const result = schema.safeParse( null )
!result.success && console.log( result.error.issues )
// [
//     {
//         code: "invalid_date",
//         path: [],
//         message: "Invalid date",
//     }
// ]

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

[INDAPP]

What if I need to use this solution in the following situation?

const schema = z
  .enum(['it', 'es', 'fr', 'uk'])
  .nullish()
  .transform((x) => x ?? undefined)
  .default('it');
    
console.log({
  withValue: schema.safeParse('it'),
  withUndefined: schema.safeParse(undefined),
  withNull: schema.safeParse(null),
});

//     {
//       withValue: { success: true, data: 'it' },
//       withUndefined: { success: true, data: 'it' },
//       withNull: { success: true, data: undefined }
//     }

null value is successfully parsed but the result data is undefined.

I can use something like this:

const schema = z
  .enum(['it', 'es', 'fr', 'uk'])
  .nullish()
  .transform((x) => x ?? 'it');

but I don't understand why the default function doesn't work after transformation.

[digisomni]

I think we need a built-in way to coerce it from "unknown" values.

[JacobWeisenburger]

What is the "it" that you are coercing from "unknown" values?

[movahhedi]

Something built-in like .coerceUndefined would be nice.