zod-patterns

Zod Schema Patterns

Basic Pattern

import { z } from 'zod'
import { createZodDto } from 'nestjs-zod'

// Define Schema
export const MySchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
})

// Create DTO class
export class MyDto extends createZodDto(MySchema) {}

// Partial DTO for updates
export class PartialMyDto extends createZodDto(MySchema.partial()) {}

Project Custom Validators

Location: apps/core/src/shared/schema/base.schema.ts

import {
  zMongoId,           // MongoDB ObjectId validation
  zNonEmptyString,    // Non-empty string
  zArrayUnique,       // Unique array elements
  zPinDate,           // Pin date validation
} from '~/shared/schema/base.schema'

const Schema = z.object({
  id: zMongoId,
  title: zNonEmptyString,
  tags: zArrayUnique(z.string()),
  pin: zPinDate,
})

Extending Base Schemas

import { WriteBaseSchema } from '~/shared/schema/write-base.schema'
import { ImageSchema } from '~/shared/schema/image.schema'

// Extend WriteBaseSchema (includes title, text, images, etc.)
export const PostSchema = WriteBaseSchema.extend({
  slug: zNonEmptyString,
  categoryId: zMongoId,
  tags: zArrayUnique(z.string()).optional(),
})

Common Patterns

Optional Fields with Defaults

z.boolean().default(true).optional()
z.number().default(0).optional()
z.array(z.string()).default([]).optional()

Preprocessing

// Empty string to null
z.preprocess(
  (val) => (val === '' ? null : val),
  z.string().nullable()
).optional()

// String to number
z.preprocess(
  (val) => (typeof val === 'string' ? parseInt(val, 10) : val),
  z.number()
)

Union Types

z.union([z.string(), z.number()])
z.enum(['draft', 'published', 'archived'])

Array Validation

// Basic array
z.array(z.string())

// Length constraints
z.array(z.string()).min(1).max(10)

// Unique elements
zArrayUnique(z.string())

Nested Objects

const AddressSchema = z.object({
  street: z.string(),
  city: z.string(),
})

const UserSchema = z.object({
  name: z.string(),
  address: AddressSchema.optional(),
  addresses: z.array(AddressSchema).optional(),
})

Conditional Validation

// refine for custom validation
z.object({
  password: z.string(),
  confirmPassword: z.string(),
}).refine(
  (data) => data.password === data.confirmPassword,
  { message: 'Passwords must match' }
)

Mapping to TypeGoose Models

// Model
export class PostModel extends WriteBaseModel {
  @prop({ required: true })
  slug!: string

  @prop({ type: () => [String] })
  tags?: string[]
}

// Schema
export const PostSchema = WriteBaseSchema.extend({
  slug: zNonEmptyString,           // Maps to required
  tags: z.array(z.string()).optional(), // Maps to optional field
})

Type Inference

// Infer type from Schema
type MyType = z.infer<typeof MySchema>

// Use in Service
async create(data: z.infer<typeof MySchema>) {
  return this.model.create(data)
}