Converta JSON em tipos TypeScript!

Insira JSON para convertê-lo em interfaces TypeScript! Compatível com TypeScript interface. TypeORM · Sequelize · Mongoose: nas abas acima.
JSON
Resultado
 

Converta JSON em tipos TypeScript!

Esta ferramenta lê um valor JSON e escreve as declarações interface TypeScript correspondentes. As chaves são mantidas exatamente como estão; arrays de objetos são mesclados numa só interface, chaves presentes só em alguns itens ganham ? e valores misturados viram union types.

Use para tipar respostas de fetch ou axios no frontend, para declarar tipos de retorno de API routes do Next.js ou handlers do Express, ou sempre que um backend só documenta respostas de exemplo e nenhuma definição de tipo.

Como usar

  1. Cole um JSON de resposta, por exemplo copiado da aba Network do DevTools.
  2. Informe o nome da interface raiz em Nome do tipo (ex.: ChannelHistory); ele fica na URL como ?name=.
  3. Salve a saída num arquivo como types.ts e use via import type { ChannelHistory } from "./types".

Exemplo

Entrada (JSON)
{
  "channel": "general",
  "messages": [
    { "id": "m1", "user": "kim", "text": "deploy done", "reactions": ["+1"] },
    { "id": "m2", "user": "lee", "text": null, "edited": true, "attachment": { "type": "image", "url": "https://cdn.example.com/a.png" } }
  ],
  "cursor": 42
}
Saída (TypeScript)
export interface ChannelHistory {
  channel: string;
  messages: Message[];
  cursor: number;
}

export interface Message {
  id: string;
  user: string;
  text: string | null;
  reactions?: string[];
  edited?: boolean;
  attachment?: Attachment;
}

export interface Attachment {
  type: string;
  url: string;
}

As duas mensagens são mescladas numa única interface Message; reactions, edited e attachment só aparecem numa delas, então ganham ?. text mistura string e null, resultando em string | null. As interfaces de elemento usam a forma singular da chave (messages → Message).

Recursos suportados

  • Toda declaração é um export interface, pronto para importar em outro lugar.
  • As chaves JSON não são renomeadas, então os tipos batem um a um com o objeto da resposta; chaves que não são identificadores válidos ("a-b", "2fa") ficam entre aspas.
  • Arrays de objetos mesclam as chaves de todos os elementos; chaves que faltam em alguns elementos viram opcionais (?:).
  • Tipos misturados geram unions (string | number); o null é adicionado por último como | null. Arrays mistos viram (string | number)[].
  • Arrays vazios não têm tipo de elemento a inferir e viram unknown[].
  • Um array no nível mais alto também gera um alias como export type Root = RootItem[];.

Casos de uso

Tipar respostas de fetch e axios

Passe o tipo como generic, por exemplo const res = await axios.get<ChannelHistory>(url), e o editor avisa que res.data.messages[0].text pode ser null.

APIs de terceiros sem tipagem

Para APIs internas ou externas sem SDK nem pacote @types, uma resposta de exemplo basta para gerar um arquivo de definição de tipos para compartilhar com o time.

Dados mock e props de componentes

Gere interfaces a partir do JSON mock do Storybook ou dos testes e use como tipo das props dos componentes; quando os mocks se desalinham dos componentes, o compilador avisa.

Observações e limitações

  • Interfaces são apagadas na compilação e não verificam em runtime se uma resposta tem mesmo esse formato. Combine com uma biblioteca de schema como o zod se precisar de validação em runtime.
  • Todos os números são number (sem separação entre inteiro e float), e strings de data são string.
  • Campos com um conjunto fixo de valores, como "status": "active", saem como string; restrinja-os a unions de literais ("active" | "banned") você mesmo.
  • Formatos idênticos sob chaves diferentes ganham cada um a sua interface, e nomes em conflito recebem um sufixo numérico como Profile2.

Perguntas frequentes

Dá para gerar aliases type em vez de interfaces?

Um alias type só é usado para um array ou primitivo no nível mais alto; objetos são sempre interface. Reescrever export interface X { ... } como export type X = { ... }; se comporta igual para esse fim.

Por que opcional (?) e | null ficam separados?

Eles significam coisas diferentes: ? diz que a chave pode estar ausente (undefined), enquanto | null diz que a chave está lá com valor null. Com strictNullChecks ligado, você trata os dois casos de formas diferentes.

Por que as chaves não são convertidas para camelCase?

Um tipo TypeScript descreve o objeto real, então chaves renomeadas deixariam de bater com a resposta. Se você quer camelCase no seu código, defina um tipo separado para o resultado da sua função de mapeamento.

Preciso de entities de ORM (TypeORM, Sequelize, Mongoose).

Esta página só gera declarações de tipo simples. As abas TypeORM, Sequelize e Mongoose no topo geram código de entity e de model a partir do mesmo JSON.