zod-deep-extend

zod-deep-extend is a powerful utility for extending Zod schemas in a deep and recursive manner. It provides a simple and efficient way to add new fields to your existing Zod schemas, even for nested objects. This package is built on top of the Zod library, a TypeScript-first schema declaration and validation library.

Installation

You can install zod-deep-extend via npm:

npm install zod-deep-extend

Or via pnpm:

pnpm add zod-deep-extend

Usage

First, import the deepExtend function from the package:

import { deepExtend } from 'zod-deep-extend';

Then, define your original Zod schema:

import { z } from 'zod';

const originalSchema = z.object({
  name: z.string(),
  address: z.object({
    city: z.string(),
  }),
});

Now, you can extend your schema using deepExtend:

const extendedSchema = deepExtend(originalSchema, {
  email: z.string().email(),
  age: z.number().int(),
  address: z.object({
    street: z.string(),
    zip: z.string(),
    state: z.string()
  }),
});

You can now use your extended schema for validation:

const data = {
  name: 'John',
  age: 30,
  email: '[e-mail]',
  address: {
    street: '123 Main St',
    city: 'New York',
    state: 'NY',
    zip: '10001',
  },
};

const result = extendedSchema.safeParse(data);

if (result.success) {
  console.log('Data is valid!');
} else {
  console.log('Data is invalid:', result.error);
}

Why use zod-deep-extend?

Without zod-deep-extend, the above example would require accessing the internal shape of the original schema:

const extendedSchema = originalSchema.extend({
  email: z.string().email(),
  age: z.number().int(),
  address: originalSchema.shape.address.extend({
    street: z.string(),
    zip: z.string(),
    state: z.string()
  }),
});

This isn't so bad here, but it can get messy with a more complicated schema:

const extendedSchema = originalSchema.extend({
  profile: originalSchema.shape.profile.extend({
    preferences: originalSchema.shape.profile.shape.preferences.extend({
      game: originalSchema.shape.profile.shape.preferences.shape.game.extend({
        stats: originalSchema.shape.profile.shape.preferences.shape.game.shape.stats.extend({
          gameQuestionsAnswered: z.number(),
        }),
      }),
    }),
  }),
});

With zod-deep-extend, you can simply do this:

const extendedSchema = deepExtend(originalSchema, {
  profile: {
    preferences: {
      game: {
        stats: {
          gameQuestionsAnswered: z.number(),
        },
      },
    },
  },
});

Features

• Deeply extend your Zod schemas with new fields.
• Supports nested object schemas.
• Maintains the original schema's type safety.
• Provides clear error messages for invalid extensions.
• Fully compatible with all Zod types.

Contributing

Contributions are always welcome. Feel free to open a pull request or a issue.

License

MIT

Conclusion

zod-deep-extend is a handy tool for those who want to extend their Zod schemas in a deep and recursive way. It simplifies the process of adding new fields to your schemas, making your code cleaner and easier to maintain. Try it out today!