Convertissez du JSON en struct Rust !

Saisissez du JSON pour générer du code struct Rust, objets imbriqués compris ! Compatible avec serde Serialize, Deserialize, #[serde(rename)].
JSON
Résultat
 

Convertissez du JSON en struct Rust !

Transformez un exemple JSON en structs Rust prêtes pour serde. Chaque struct dérive Debug, Clone, Serialize, Deserialize ; les noms de champs suivent la convention snake_case de Rust et sont reliés à la clé d'origine par #[serde(rename)] quand ils diffèrent.

Un point de départ quand vous voulez des réponses reqwest typées, avez besoin d'un type de requête pour un extracteur Json<T> d'axum ou d'actix-web, ou écrivez une CLI qui analyse du JSON de logs ou d'événements.

Mode d'emploi

  1. Collez le JSON. Un tableau de plusieurs éléments l'aide à détecter les champs optionnels.
  2. Saisissez le nom de la struct de premier niveau dans Nom du type (par exemple AccessLog).
  3. Collez la sortie dans un fichier .rs et ajoutez serde (avec la feature derive) et serde_json à Cargo.toml.
  4. Utilisez-la via serde_json::from_str::<AccessLog>(&body)? ou resp.json::<AccessLog>().await?.

Exemple

Entrée (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
}
Sortie (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 est un mot-clé Rust : le champ s'appelle donc type_ avec #[serde(rename = "type")]. Les entiers sont i64 quelle que soit leur taille, et latency_ms est f64. trace_id ne vaut jamais que null : son type est inconnu et il reste serde_json::Value ; remplacez-le par le vrai type, par exemple Option<String>.

Fonctionnalités prises en charge

  • #[derive(Debug, Clone, Serialize, Deserialize)] et des champs pub sur chaque struct.
  • #[serde(rename = "originalKey")] par champ quand la clé diffère du nom de champ snake_case.
  • Champs absents de certains éléments : Option<T> avec #[serde(default, skip_serializing_if = "Option::is_none")].
  • Champs toujours présents mais parfois null : simple Option<T> sans attribut.
  • Types : i64 pour les entiers, f64 pour les décimaux, bool, String, Vec<T>, et serde_json::Value pour les types mélangés.
  • Les clés qui sont des mots-clés, comme type, match ou ref, reçoivent un tiret bas final (type_).
  • Un tableau de premier niveau produit pub type Root = Vec<RootItem>;.

Cas d'utilisation

Réponses reqwest typées

Remplacez les accès serde_json::Value comme ["status"].as_i64() par resp.json::<AccessLog>() : un champ mal orthographié échoue alors à la compilation.

Corps de requête dans axum ou actix-web

Générez une struct à partir du JSON qu'envoie un client et acceptez-la sous la forme Json(payload): Json<CreateOrder> ; les requêtes aux champs manquants ou mal typés sont rejetées par le framework avant que votre handler ne s'exécute.

Une CLI d'analyse de logs JSON Lines

Construisez une struct à partir d'une ligne de log, puis désérialisez chaque ligne de BufReader::lines() pour obtenir en quelques lignes un outil d'agrégation par champ.

Remarques et limites

  • Les entiers sont toujours i64, aussi petits soient-ils. Réduisez-les vous-même quand la plage est connue, par exemple u16 pour des codes de statut ou u32 pour des compteurs.
  • Les timestamps et chaînes de date restent i64 ou String. Passer aux types chrono ou time nécessite d'activer les features serde de ces crates.
  • Une sortie qui utilise serde_json::Value écrit le chemin complet : aucun use supplémentaire n'est requis, mais la dépendance serde_json l'est.
  • Les renommages se font par champ plutôt qu'avec un #[serde(rename_all = "camelCase")] au niveau de la struct. Si les clés suivent une seule convention, vous pouvez les regrouper vous-même.
  • Aucun enum tagué n'est généré. Les champs à ensemble de valeurs fixe, comme "level": "warn", sont de bons candidats pour un enum par la suite.

FAQ

Pourquoi les champs optionnels reçoivent-ils aussi #[serde(default)] ?

serde remplit déjà un Option manquant avec None, mais un default explicite continue d'accepter les clés manquantes si vous changez plus tard le type en quelque chose comme Vec<T>. skip_serializing_if omet les champs None à la réécriture du JSON, ce qui préserve la forme d'origine.

Comment les champs nullables et les champs manquants diffèrent-ils dans la sortie ?

Les deux deviennent Option<T>, mais seuls les champs dont la clé peut être absente reçoivent les attributs default et skip_serializing_if. Un champ toujours présent mais parfois null est réécrit en null.

Pourquoi ne pas emprunter avec des champs &str et une durée de vie 'de ?

Les champs zero-copy (&'a str) ne peuvent pas survivre au buffer d'entrée, ce qui est malcommode pour un traitement de réponse classique. String possédé est le choix par défaut ; passez les champs critiques en Cow<'a, str> si les performances comptent.

Puis-je ajouter les dérivations Default ou PartialEq ?

La sortie ne dérive que Debug, Clone, Serialize et Deserialize. Complétez vous-même la liste derive quand tous les types de champs les prennent en charge (serde_json::Value implémente PartialEq).