0Pricing
TypeScript Academy · Aula

Validação de esquemas com zod e inferência para TS

Valide requisições com zod; infira tipos TypeScript a partir dos esquemas; adicione middleware e tratamento de erros seguros.

Validação de esquemas com zod e inferência para TS é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 3 aulas no total.

Introdução

Objetivo: valide dados recebidos com zod e mantenha os tipos do TypeScript sincronizados por meio de z.infer. Você analisará os dados com segurança, enviará erros úteis e integrará a validação a uma camada intermediária.

  • Defina os esquemas uma única vez
  • Infira os tipos de TS
  • safeParse + erros 400

Esquema e inferência

Modele uma vez com zod. O tipo derivado type User = z.infer<typeof userSchema> reproduz exatamente a validação.

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().regex(/^u_[a-z0-9]+$/),
  name: z.string().min(1),
  age: z.number().int().nonnegative().optional()
})

export type User = z.infer<typeof userSchema>

// Reuse `User` across handlers, services, and tests

safeParse no manipulador

Use safeParse para evitar exceções; retorne 400 com os problemas formatados. O tipo da resposta reflete tanto as estruturas de sucesso quanto as de erro.

import { Request, Response } from "express"
import { userSchema, User } from "./schema"

export function createUser(req: Request<{}, User, unknown>, res: Response<User | { error: string; issues?: unknown }>) {
  const parsed = userSchema.safeParse(req.body)
  if (!parsed.success) {
    return res.status(400).json({ error: "Invalid body", issues: parsed.error.format() })
  }
  const user = parsed.data
  return res.status(201).json(user)
}

Auxiliar de camada intermediária

Crie uma camada intermediária reutilizável. Ela analisa o corpo e anexa os dados tipados ou retorna 400 com detalhes.

import { z } from "zod"
import { Request, Response, NextFunction } from "express"

export function validateBody<T extends z.ZodTypeAny>(schema: T) {
  return (req: Request, res: Response, next: NextFunction) => {
    const r = schema.safeParse(req.body)
    if (!r.success) {
      return res.status(400).json({ error: "Invalid body", issues: r.error.format() })
    }
    req.body = r.data
    next()
  }
}

Coerção e refinamento

Use z.coerce para aceitar números representados como texto, z.enum para valores conhecidos e .refine para regras entre campos.

import { z } from "zod"

const signupSchema = z.object({
  email: z.string().email(),
  age: z.coerce.number().int().gte(13),
  role: z.enum(["user", "admin"]).default("user")
}).refine(v => v.role !== "admin" || v.age >= 18, { message: "admin must be adult" })

export type Signup = z.infer<typeof signupSchema>

// Coercion allows numbers in strings; refine adds cross-field rules

Dicas sobre erros

Dicas sobre erros:

  • Use sempre safeParse na borda do sistema.
  • Formate os problemas para os clientes; evite expor rastreamentos da pilha.
  • Restrinja unknown para ZodError se capturar erros de análise lançados.

Verificação da inferência de zod

Verificação rápida: como manter os tipos TS sincronizados com os esquemas do zod?

Recapitulação

Recapitulação: defina um único esquema, infira o tipo TS, valide com safeParse e conecte-o ao middleware para obter erros 400 consistentes.

Perguntas Frequentes

A aula “Validação de esquemas com zod e inferência para TS” é grátis?

Sim — o texto completo de “Validação de esquemas com zod e inferência para TS” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 3 aulas no total.

O que vou aprender em “Validação de esquemas com zod e inferência para TS”?

Valide requisições com zod; infira tipos TypeScript a partir dos esquemas; adicione middleware e tratamento de erros seguros. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Validação de esquemas com zod e inferência para TS”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tipagem de manipuladores de rotas e Request/Response
  2. Validação de esquemas com zod e inferência para TS
  3. Middleware de erros e tipos de resultado
← Voltar para TypeScript Academy