Supercharging Zod: Extending Schemas for Advanced Validation

Introduction

Learn how to unlock the full potential of Zod by extending schemas with new properties and custom validation functions. This post provides practical techniques to enhance your TypeScript projects, making data validation more flexible and robust.

What is Zod?

Zod is a TypeScript-first schema declaration and validation library that helps ensure your data adheres to specified types. Its simplicity and type safety make it a popular choice among developers.

Why Extend Zod Schemas?

• Customization: Tailor schemas to fit specific application needs.
• Reusability: Create reusable components that can be shared across different parts of your application.
• Enhanced Validation: Implement complex validation logic that goes beyond basic checks.
• Customized Functionality: Take control of the flow and enhance the development experience.

How to Extend Zod Schemas

The very basics when it comes to extending a zod schema, is to use the .entend or .merge function on an existing zod schema.

import { z } from "zod";
 
const baseSchema = z.object({
  name: z.string(),
  age: z.number(),
});
 
// Extending the schema
const extendedSchema = baseSchema.extend({
  email: z.string().email(),
});

Where zod becomes really powerful, is when you define custom methods you can reuse in your other schemas.

/// myzod.ts
import * as z from "zod";
 
export * from "zod";
 
export function id() {
  return z
    .string()
    .uuid()
    .default(() => crypto.randomUUID());
}

/// myschema.ts
import * as z from "./myzod";
 
const User = z.object({
  id: z.id(),
  name: z.string().min(3),
});
 
User.parse({ name: "John Doe" });
// ^ { id: "random-uuid-here", name: "John Doe" }

This is great for reusability, but does not really extend the zod functionality, rather abstract it.

To really extend functionality, add on top of existing logic and create your own rules and set, make use of interface merging and the zod prototype objects.

/// myzod.ts
declare module "zod" {
  interface ZodString {
    world(): zod.ZodTypeAny;
  }
}
 
z.ZodString.prototype.world = function () {
  return this.default("Hello World!");
};

/// myschema.ts
import "./myzod"; // notice, we don't need to use it, just import it.
 
const schema = z.object({
  hello: z.string().world(),
});
 
console.log(schema.parse({}));
// ^ { hello: "Hello World!"}

This adds the posibility to alter the schema, add fields to the _def object and continue with the schema, trully extending the zod schema.

Conclusion

Extending Zod schemas opens up a world of possibilities for creating more powerful, flexible, and customized validation solutions in your TypeScript projects. By leveraging Zod's extensibility, you can craft schemas that not only validate data but also enhance your development workflow.

We've explored various techniques, from simple extensions and merges to more advanced custom methods and prototype modifications. These approaches allow you to:

• Create reusable validation logic
• Implement complex, application-specific rules
• Enhance type safety and reduce boilerplate code
• Improve code readability and maintainability

As you continue to work with Zod, remember that the true power lies in finding the right balance between built-in features and custom extensions. Start small, experiment with different approaches, and gradually build up your toolkit of custom Zod utilities. By mastering these techniques, you'll be well-equipped to handle even the most challenging data validation scenarios in your projects. The flexibility and expressiveness you gain will not only make your code more robust but also more enjoyable to write and maintain.

So go ahead, supercharge your Zod schemas, and take your TypeScript projects to the next level!