¡Convierte JSON en struct de Rust!

¡Introduce JSON para generar código struct de Rust, incluidos los objetos anidados! Compatible con serde Serialize, Deserialize, #[serde(rename)].
JSON
Resultado
 

¡Convierte JSON en struct de Rust!

Convierte un JSON de ejemplo en structs de Rust listos para serde. Cada struct deriva Debug, Clone, Serialize, Deserialize; los nombres de campo siguen la convención snake_case de Rust y se vinculan a la clave original con #[serde(rename)] cuando difieren.

Es un punto de partida cuando quieres respuestas tipadas de reqwest, necesitas un tipo de petición para un extractor Json<T> de axum o actix-web, o estás escribiendo un CLI que parsea JSON de logs o eventos.

Cómo usar

  1. Pega el JSON. Un array con varios elementos le ayuda a detectar los campos opcionales.
  2. Escribe el nombre del struct de nivel superior en Nombre del tipo (por ejemplo AccessLog).
  3. Pega la salida en un archivo .rs y añade serde (con la feature derive) y serde_json a Cargo.toml.
  4. Úsalo mediante serde_json::from_str::<AccessLog>(&body)? o resp.json::<AccessLog>().await?.

Ejemplo

Entrada (JSON)
{
  "timestamp": 1714550400,
  "level": "warn",
  "type": "http_request",
  "status": 503,
  "latency_ms": 1250.7,
  "headers": [{ "name": "user-agent", "value": "curl/8.4" }],
  "trace_id": null
}
Salida (Rust · serde)
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessLog {
    pub timestamp: i64,
    pub level: String,
    #[serde(rename = "type")]
    pub type_: String,
    pub status: i64,
    pub latency_ms: f64,
    pub headers: Vec<Header>,
    pub trace_id: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Header {
    pub name: String,
    pub value: String,
}

type es una palabra reservada de Rust, así que el campo es type_ con #[serde(rename = "type")]. Los enteros son i64 sea cual sea su tamaño, y latency_ms es f64. trace_id siempre vale null, así que su tipo es desconocido y se queda como serde_json::Value; sustitúyelo por el tipo real, p. ej. Option<String>.

Funciones compatibles

  • #[derive(Debug, Clone, Serialize, Deserialize)] y campos pub en cada struct.
  • #[serde(rename = "originalKey")] por campo cuando la clave difiere del nombre del campo en snake_case.
  • Campos que faltan en algunos elementos: Option<T> con #[serde(default, skip_serializing_if = "Option::is_none")].
  • Campos siempre presentes pero a veces null: Option<T> simple, sin atributos.
  • Tipos: i64 para enteros, f64 para decimales, bool, String, Vec<T> y serde_json::Value para tipos mixtos.
  • Las claves que son palabras reservadas como type, match o ref reciben un guion bajo al final (type_).
  • Un array de nivel superior produce pub type Root = Vec<RootItem>;.

Casos de uso

Respuestas tipadas de reqwest

Sustituye accesos sobre serde_json::Value como ["status"].as_i64() por resp.json::<AccessLog>() para que un campo mal escrito falle en tiempo de compilación.

Bodies de petición en axum o actix-web

Genera un struct a partir del JSON que envía un cliente y recíbelo como Json(payload): Json<CreateOrder>; el framework rechaza las peticiones con campos ausentes o de tipo incorrecto antes de que se ejecute el código de tu handler.

Un CLI para analizar logs JSON Lines

Construye un struct a partir de una línea de log y luego deserializa cada línea de BufReader::lines() para tener en pocas líneas una herramienta de agregación por campo.

Notas y limitaciones

  • Los enteros siempre son i64, por pequeños que sean. Ajústalos tú donde conozcas el rango, p. ej. u16 para códigos de estado o u32 para contadores.
  • Los timestamps y las cadenas de fecha se quedan como i64 o String. Pasar a tipos de chrono o time requiere activar las features de serde de esos crates.
  • La salida que usa serde_json::Value escribe la ruta completa, así que no hace falta un use extra, pero sí la dependencia serde_json.
  • Los renombres van por campo en lugar de un #[serde(rename_all = "camelCase")] a nivel de struct. Si las claves siguen una sola convención, puedes unificarlos tú.
  • No se generan enums con tag. Los campos con un conjunto fijo de valores, como "level": "warn", son buenos candidatos para convertirlos después en un enum.

Preguntas frecuentes

¿Por qué los campos opcionales también reciben #[serde(default)]?

serde ya rellena con None un Option ausente, pero un default explícito sigue aceptando claves ausentes si más adelante cambias el tipo a algo como Vec<T>. skip_serializing_if omite los campos None al volver a escribir JSON, conservando la forma original.

¿En qué se diferencian en la salida los campos que pueden ser null y los que pueden faltar?

Ambos pasan a Option<T>, pero solo los campos cuya clave puede estar ausente reciben los atributos default y skip_serializing_if. Un campo siempre presente pero a veces null se vuelve a escribir como null.

¿Por qué no tomar prestado con campos &str y un lifetime 'de?

Los campos zero-copy (&'a str) no pueden vivir más que el buffer de entrada, lo que resulta incómodo para el manejo habitual de respuestas. Por defecto se usa String con ownership; cambia los campos críticos a Cow<'a, str> si el rendimiento importa.

¿Puedo añadir derives Default o PartialEq?

La salida solo deriva Debug, Clone, Serialize y Deserialize. Añade más a la lista de derive tú mismo cuando todos los tipos de los campos los soporten (serde_json::Value implementa PartialEq).