Converta JSON em struct Rust!

Insira JSON para gerar código struct Rust, incluindo objetos aninhados! Compatível com serde Serialize, Deserialize, #[serde(rename)].
JSON
Resultado
 

Converta JSON em struct Rust!

Transforma um JSON de exemplo em structs Rust prontos para o serde. Cada struct faz derive de Debug, Clone, Serialize, Deserialize; os nomes dos campos seguem a convenção snake_case do Rust e são ligados de volta à chave original com #[serde(rename)] quando diferem.

É um ponto de partida quando você quer respostas tipadas no reqwest, precisa de um tipo de request para um extractor Json<T> do axum ou do actix-web, ou está escrevendo uma CLI que faz parse de JSON de logs ou eventos.

Como usar

  1. Cole o JSON. Um array com vários itens ajuda a detectar campos opcionais.
  2. Informe o nome do struct de nível mais alto em Nome do tipo (por exemplo AccessLog).
  3. Cole a saída num arquivo .rs e adicione serde (com a feature derive) e serde_json ao Cargo.toml.
  4. Use via serde_json::from_str::<AccessLog>(&body)? ou resp.json::<AccessLog>().await?.

Exemplo

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
}
Saída (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 é keyword do Rust, então o campo é type_ com #[serde(rename = "type")]. Inteiros são i64 independentemente do tamanho, e latency_ms é f64. trace_id só aparece como null, então o tipo é desconhecido e ele fica serde_json::Value; troque pelo tipo real, por exemplo Option<String>.

Recursos suportados

  • #[derive(Debug, Clone, Serialize, Deserialize)] e campos pub em todo struct.
  • #[serde(rename = "originalKey")] por campo quando a chave difere do nome do campo em snake_case.
  • Campos que faltam em alguns itens: Option<T> com #[serde(default, skip_serializing_if = "Option::is_none")].
  • Campos sempre presentes, mas às vezes null: Option<T> simples, sem atributos.
  • Tipos: i64 para inteiros, f64 para decimais, bool, String, Vec<T> e serde_json::Value para tipos misturados.
  • Chaves que são keywords, como type, match ou ref, ganham um underscore no final (type_).
  • Um array no nível mais alto gera pub type Root = Vec<RootItem>;.

Casos de uso

Respostas tipadas no reqwest

Troque acessos a serde_json::Value como ["status"].as_i64() por resp.json::<AccessLog>(), para que um campo com nome errado falhe em tempo de compilação.

Request bodies no axum ou no actix-web

Gere um struct a partir do JSON que um client manda e receba como Json(payload): Json<CreateOrder>; requests com campos faltando ou com tipo errado são rejeitados pelo framework antes de o código do seu handler rodar.

Uma CLI de análise de logs JSON Lines

Monte um struct a partir de uma linha de log e depois desserialize cada linha de BufReader::lines() para ter, em poucas linhas, uma ferramenta de agregação por campo.

Observações e limitações

  • Inteiros são sempre i64, por menores que sejam. Restrinja você mesmo onde o intervalo é conhecido, por exemplo u16 para status codes ou u32 para contadores.
  • Timestamps e strings de data continuam i64 ou String. Trocar para tipos do chrono ou do time exige ativar as features serde desses crates.
  • A saída que usa serde_json::Value escreve o path completo, então não precisa de use extra, mas a dependência serde_json sim.
  • Os renames são por campo, não um #[serde(rename_all = "camelCase")] no nível do struct. Se as chaves seguem uma única convenção, você pode consolidar você mesmo.
  • Enums com tag não são gerados. Campos com um conjunto fixo de valores, como "level": "warn", são bons candidatos a enum depois.

Perguntas frequentes

Por que os campos opcionais também recebem #[serde(default)]?

O serde já preenche um Option ausente com None, mas um default explícito continua aceitando chaves ausentes se depois você mudar o tipo para algo como Vec<T>. O skip_serializing_if omite campos None ao escrever o JSON de volta, preservando o formato original.

Como campos que aceitam null e campos ausentes diferem na saída?

Os dois viram Option<T>, mas só campos cuja chave pode faltar recebem os atributos default e skip_serializing_if. Um campo sempre presente, mas às vezes null, é escrito de volta como null.

Por que não usar borrow com campos &str e um lifetime 'de?

Campos zero-copy (&'a str) não podem viver mais que o buffer de entrada, o que é incômodo no tratamento típico de respostas. String owned é o padrão; troque os campos mais acessados por Cow<'a, str> se a performance importar.

Posso adicionar derives de Default ou PartialEq?

A saída só faz derive de Debug, Clone, Serialize e Deserialize. Adicione mais à lista de derive você mesmo quando todos os tipos de campo suportarem (serde_json::Value implementa PartialEq).