Idiomatic way to chain model.parse

[drewwyatt]

👋 Love this library. Thank you so so much for all the amazing work.

I'm setting up an api endpoint that should validate incoming metrics. To do that, I've defined the following models:

const webVital = z.object({
  type: z.literal('web-vital'),
  payload: z.object({
    id: z.string(),
    label: z.union([z.literal('web-vital'), z.literal('custom')]),
    name: z.string(),
    startTime: z.number(),
    value: z.number(),
  }),
});

const pageReady = z.object({
  type: z.literal('page-ready'),
  payload: z.object({
    id: z.string(),
    page: z.string(),
    startTime: z.number(),
    value: z.number(),
  }),
});

export const metric = z.union([webVital, pageReady]);

In my APIGateWayHandler, event.body is either string | null. What I'd like to be able to do is define a model that will:

validate that it's a string => call JSON.parse => then try to parse that object with metric. Is there an idiomatic way to do that? This is what I've got so far (that I am unsure about because I don't think transforms are supposed to throw), but hopefully this shows what I'm trying to do?

export const event = z
  .string()
  .transform(str => {
    try {
      return JSON.parse(str);
    } catch {
      return null;
    }
  })
  .refine(obj => typeof obj === 'object')
  .transform(metric.parse);

[scotttrinh]

I'm not sure my opinions count as idioms, but I would personally consider this as multiple steps, rather than a pipeline from string. Aside from a few technical details, there isn't anything fundamentally wrong with your proposal.

If you keep it as a single pipelined schema, you'll want to update your example a bit:

export const event = z
  .string()
  .nullable() // Needs `nullable` so that it doesn't fail on `null`
  .transform(maybeString => { // just updated the name to be less certain about the stringiness
    try {
      return JSON.parse(maybeString);
    } catch {
      return null;
    }
  })
  .refine(obj => typeof obj === 'object') // Do you really want this? It will fail on some valid JSON values like `42` or `true`
  .transform(metric.parse);

Some helper/util/core module defines the JSON stuff:

const jsonStringSchema = z
  .string()
  .nullable()
  .refine((maybeString) => {
    try {
      JSON.parse(maybeString);
      return true;
    } catch (err) {
      return false;
    }
  })
  .transform(JSON.parse);

And then somewhere where you are handling these string | null bodies:

const parsedBody = jsonStringSchema.parse(event.body);
const metric = metric.parse(parsedBody);

In my setup, the jsonStringSchema usage would happen in some kind of middleware step since it's common among all of the handlers, but