Convert Nested JSON Objects to Zod Schemas

Handling Nested Structures with Zod

Real-world JSON is rarely flat. APIs typically return objects inside objects, and each level of nesting maps to a separate Zod schema constant that can be composed together.

Example JSON

{
  "id": 1,
  "name": "Acme Corp",
  "address": {
    "street": "123 Main St",
    "city": "Springfield",
    "geo": {
      "lat": 39.7817,
      "lng": -89.6501
    }
  }
}

Generated Zod Schema

import { z } from "zod";

const geoSchema = z.object({
  lat: z.number(),
  lng: z.number(),
});

const addressSchema = z.object({
  street: z.string(),
  city: z.string(),
  geo: geoSchema,
});

const companySchema = z.object({
  id: z.number().int(),
  name: z.string(),
  address: addressSchema,
});

type Geo = z.infer<typeof geoSchema>;
type Address = z.infer<typeof addressSchema>;
type Company = z.infer<typeof companySchema>;

Why Separate Schemas?

Extracting each nested object into its own schema provides several benefits:

1. Reusability — geoSchema can be reused anywhere coordinates appear (e.g., store locations, event venues).
2. Composability — Zod schemas compose naturally. You can extend, merge, or pick fields from existing schemas.
3. Testability — You can validate addressSchema independently of companySchema, making unit tests simpler.
4. Readability — Deeply nested inline schemas quickly become unreadable.

Schema Composition Methods

Zod provides powerful composition tools:

// Extend a schema
const detailedAddressSchema = addressSchema.extend({
  zipCode: z.string(),
});

// Merge two schemas
const fullSchema = addressSchema.merge(contactSchema);

// Pick specific fields
const locationSchema = addressSchema.pick({ city: true, geo: true });

These composition patterns let you build complex validation from simple, tested building blocks.