0Pricing
TypeScript Academy · Aula

Esquemas zod/valibot + inferência

Valide dados não confiáveis com esquemas; infira tipos TS diretamente dos validadores; compare zod e valibot; integre-os aos manipuladores.

Esquemas zod/valibot + inferência é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 2. 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 2 aulas no total.

Introdução

Objetivo: Tratar entradas externas como unknown, validá-las com um esquema e inferir tipos de TS a partir desse esquema. Você usará zod, verá a sintaxe do valibot e criará um pequeno auxiliar para manipuladores.

  • Uma única fonte de verdade
  • safeParse versus parse
  • Reutilização dos tipos inferidos

Inferência com zod

Defina um esquema uma vez. type User = z.infer<typeof userSchema> reproduz exatamente as regras de validação.

import { z } from "zod"

export const userSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1),
  age: z.number().int().min(0).optional()
})

export type User = z.infer<typeof userSchema>

// User is kept in sync with runtime rules.

safeParse versus parse

safeParse fornece um resultado de sucesso ou falha sem lançar uma exceção, sendo perfeito para manipuladores HTTP; parse lança uma exceção quando a entrada é inválida.

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

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

// parse() throws; safeParse() returns a discriminated union

Inferência com valibot

valibot oferece um validador compacto com Infer<typeof schema>. Escolha uma biblioteca e padronize seu uso em toda a equipe.

import { object, string, number, optional, minLength, uuid, minValue } from "valibot"
import type { Infer } from "valibot"

export const VUser = object({
  id: string([uuid()]),
  name: string([minLength(1)]),
  age: optional(number([minValue(0)]))
})

export type VUserT = Infer<typeof VUser>

// Similar idea: one schema, inferred type.

Auxiliar de validação

Encapsule a análise em um pequeno auxiliar para que os manipuladores recebam uma estrutura simples { ok,data } ou { ok:false,issues }.

import { ZodTypeAny } from "zod"

export function validate<T extends ZodTypeAny, Out = unknown>(schema: T, value: unknown, onError?: (issues: unknown) => never | void): { ok: true; data: Out } | { ok: false; issues: unknown } {
  const r = schema.safeParse(value)
  if (!r.success) {
    const issues = r.error.format()
    if (onError) onError(issues as unknown as never)
    return { ok: false, issues }
  }
  return { ok: true, data: r.data as unknown as Out }
}

Dicas

Dicas:

  • Mantenha os esquemas próximos da fronteira (HTTP, CLI, IO do banco de dados).
  • Infira os tipos e exporte-os — evite duplicatas escritas manualmente.
  • Retorne 400 com os detalhes dos problemas; nunca confie na entrada do cliente.

Verificação do benefício da inferência

Verificação rápida: Por que inferir tipos a partir de esquemas?

Recapitulação

Recapitulação: Valide entradas unknown com zod/valibot, use safeParse e infira tipos para manter o tempo de compilação e o tempo de execução alinhados.

Perguntas Frequentes

A aula “Esquemas zod/valibot + inferência” é grátis?

Sim — o texto completo de “Esquemas zod/valibot + inferência” é 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 2 aulas no total.

O que vou aprender em “Esquemas zod/valibot + inferência”?

Valide dados não confiáveis com esquemas; infira tipos TS diretamente dos validadores; compare zod e valibot; integre-os aos manipuladores. 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 1 de 2.

Quanto tempo leva a aula “Esquemas zod/valibot + inferência”?

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. Esquemas zod/valibot + inferência
  2. Análise defensiva e envelopes de erros
← Voltar para TypeScript Academy