¡Convierte JSON en tipos de TypeScript!

¡Introduce JSON para convertirlo en interfaces de TypeScript! Compatible con TypeScript interface. TypeORM · Sequelize · Mongoose: en las pestañas de arriba.
JSON
Resultado
 

¡Convierte JSON en tipos de TypeScript!

Esta herramienta lee un valor JSON y escribe sus declaraciones interface de TypeScript. Las claves se conservan exactamente como están; los arrays de objetos se fusionan en una sola interface, las claves presentes solo en algunos elementos reciben ? y los valores mixtos pasan a union types.

Úsala para tipar respuestas de fetch o axios en el frontend, para declarar los tipos de retorno de API routes de Next.js o handlers de Express, o siempre que un backend solo documente respuestas de ejemplo y no definiciones de tipos.

Cómo usar

  1. Pega un JSON de respuesta, por ejemplo copiado de la pestaña Network de las DevTools.
  2. Escribe el nombre de la interface raíz en Nombre del tipo (p. ej. ChannelHistory); se guarda en la URL como ?name=.
  3. Guarda la salida en un archivo como types.ts y úsala mediante import type { ChannelHistory } from "./types".

Ejemplo

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
}
Salida (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;
}

Los dos mensajes se fusionan en una sola interface Message; reactions, edited y attachment aparecen solo en uno de ellos, así que reciben ?. text mezcla una cadena y null, lo que da string | null. Las interfaces de elementos toman la forma singular de la clave (messages → Message).

Funciones compatibles

  • Todas las declaraciones son export interface, listas para importar desde otros archivos.
  • Las claves JSON no se renombran, así que los tipos coinciden uno a uno con el objeto de respuesta; las claves que no son identificadores válidos ("a-b", "2fa") van entre comillas.
  • Los arrays de objetos fusionan las claves de todos los elementos; las claves que faltan en algunos pasan a ser opcionales (?:).
  • Los tipos mixtos producen uniones (string | number); null se añade al final como | null. Los arrays mixtos pasan a (string | number)[].
  • Los arrays vacíos no tienen tipo de elemento que inferir y pasan a unknown[].
  • Un array de nivel superior también produce un alias como export type Root = RootItem[];.

Casos de uso

Tipar respuestas de fetch y axios

Pasa el tipo como genérico, p. ej. const res = await axios.get<ChannelHistory>(url), y el editor te avisa de que res.data.messages[0].text puede ser null.

APIs de terceros sin tipos

Para APIs internas o externas sin SDK ni paquete @types, basta con una respuesta de ejemplo para producir un archivo de definición de tipos que compartir con el equipo.

Datos mock y props de componentes

Genera interfaces a partir del JSON mock de Storybook o de los tests y úsalas como tipos de props de los componentes; cuando los mocks se desvíen de los componentes, el compilador te lo dirá.

Notas y limitaciones

  • Las interfaces se borran en tiempo de compilación y no comprueban en runtime que una respuesta tenga realmente esa forma. Combínalas con una librería de schemas como zod si necesitas validación en runtime.
  • Todos los números son number (sin separar enteros y decimales), y las cadenas de fecha son string.
  • Los campos con un conjunto fijo de valores, como "status": "active", salen como string; restríngelos tú a uniones de literales ("active" | "banned").
  • Las formas idénticas bajo claves distintas reciben cada una su propia interface, y los nombres que chocan reciben un sufijo numérico como Profile2.

Preguntas frecuentes

¿Puedo obtener alias type en lugar de interfaces?

Solo se usa un alias type para un array o un primitivo de nivel superior; los objetos siempre son interfaces. Reescribir export interface X { ... } como export type X = { ... }; se comporta igual para este fin.

¿Por qué se mantienen separados el opcional (?) y | null?

Significan cosas distintas: ? dice que la clave puede estar ausente (undefined), mientras que | null dice que la clave está presente con valor null. Con strictNullChecks activado, manejas los dos casos de forma diferente.

¿Por qué no se convierten las claves a camelCase?

Un tipo de TypeScript describe el objeto real, así que con claves renombradas dejaría de coincidir con la respuesta. Si quieres camelCase en tu código, define un tipo aparte para el resultado de tu función de mapeo.

Necesito entidades de ORM (TypeORM, Sequelize, Mongoose).

Esta página solo emite declaraciones de tipos simples. Las pestañas TypeORM, Sequelize y Mongoose de arriba generan código de entidades y modelos a partir del mismo JSON.