Zod Schema Validator

import { z } from 'zod';

const passwordSchema = z
  .string()
  .min(8, 'Password must be at least 8 characters')
  .regex(/[0-9]/, 'Password must contain a number')
  .regex(/[^a-zA-Z0-9]/, 'Password must contain a special character');

const userRegistrationSchema = z.object({
  email: z.string().email('Invalid email address'),
  password: passwordSchema,
  confirmPassword: z.string(),
  age: z.number().int().min(18, 'Must be 18 or older').max(100),
  phone: z.string().regex(/^\+?[1-9]\d{1,14}$/).optional(),
  acceptTerms: z.literal(true, {
    errorMap: () => ({ message: 'You must accept the terms' }),
  }),
}).refine((data) => data.password === data.confirmPassword, {
  message: 'Passwords do not match',
  path: ['confirmPassword'],
});

type UserRegistration = z.infer<typeof userRegistrationSchema>;

// Usage
const result = userRegistrationSchema.safeParse({
  email: 'user@example.com',
  password: 'SecureP@ss1',
  confirmPassword: 'SecureP@ss1',
  age: 25,
  acceptTerms: true,
});

if (!result.success) {
  console.error(result.error.format());
} else {
  console.log('Valid user:', result.data);
}

import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';

const formSchema = z.object({
  name: z.string().min(2, 'Name must be at least 2 characters'),
  email: z.string().email(),
  address: z.object({
    street: z.string().min(5),
    city: z.string().min(2),
    state: z.string().length(2, 'Use 2-letter state code'),
    zip: z.string().regex(/^\d{5}(-\d{4})?$/, 'Invalid ZIP code'),
  }),
});

type FormData = z.infer<typeof formSchema>;

export function RegistrationForm() {
  const {
    register,
    handleSubmit,
    formState: { errors },
  } = useForm<FormData>({
    resolver: zodResolver(formSchema),
  });

  const onSubmit = (data: FormData) => {
    console.log('Valid form data:', data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...register('name')} />
      {errors.name && <span>{errors.name.message}</span>}

      <input {...register('email')} />
      {errors.email && <span>{errors.email.message}</span>}

      <input {...register('address.street')} placeholder="Street" />
      {errors.address?.street && <span>{errors.address.street.message}</span>}

      {/* ... other fields ... */}

      <button type="submit">Submit</button>
    </form>
  );
}

import { z } from 'zod';
import { Request, Response, NextFunction } from 'express';

const createUserSchema = z.object({
  body: z.object({
    name: z.string().min(2),
    email: z.string().email(),
    role: z.enum(['user', 'admin']).default('user'),
  }),
  query: z.object({
    sendWelcomeEmail: z
      .string()
      .transform((val) => val === 'true')
      .default('false'),
  }),
});

type CreateUserRequest = z.infer<typeof createUserSchema>;

export const validateRequest =
  (schema: z.ZodSchema) =>
  async (req: Request, res: Response, next: NextFunction) => {
    try {
      const result = await schema.parseAsync({
        body: req.body,
        query: req.query,
        params: req.params,
      });

      req.body = result.body;
      req.query = result.query as any;
      next();
    } catch (error) {
      if (error instanceof z.ZodError) {
        res.status(400).json({
          error: 'Validation failed',
          details: error.format(),
        });
      } else {
        next(error);
      }
    }
  };

// Usage
app.post('/users', validateRequest(createUserSchema), async (req, res) => {
  const { name, email, role } = req.body;
  // Data is validated and typed
  const user = await createUser({ name, email, role });
  res.json(user);
});

import { z } from 'zod';

const creditCardPayment = z.object({
  method: z.literal('credit_card'),
  cardNumber: z.string().regex(/^\d{16}$/),
  expiryMonth: z.number().min(1).max(12),
  expiryYear: z.number().min(2025),
  cvv: z.string().regex(/^\d{3,4}$/),
});

const paypalPayment = z.object({
  method: z.literal('paypal'),
  email: z.string().email(),
});

const cryptoPayment = z.object({
  method: z.literal('crypto'),
  walletAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
  cryptocurrency: z.enum(['BTC', 'ETH', 'USDC']),
});

const paymentSchema = z.discriminatedUnion('method', [
  creditCardPayment,
  paypalPayment,
  cryptoPayment,
]);

type Payment = z.infer<typeof paymentSchema>;

// TypeScript knows the shape based on method
function processPayment(payment: Payment) {
  switch (payment.method) {
    case 'credit_card':
      return chargeCreditCard(payment.cardNumber, payment.cvv);
    case 'paypal':
      return chargePayPal(payment.email);
    case 'crypto':
      return chargeCrypto(payment.walletAddress);
  }
}