Request Validation
Developmentrequest-validationRequest Validation is an Agent Skill for development published in the dadbodgeoff/drift repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Validate API requests with schemas, sanitization, and helpful error messages. Covers Zod, Joi, and Pydantic patterns.
QUICK START
How to use this skill
Bring this guide into your coding agent with a prompt tailored to the tool you use.
- Open your project in Codex.
- Copy and paste the prompt below.
- Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/dadbodgeoff/drift/blob/HEAD/drift v1 depreciated/skills/request-validation/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/request-validation, but wait for my approval before writing files or running scripts.
Copying this prompt does not install or run the skill. Review third-party files before use.
Request Validation
Never trust user input. Validate everything.
When to Use This Skill
- All API endpoints accepting user input
- Form submissions
- File uploads
- Query parameters
- Webhook payloads
TypeScript Implementation (Zod)
Schema Definition
// schemas/user.ts
import { z } from 'zod';
export const createUserSchema = z.object({
email: z.string().email('Invalid email address'),
password: z
.string()
.min(8, 'Password must be at least 8 characters')
.regex(/[A-Z]/, 'Password must contain uppercase letter')
.regex(/[0-9]/, 'Password must contain a number'),
name: z.string().min(1).max(100).trim(),
role: z.enum(['user', 'admin']).default('user'),
metadata: z.record(z.string()).optional(),
});
export const updateUserSchema = createUserSchema.partial().omit({ password: true });
export const userIdSchema = z.object({
id: z.string().uuid('Invalid user ID'),
});
export const listUsersSchema = z.object({
page: z.coerce.number().int().positive().default(1),
limit: z.coerce.number().int().min(1).max(100).default(20),
search: z.string().max(100).optional(),
role: z.enum(['user', 'admin']).optional(),
sortBy: z.enum(['name', 'createdAt', 'email']).default('createdAt'),
sortOrder: z.enum(['asc', 'desc']).default('desc'),
});
// Infer types from schemas
export type CreateUserInput = z.infer<typeof createUserSchema>;
export type UpdateUserInput = z.infer<typeof updateUserSchema>;
export type ListUsersQuery = z.infer<typeof listUsersSchema>;
Validation Middleware
// middleware/validate.ts
import { Request, Response, NextFunction } from 'express';
import { ZodSchema, ZodError } from 'zod';
interface ValidationSchemas {
body?: ZodSchema;
query?: ZodSchema;
params?: ZodSchema;
}
function validate(schemas: ValidationSchemas) {
return async (req: Request, res: Response, next: NextFunction) => {
const errors: Array<{ field: string; message: string }> = [];
try {
if (schemas.body) {
req.body = schemas.body.parse(req.body);
}
if (schemas.query) {
req.query = schemas.query.parse(req.query);
}
if (schemas.params) {
req.params = schemas.params.parse(req.params);
}
next();
} catch (error) {
if (error instanceof ZodError) {
const formattedErrors = error.errors.map(err => ({
field: err.path.join('.'),
message: err.message,
}));
return res.status(400).json({
error: 'Validation failed',
details: formattedErrors,
});
}
next(error);
}
};
}
export { validate };
Route Usage
// routes/users.ts
import { validate } from '../middleware/validate';
import { createUserSchema, userIdSchema, listUsersSchema } from '../schemas/user';
router.post(
'/users',
validate({ body: createUserSchema }),
async (req, res) => {
// req.body is typed and validated
const user = await userService.create(req.body);
res.status(201).json(user);
}
);
router.get(
'/users/:id',
validate({ params: userIdSchema }),
async (req, res) => {
const user = await userService.findById(req.params.id);
res.json(user);
}
);
router.get(
'/users',
validate({ query: listUsersSchema }),
async (req, res) => {
// req.query is typed with defaults applied
const users = await userService.list(req.query);
res.json(users);
}
);
Custom Validators
// schemas/custom.ts
import { z } from 'zod';
// Phone number with formatting
export const phoneSchema = z
.string()
.transform(val => val.replace(/\D/g, ''))
.refine(val => val.length >= 10 && val.length <= 15, 'Invalid phone number');
// Slug (URL-safe string)
export const slugSchema = z
.string()
.min(1)
.max(100)
.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, 'Invalid slug format');
// Date string to Date object
export const dateSchema = z
.string()
.datetime()
.transform(val => new Date(val));
// Sanitized HTML (strip dangerous tags)
export const safeHtmlSchema = z
.string()
.transform(val => sanitizeHtml(val, { allowedTags: ['b', 'i', 'em', 'strong', 'a', 'p'] }));
// File upload validation
export const fileSchema = z.object({
mimetype: z.enum(['image/jpeg', 'image/png', 'application/pdf']),
size: z.number().max(10 * 1024 * 1024, 'File too large (max 10MB)'),
originalname: z.string(),
});
Python Implementation (Pydantic)
# schemas/user.py
from pydantic import BaseModel, EmailStr, Field, field_validator
from typing import Optional
from enum import Enum
class UserRole(str, Enum):
user = "user"
admin = "admin"
class CreateUserInput(BaseModel):
email: EmailStr
password: str = Field(min_length=8)
name: str = Field(min_length=1, max_length=100)
role: UserRole = UserRole.user
metadata: Optional[dict[str, str]] = None
@field_validator('password')
@classmethod
def password_strength(cls, v: str) -> str:
if not any(c.isupper() for c in v):
raise ValueError('Password must contain uppercase letter')
if not any(c.isdigit() for c in v):
raise ValueError('Password must contain a number')
return v
@field_validator('name')
@classmethod
def strip_name(cls, v: str) -> str:
return v.strip()
class UpdateUserInput(BaseModel):
email: Optional[EmailStr] = None
name: Optional[str] = Field(None, min_length=1, max_length=100)
role: Optional[UserRole] = None
class ListUsersQuery(BaseModel):
page: int = Field(default=1, ge=1)
limit: int = Field(default=20, ge=1, le=100)
search: Optional[str] = Field(None, max_length=100)
role: Optional[UserRole] = None
FastAPI Usage
# routes/users.py
from fastapi import APIRouter, Query, Path, HTTPException
from schemas.user import CreateUserInput, UpdateUserInput, ListUsersQuery
router = APIRouter()
@router.post("/users", status_code=201)
async def create_user(data: CreateUserInput):
# data is validated and typed
user = await user_service.create(data.model_dump())
return user
@router.get("/users/{user_id}")
async def get_user(user_id: str = Path(pattern=r'^[0-9a-f-]{36}$')):
user = await user_service.find_by_id(user_id)
if not user:
raise HTTPException(404, "User not found")
return user
@router.get("/users")
async def list_users(
page: int = Query(default=1, ge=1),
limit: int = Query(default=20, ge=1, le=100),
search: str = Query(default=None, max_length=100),
):
return await user_service.list(page=page, limit=limit, search=search)
Error Response Format
{
"error": "Validation failed",
"details": [
{ "field": "email", "message": "Invalid email address" },
{ "field": "password", "message": "Password must be at least 8 characters" }
]
}
Best Practices
- Validate at the edge - Before any business logic
- Use schema inference - Don't duplicate types
- Provide helpful messages - Tell users how to fix errors
- Sanitize strings - Trim whitespace, escape HTML
- Set sensible defaults - Reduce required fields
Common Mistakes
- Validating after database operations
- Generic error messages ("Invalid input")
- Not validating query parameters
- Missing max length on strings (DoS vector)
- Not sanitizing HTML content