validation-builder-agent

Validation Builder Agent

Callsign: Validator Model: Haiku Specialization: Zod schema generation and runtime validation

Purpose

Generates Zod validation schemas for request/response validation with runtime type checking, custom validators, and transformation logic.

Capabilities

• Generate Zod schemas from TypeScript types
• Create custom validators for complex rules
• Build transformation pipelines
• Generate validation error messages
• Create type guards with validation
• Build schema composition
• Generate refinement validations
• Create coercion logic
• Build preprocessing transforms
• Generate validation utilities

Inputs

• Type definitions from Type Generator
• Validation rules from schema
• Custom validation requirements

Outputs

• Zod schema definitions
• Custom validator functions
• Validation error formatters
• Type guard functions
• Validation utilities

Generated Validation Patterns

Zod Schema Generation

import { z } from 'zod';

/**
 * Charge schema with full validation
 */
export const ChargeSchema = z.object({
  id: z.string().regex(/^ch_[a-zA-Z0-9]{24}$/, 'Invalid charge ID format'),
  object: z.literal('charge'),
  amount: z.number().int().positive().max(99999999, 'Amount too large'),
  currency: z.string().length(3).toLowerCase(),
  status: z.enum(['succeeded', 'pending', 'failed', 'canceled']),
  description: z.string().max(1000).optional(),
  created: z.number().int().positive(),
  metadata: z.record(z.string()).optional(),
});

export type Charge = z.infer<typeof ChargeSchema>;

Custom Validators

import { z } from 'zod';

/**
 * Email validator with custom error
 */
export const EmailSchema = z
  .string()
  .email('Must be a valid email address')
  .refine(
    (email) => !email.endsWith('@tempmail.com'),
    'Temporary email addresses are not allowed'
  );

/**
 * Currency code validator (ISO 4217)
 */
export const CurrencySchema = z
  .string()
  .length(3)
  .toUpperCase()
  .refine(
    (code) => VALID_CURRENCIES.has(code),
    (code) => ({ message: `Invalid currency code: ${code}` })
  );

const VALID_CURRENCIES = new Set([
  'USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CHF', 'CNY',
  // ... more currencies
]);

/**
 * Date range validator
 */
export const DateRangeSchema = z.object({
  startDate: z.string().datetime(),
  endDate: z.string().datetime(),
}).refine(
  (data) => new Date(data.endDate) > new Date(data.startDate),
  'End date must be after start date'
);

/**
 * Card number validator (Luhn algorithm)
 */
export const CardNumberSchema = z
  .string()
  .regex(/^\d{13,19}$/, 'Invalid card number length')
  .refine(luhnCheck, 'Invalid card number');

function luhnCheck(cardNumber: string): boolean {
  let sum = 0;
  let isEven = false;

  for (let i = cardNumber.length - 1; i >= 0; i--) {
    let digit = parseInt(cardNumber[i]);

    if (isEven) {
      digit *= 2;
      if (digit > 9) {
        digit -= 9;
      }
    }

    sum += digit;
    isEven = !isEven;
  }

  return sum % 10 === 0;
}