Валидация через Zod

npm install zod

import { z } from 'zod';

const schema = z.object({
    title: z.string().min(3).max(200),
    body: z.string().min(10),
    published: z.boolean().optional().default(false),
});

export async function POST(request: Request) {
    const json = await request.json();
    const result = schema.safeParse(json);

    if (!result.success) {
        return Response.json(
            { errors: result.error.flatten().fieldErrors },
            { status: 422 }
        );
    }

    const post = await db.post.create({ data: result.data });
    return Response.json(post, { status: 201 });
}

type PostInput = z.infer<typeof schema>;

const schema = z.object({
    // строки
    title: z.string().min(3, 'Минимум 3').max(200, 'Максимум 200'),
    email: z.string().email('Некорректный email'),
    url: z.string().url('Некорректный URL'),
    uuid: z.string().uuid(),

    // числа
    age: z.number().int().min(18).max(120),
    price: z.number().positive(),

    // булевы
    published: z.boolean().default(false),

    // даты
    createdAt: z.date(),
    dateString: z.string().datetime(),

    // enum
    status: z.enum(['draft', 'published', 'archived']),

    // массивы
    tags: z.array(z.string()).min(1).max(10),

    // опциональные
    bio: z.string().optional(),
    phone: z.string().nullable(),

    // вложенные
    author: z.object({
        name: z.string(),
        email: z.string().email(),
    }),
});

const schema = z.object({
    published: z.string().transform((v) => v === 'true'),
    age: z.string().transform(Number),
    tags: z.string().transform((v) => v.split(',')),
});

const schema = z.object({
    page: z.coerce.number().int().min(1).default(1),
    published: z.coerce.boolean().default(false),
});

const schema = z.object({
    password: z.string().min(8),
    confirm: z.string(),
}).refine((data) => data.password === data.confirm, {
    message: 'Пароли не совпадают',
    path: ['confirm'],
});

const schema = z.object({
    start: z.date(),
    end: z.date(),
}).superRefine((data, ctx) => {
    if (data.end <= data.start) {
        ctx.addIssue({
            code: z.ZodIssueCode.custom,
            message: 'Конец должен быть после начала',
            path: ['end'],
        });
    }
});

const result = schema.safeParse(json);

if (!result.success) {
    const errors = result.error.flatten().fieldErrors;
    // { title: ['Минимум 3'], body: ['Минимум 10'] }

    return Response.json({ errors }, { status: 422 });
}

const QuerySchema = z.object({
    page: z.coerce.number().int().min(1).default(1),
    limit: z.coerce.number().int().min(1).max(100).default(20),
    search: z.string().optional(),
});

export async function GET(request: Request) {
    const { searchParams } = new URL(request.url);

    const result = QuerySchema.safeParse(Object.fromEntries(searchParams));

    if (!result.success) {
        return Response.json({ errors: result.error.flatten() }, { status: 422 });
    }

    const { page, limit, search } = result.data;
    // ...
}

const BaseSchema = z.object({
    title: z.string().min(3),
});

const CreateSchema = BaseSchema.extend({
    body: z.string().min(10),
});

const UpdateSchema = BaseSchema.partial();

const UserSchema = z.object({
    name: z.string(),
    email: z.string().email(),
    password: z.string().min(8),
});

const PublicUserSchema = UserSchema.omit({ password: true });
const AuthSchema = UserSchema.pick({ email: true, password: true });