Value or undefined is not the same as an optional, and should not be a required property either

Discussed in https://github.com/colinhacks/zod/discussions/971

<div type='discussions-op-text'>

^{Originally posted by emanuel-lundman February 7, 2022}

type A = {
    b: string | undefined
}

is not the same as:

type A = {
    b?: string | undefined
}

The first requires undefined to be set, and can’t just be left out.

Zod though both seem to infer:

type A = {
    b: string | undefined
}

to an optional when writing the schema first and then inferring a type. And when doing the other way around, writing a schema for the type, thinks it’s required and only accepts the following:

type A = {
    b: string | undefined
}

const a = z.ZodScheme<A> = z.object({
    b: z.string()
})

even though it should be z.string().or(z.undefined()) But writing is it should be results in error: Property 'b' is optional in type '{ b?: string | undefined; }' but required in type 'A'

Am I missing something?</div>

[colinhacks]

Known design limitation. Technically property optionality should be defined on z.object somehow, since it’s not an inherent property of the child schema. But I decided a long time ago that question marks should get automatically added if an “or-undefined” schema is used in an object schema. Any other default behavior would be unacceptably verbose.

const base = z.object({
  hello: z.string().optional()
});  // {hello: string | optional}

base.partial({ hello: true })
// {hello?: string | optional}

The best API solution here is to add a method to ZodObject that removes the question marks if needed:

const base = z.object({
  hello: z.string().optional()
});  // {hello?: string | optional}

base.require({ hello: true })
// {hello: string | optional}

Thoughts?

[akomm]

It got even worser now btw. Now if you want a {[P in K]?: V} where undefined can not be assigned directly, you are screwed with this library, because it adds explicit | undefined everywhere, eliminating taking advantage of exactOptionalPropertyTypes, where you don’t want undefined assignment.