json-schema-rs

A Rust library to generate Rust structs from JSON Schema.

Features

• Unsupported keys are ignored. Unknown keywords and unsupported types do not cause an error; they are skipped.

Objects

The root schema must have type: "object". Object schemas are traversed recursively; each object with properties yields a Rust struct. Non-object types at the root cause generation to fail.

The properties key defines the shape of each object. Each property becomes a struct field. Property keys are sanitized for Rust (e.g. - becomes _); when the Rust field name differs from the JSON key, generated code includes #[serde(rename = "...")].

Nested properties produce nested structs. Child structs are emitted before parent structs (topological order), so the generated Rust compiles without reordering.

The title of an object schema is used as the struct name (PascalCase). If title is missing or empty, the struct name is derived from the property key that references it.

String type

Properties with type: "string" are emitted as String in Rust. Generated structs use serde::Serialize and serde::Deserialize.

Enums

When a property has an enum of string values, the crate generates a Rust enum instead of String. Variant names are PascalCase. If multiple JSON values map to the same variant name (e.g. "PENDING" and "pending"), suffixes like _0, _1 are applied so variant names stay unique.

Required vs Optional

The required array lists property names that are required at that object level. Required properties are emitted as T; others as Option<T>. If required is absent, all properties are treated as optional.

Unsupported features

Examples

JSON Schema:

{
  "type": "object",
  "title": "Record",
  "required": ["id"],
  "properties": {
    "id": { "type": "string" },
    "name": { "type": "string" },
    "status": { "type": "string", "enum": ["active", "inactive"] },
    "nested": {
      "type": "object",
      "title": "NestedInfo",
      "required": ["value"],
      "properties": {
        "value": { "type": "string" },
        "kind": { "type": "string", "enum": ["A", "a"] }
      }
    },
    "foo-bar": { "type": "string" }
  }
}

Generated Rust:

//! Generated by json-schema-rs. Do not edit manually.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub enum Kind {
    #[serde(rename = "A")]
    A_0,
    #[serde(rename = "a")]
    A_1,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub enum Status {
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "inactive")]
    Inactive,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct NestedInfo {
    pub kind: Option<Kind>,
    pub value: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Record {
    #[serde(rename = "foo-bar")]
    pub foo_bar: Option<String>,
    pub id: String,
    pub name: Option<String>,
    pub nested: Option<NestedInfo>,
    pub status: Option<Status>,
}

View full example in examples/readme_example.rs

Running the binary

The crate includes a CLI binary json-schema-gen that reads a JSON Schema from stdin and writes generated Rust code to stdout.

Build the binary:

cargo build --release

The binary is at target/release/json-schema-gen.

Run it:

json-schema-gen < schema.json > output.rs

Or pipe from another command:

cat schema.json | json-schema-gen > output.rs

Alternative libraries

TODO

Developers

Project is under active maintenance - even if there are no recent commits! Please submit an issue / bug request if the library needs updating for any reason!

Philosophy

• Generates idiomatic Rust
• Can handle every JSON Schema specification version

Commands

• make lint
• make test
• make fix

Credits

Made by Todd Everett Griffin.