transform old data to new data format unless it comes in new format already

[pke]

My server currently sends an array of old structured data and my client would like to work with new structured data already so when the server switches to new data the client is already ready and can handle it.
During the transitioning period the client is able to handle both old and new data.

I am currently doing this, but it lacks strong typing of

const OldSchema = z
  .object({
    iccsn: z.string(),
    cardAccessNumber: z.string().length(6),
  })
  .transform(({ iccsn, cardAccessNumber }) => ({
    id: iccsn,
    can: cardAccessNumber,
  }))

const OldSchemaArray = z.array(OldSchema)

type OldData = z.input<typeof Schema>
type NewData = z.output<typeof Schema>

function transformCards(cards: OldData[] = []): NewData[] {
  return SchemaArray.parse(cards)
}

I am transforming into the new data schema, however the new data schema is not strictly defined. I'd like to defined a proper zod schema for new data too and then have the parse function to be able to detect if the input data is of the old format (and will be transformed) or is already in the new format and will just be parsed & checked.

Is this possible with maybe unions and pipes?

[Roman86]

yes, unions and pipes are exactly the right tool. The pattern is: the new schema as-is, .or() the old schema with a .transform() that maps old fields to new, then .pipe(NewSchema) so the transformed result is re-validated (and fully typed):

const NewCard = z.object({ id: z.string(), can: z.string() });

const OldCard = z.object({ iccsn: z.string(), cardAccessNumber: z.string() });

const Card = NewCard.or(
  OldCard.transform(({ iccsn, cardAccessNumber }) => ({
    id: iccsn,
    can: cardAccessNumber,
  })).pipe(NewCard),
);
// z.infer<typeof Card> is the new shape, old input is migrated on parse

The .pipe(NewCard) at the end is what gives you the strong typing you were missing — without it the transform's output is unchecked.

I ran into this often enough that I packaged the pattern into a small utility, zod-funnel: you declare the canonical schema once and attach each legacy shape with a type-checked mapper (funnel(NewCard).from(OldCard, map)), and the re-validation can't be forgotten. Under the hood it builds the same flat union, so behavior and performance match the hand-written version.