Schemas and optionality

[mike-wheel]

Hey folks!

Rich Hickey talks about how most type systems (including zod and Typescript) conflate the ideas of schema and optionality. The issue is that a schema is a shape of an entity, regardless of optionality (undefined/null) which can differ at different call sites. We use .optional()/.nullable(), etc, when we define our schemas. This locks certain keys into being optional forever and ever, no matter what call site. In reality, some places require foo and some don't care about foo. This leads to type proliferation and divergence of types in places that should be able to leverage a shared schema.

(watch this part of this video for more details)

I was hoping zod had a concise way to update the optionality of a schema so that can we customize the requirements for each call site. The best I've found so far with zod is to define a schema without optionality, then use .partial() and .required() to select the required fields at a given call site.

const apiSchema = z.object({
  make: z.string(),
  model: z.string(),
  year: z.string()
})

const apiSchemaThatRequiresJustMake = apiSchema.partial().required({
  make: true
})

This is close, but it only works with undefineds. .partial() will make all fields .optional() and .required() will undo it for the fields that we care about. I don't see a zod equivalent to .partial() that makes each entry .nullable() or .nullish().

Another larger issue with it is that it doesn't extend deeply into aggregates. For example, if one of the keys was address and I only require the zip, this pattern breaks down.

const apiSchema = z.object({
  name: z.string(),
  address: z.object({
    street: z.string(),
    city: z.string(),
    state: z.string(),
    zip: z.string()
  })
});

const apiSchemaThatRequiresNameAndZip = apiSchema.partial().required({
  name: true,
  address: // ??? How to require just the zip here ???
})

// It would be nice to be able to do this:
const apiSchemaThatRequiresNameAndZip = apiSchema.partial().required({
  name: true,
  address: {
    zip: true;
  }
})

The ideal situation would be to have the ability to define schemas regardless of optionality and have tools to deeply specify only the required fields at each different call site.

Does anyone have any thoughts about this?