Research Zod Validation

---
name: research-zod-validation
description: Research Zod validation patterns, schema design, and TypeScript integration using Exa code search and Ref documentation
---

# Research Zod Validation Patterns

Use this skill when you need to:
- Learn Zod schema design patterns
- Understand validation error handling
- Research complex schema transformations
- Find type inference patterns
- Learn integration with forms and APIs

## Process

1. **Identify Validation Need**
   - Form validation?
   - API request/response validation?
   - Environment variables?
   - Complex transformations?

2. **Search Documentation (Ref)**
   ```
   Query patterns:
   - "Zod [schema type] validation"
   - "Zod error handling"
   - "Zod schema composition"
   - "Zod TypeScript integration"
   ```

3. **Find Implementation Examples (Exa)**
   ```
   Query patterns:
   - "Zod schema validation Next.js API route example"
   - "Zod React Hook Form integration validation"
   - "Zod complex nested schema transformation example"
   - "Zod custom error messages refinement example"
   ```

## Common Research Topics

### Basic Schemas
```typescript
// Documentation
Query: "Zod schema types string number object"

// Code examples
Query: "Zod schema validation string email number positive example"
```

### Schema Composition
```typescript
// Documentation
Query: "Zod schema composition extend merge pick omit"

// Code examples
Query: "Zod extend schema reuse base schema example"
```

### Transformations
```typescript
// Documentation
Query: "Zod transform preprocess coerce"

// Code examples
Query: "Zod transform string to date lowercase example"
```

### Refinements
```typescript
// Documentation
Query: "Zod refine superRefine custom validation"

// Code examples
Query: "Zod refine password confirmation match example"
```

### Error Handling
```typescript
// Documentation
Query: "Zod error handling format messages"

// Code examples
Query: "Zod parse safeParse error handling Next.js API example"
```

### Type Inference
```typescript
// Documentation
Query: "Zod infer TypeScript types"

// Code examples
Query: "Zod infer schema to TypeScript type example"
```

## Integration Patterns

### React Hook Form
```typescript
// Documentation
Query: "Zod React Hook Form resolver integration"

// Code examples
Query: "Zod React Hook Form validation zodResolver example"
```

### Next.js API Routes
```typescript
// Documentation
Query: "Zod Next.js API validation"

// Code examples
Query: "Zod Next.js route handler request body validation example"
```

### Server Actions
```typescript
// Documentation
Query: "Zod Next.js server actions validation"

// Code examples
Query: "Zod server action FormData validation example"
```

### Environment Variables
```typescript
// Documentation
Query: "Zod environment variables validation"

// Code examples
Query: "Zod env validation t3-env Next.js example"
```

## Advanced Patterns

### Discriminated Unions
```
Query: "Zod discriminated union schema validation example"
```

### Recursive Schemas
```
Query: "Zod recursive schema tree structure validation example"
```

### Async Validation
```
Query: "Zod async validation refine database check example"
```

### Schema Merging
```
Query: "Zod merge schemas partial update validation example"
```

### Custom Error Messages
```
Query: "Zod custom error messages field-specific validation example"
```

## Form Validation Patterns

### Multi-step Forms
```
Query: "Zod multi-step form validation partial schema example"
```

### Dynamic Fields
```
Query: "Zod array schema dynamic form fields validation example"
```

### File Uploads
```
Query: "Zod file validation size type validation example"
```

## API Validation Patterns

### Request Validation
```
Query: "Zod API request body query params validation example"
```

### Response Validation
```
Query: "Zod API response schema validation type guard example"
```

### Error Responses
```
Query: "Zod validation error API response format example"
```

## Output Format

Provide:
1. **Schema examples** - Different schema patterns
2. **Type inference** - How TypeScript types are generated
3. **Error handling** - Best practices for user-friendly errors
4. **Integration code** - How to use with forms/APIs
5. **Performance tips** - When to use parse vs safeParse
6. **Common patterns** - Reusable schema utilities

## Project Context

Your project uses:
- Zod 3.25.76
- React Hook Form 7.61.1
- Next.js API routes and Server Actions
- TypeScript strict mode
- @t3-oss/env-nextjs for environment validation

## Common Use Cases

### User Registration
```
Research: "Zod user registration schema email password validation"
```

### Profile Updates
```
Research: "Zod partial schema optional fields validation"
```

### API Integration
```
Research: "Zod API schema validation error handling Next.js"
```

### Configuration
```
Research: "Zod config schema environment variables validation"
```

## When to Use

- Validating form inputs
- Validating API requests/responses
- Type-safe environment variables
- Runtime type checking
- Data transformations
- Parsing external data
- Schema documentation

## Type Safety Best Practices

Research:
- Type inference vs explicit types
- Generic schema functions
- Schema as single source of truth
- Integration with API types

```
Query: "Zod TypeScript best practices type inference patterns"
```

## Related Skills

- research-typescript (for type patterns)
- research-nextjs (for API integration)
- research-react (for form integration)