Photo by Rafif Prawira on Unsplash

Navigating TypeScript’s type system, especially with complex data structures, can feel like traversing a maze. Fear not, for we embark on a journey today to demystify the art of type predicates, comparing the ease of Zod against the traditional TypeScript approach.

The Old-fashioned Way: Vanilla TypeScript

Picture yourself in the heart of a coding labyrinth, tasked with validating a user object. Armed solely with vanilla TypeScript, you delve into the code:

export interface User {
  id: string;
  email: string;
  firstName: string;
  lastName: string;
}

export const isUser = (user: unknown): user is Company =>
  typeof company === 'object' &&
  !!company &&
  'id' in user &&
  typeof user.id === 'string' &&
  'email' in user &&
  typeof user.email === 'string' &&
  'firstName' in user &&
  typeof user.firstName === 'string' &&
  'lastName' in user &&
  typeof user.lastName === 'string' &&

you find yourself entangled in a web of typeof verifications, meticulously ensuring each property matches your expectations. It's a tedious journey, fraught with the danger of runtime errors looming at every turn.

Introducing Zod: A Modern Solution

But wait! There’s a beacon of hope on the horizon — Zod, a TypeScript-first validation library. With Zod at your disposal, you redefine your validation process:

import { z } from 'zod';

const userSchema = z
  .object({
    id: z.string(),
    email: z.string().email(),
    firstName: z.string(),
    lastName: z.string(),
  });

type User = z.infer<typeof userSchema>;

const isUser = (user: unknown): user is User => userSchema.safeParse(user).success;

With Zod, not only do you define concise schemas, articulating the essence of your data structures with clarity, but you also effortlessly generate types from these schemas. Validation becomes a breeze as you harness the power of, effortlessly discerning valid data from erroneous entries.

Conclusion: Striking a Balance

In the realm of TypeScript type predicates, simplicity is key. While the traditional TypeScript approach offers control, Zod provides a modern, streamlined solution, allowing for both schema definition and type generation. Choose your path wisely, and may your TypeScript adventures be both fruitful and straightforward!

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: Stackademic | CoFeed | Venture | Cubed
• More content at PlainEnglish.io