Zod Advanced Patterns — z.any() Hid a 3-Week Schema Change

import { z } from 'zod';

// Each variant has a z.literal() discriminator
const CardPaymentSchema = z.object({
  type: z.literal('card'),
  last4: z.string().length(4),
  brand: z.enum(['visa', 'mastercard', 'amex']),
  expiryMonth: z.number().int().min(1).max(12),
  expiryYear: z.number().int().min(2024),
});

const BankPaymentSchema = z.object({
  type: z.literal('bank'),
  accountNumber: z.string().regex(/^\*{4}\d{4}$/),
  routingNumber: z.string().length(9),
  bankName: z.string().min(1),
});

const CryptoPaymentSchema = z.object({
  type: z.literal('crypto'),
  walletAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  network: z.enum(['ethereum', 'polygon', 'arbitrum']),
  token: z.string().min(1),
});

// Discriminated union — validates 'type' first
 export const PaymentSchema = z.discriminatedUnion('type', [
  CardPaymentSchema,
  BankPaymentSchema,
  CryptoPaymentSchema,
]);

export type Payment = z.infer<typeof PaymentSchema>;

export function processPayment(raw: unknown) {
  const result = PaymentSchema.safeParse(raw);
  if (!result.success) throw new Error('Invalid payment');
  const payment = result.data;
  switch (payment.type) {
    case 'card': return chargeCard(payment.last4, payment.brand);
    case 'bank': return debitBank(payment.accountNumber, payment.routingNumber);
    case 'crypto': return transferCrypto(payment.walletAddress, payment.network);
  }
}

import { z } from 'zod';

function getMaxDepth(node: unknown, depth = 0): number {
  if (!node || typeof node !== 'object') return depth;
  const children = (node as any).children;
  if (!Array.isArray(children)) return depth;
  return Math.max(...children.map((c: any) => getMaxDepth(c, depth + 1)), depth);
}

const CommentBase = z.object({
  id: z.string().uuid(),
  author: z.string().min(1).max(100),
  content: z.string().min(1).max(10000),
  createdAt: z.string().datetime(),
});

export interface Comment extends z.infer<typeof CommentBase> {
  children: Comment[];
}

export const CommentSchema: z.ZodType<Comment> = CommentBase.extend({
  children: z.lazy(() => z.array(CommentSchema)).default([]),
}).superRefine((data, ctx) => {
  const depth = getMaxDepth(data);
  if (depth > 10) ctx.addIssue({ code: 'custom', message: `Max depth 10 exceeded (got ${depth})`, path: ['children'] });
});

import { z } from 'zod';

// Zod 4: coerce is preferred over preprocess for primitives
const PaginationSchema = z.object({
  page: z.coerce.number().int().positive().default(1),
  limit: z.coerce.number().int().min(1).max(100).default(20),
});

// String → Date → validate future date with .pipe()
const FutureDateSchema = z.string().datetime()
  .pipe(z.coerce.date())
  .pipe(z.date().min(new Date()));

const EventSchema = z.object({
  id: z.string().uuid(),
  title: z.string().min(1).max(200),
  startsAt: z.string().datetime().pipe(z.coerce.date()),
  endsAt: z.string().datetime().pipe(z.coerce.date()),
}).transform(event => ({
  ...event,
  durationMinutes: Math.round((event.endsAt.getTime() - event.startsAt.getTime()) / 60000),
  isPast: event.endsAt < new Date(),
}));

// Flatten nested API
const ApiUserSchema = z.object({
  data: z.object({ user: z.object({
    id: z.string().uuid(),
    profile: z.object({ firstName: z.string(), lastName: z.string() })
  })})
}).transform(({data}) => ({
  id: data.user.id,
  fullName: `${data.user.profile.firstName} ${data.user.profile.lastName}`,
}));

import { z } from 'zod';

// Zod 4 nominal types
 export const UserId = z.string().uuid().brand<'UserId'>();
export type UserId = z.infer<typeof UserId>;

const BaseUser = z.object({
  id: UserId,
  email: z.string().email(),
  createdAt: z.string().datetime(),
});

export const UserWithProfile = BaseUser.extend({
  firstName: z.string().min(1),
  lastName: z.string().min(1),
  avatar: z.string().url().nullable(),
});

export const UserPublic = UserWithProfile.pick({ id: true, firstName: true, lastName: true, avatar: true });
export const UserUpdate = UserWithProfile.partial(); // PATCH

import { z } from 'zod';

const Password = z.string().superRefine((pw, ctx) => {
  if (pw.length < 8) ctx.addIssue({code:'custom', message:'Min 8 chars'});
  if (!/[A-Z]/.test(pw)) ctx.addIssue({code:'custom', message:'Need uppercase'});
  if (!/[0-9]/.test(pw)) ctx.addIssue({code:'custom', message:'Need number'});
});

// Async refinement — Zod 4
const UniqueEmail = z.string().email().superRefine(async (email, ctx) => {
  const exists = await db.user.count({ where: { email } });
  if (exists) ctx.addIssue({ code:'custom', message:'Email taken' });
});

// Must use parseAsync for async refinements
export const Register = z.object({
  email: UniqueEmail,
  password: Password,
  confirm: z.string()
}).refine(d => d.password === d.confirm, { error: 'Passwords must match', path: ['confirm'] });

import { z } from 'zod';

// Zod 4 global config
z.config({
  customError: (issue) => {
    if (issue.code === 'invalid_type' && issue.expected === 'string') return 'Required';
    if (issue.code === 'too_small') return `Min ${issue.minimum}`;
    return undefined;
  }
});

const Contact = z.object({
  name: z.string({ error: 'Name is required' }).min(1).max(100),
  email: z.string({ error: 'Valid email required' }).email(),
});

export function parseForm(schema, data) {
  const result = schema.safeParse(data);
  if (!result.success) return { success: false, errors: result.error.flatten().fieldErrors };
  return { success: true, data: result.data };
}