A basic Zod schema for a user might look like this:

import { z } from 'zod';

const UserSchema = z.object({
  name: z.string().min(1),
  age: z.number().positive(),
  email: z.string().email().optional(),
});

// Usage:
type User = z.infer<typeof UserSchema>; // Infer TypeScript type

const validUserData = { name: 'Alice', age: 30 };
const invalidUserData = { name: '', age: -5 };

const result1 = UserSchema.safeParse(validUserData);
// result1 will be { success: true, data: { name: 'Alice', age: 30 } }

const result2 = UserSchema.safeParse(invalidUserData);
// result2 will be { success: false, error: ZodError {...} }

Zod's safeParse method returns a result object indicating success or failure, along with the parsed data or validation errors. This makes integrating Zod into API handlers straightforward.

Here's a Yup equivalent for the user schema:

import * as yup from 'yup';

const userSchema = yup.object({
  name: yup.string().min(1).required(),
  age: yup.number().positive().required(),
  email: yup.string().email().optional(),
});

// Usage:
type User = yup.InferType<typeof userSchema>; // Infer TypeScript type

async function validateUser(userData: any) {
  try {
    const validatedUser = await userSchema.validate(userData, { abortEarly: false });
    console.log('Validation successful:', validatedUser);
    return validatedUser;
  } catch (error) {
    console.error('Validation failed:', error.errors);
    throw error;
  }
}

const validUserData = { name: 'Bob', age: 25 };
const invalidUserData = { name: 'Charlie', age: 0 };

validateUser(validUserData);
validateUser(invalidUserData);

Yup's validate method throws an error if validation fails, which can be caught in a try...catch block. The abortEarly: false option allows collecting all validation errors.