GREsau/ schemars

(v0.8.0) 5 months ago

Rust

Shell

serde

json-schema

View on GitHub

Need help with schemars?

Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

GREsau

173 Stars

31 Forks

MIT License

303 Commits

35 Opened issues

Description

Generate JSON Schema documents from Rust code

Services available

Need anything else?

Contributors list

Graham Esau GREsau

# 211,015

HTML

Rust

Shell

serde

297 commits

Alexander Berger alex-berger

# 174,495

minio

Amazon ...

linkerd

1 commit

Atsuki Takahashi AtsukiTak

# 319,175

Rust

rust-cr...

rust-la...

databas...

1 commit

Ferenc Tamás tamasfe

# 325,423

Rust

mariadb

SQLite

SQL

1 commit

Readme

Schemars

Name: schemars
Brand: schemars
SKU: //GREsau/schemars
Rating: 2.1825 (173 reviews)

Generate JSON Schema documents from Rust code

Basic Usage

If you don't really care about the specifics, the easiest way to generate a JSON schema for your types is to

#[derive(JsonSchema)]

and use the

schema_for!

macro. All fields of the type must also implement

JsonSchema

- Schemars implements this for many standard library types.

use schemars::{schema_for, JsonSchema};

#[derive(JsonSchema)]
pub struct MyStruct {
    pub my_int: i32,
    pub my_bool: bool,
    pub my_nullable_enum: Option,
}
#[derive(JsonSchema)]
pub enum MyEnum {
    StringNewType(String),
    StructVariant { floats: Vec },
}
fn main() {
    let schema = schema_for!(MyStruct);
    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

Click to see the output JSON schema...

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "MyStruct",
  "type": "object",
  "required": [
    "my_bool",
    "my_int"
  ],
  "properties": {
    "my_bool": {
      "type": "boolean"
    },
    "my_int": {
      "type": "integer",
      "format": "int32"
    },
    "my_nullable_enum": {
      "anyOf": [
        {
          "$ref": "#/definitions/MyEnum"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "definitions": {
    "MyEnum": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "StringNewType"
          ],
          "properties": {
            "StringNewType": {
              "type": "string"
            }
          }
        },
        {
          "type": "object",
          "required": [
            "StructVariant"
          ],
          "properties": {
            "StructVariant": {
              "type": "object",
              "required": [
                "floats"
              ],
              "properties": {
                "floats": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "format": "float"
                  }
                }
              }
            }
          }
        }
      ]
    }
  }
}

Serde Compatibility

One of the main aims of this library is compatibility with Serde. Any generated schema should match how serde_json would serialize/deserialize to/from JSON. To support this, Schemars will check for any

#[serde(...)]

attributes on types that derive

JsonSchema

, and adjust the generated schema accordingly.

use schemars::{schema_for, JsonSchema};
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct MyStruct {
    #[serde(rename = "myNumber")]
    pub my_int: i32,
    pub my_bool: bool,
    #[serde(default)]
    pub my_nullable_enum: Option,
}
#[derive(Deserialize, Serialize, JsonSchema)]
#[serde(untagged)]
pub enum MyEnum {
    StringNewType(String),
    StructVariant { floats: Vec },
}
fn main() {
    let schema = schema_for!(MyStruct);
    println!("{}", serde_json::to_string_pretty(&schema).unwrap());
}

Click to see the output JSON schema...

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "MyStruct",
  "type": "object",
  "required": [
    "myBool",
    "myNumber"
  ],
  "properties": {
    "myBool": {
      "type": "boolean"
    },
    "myNullableEnum": {
      "default": null,
      "anyOf": [
        {
          "$ref": "#/definitions/MyEnum"
        },
        {
          "type": "null"
        }
      ]
    },
    "myNumber": {
      "type": "integer",
      "format": "int32"
    }
  },
  "additionalProperties": false,
  "definitions": {
    "MyEnum": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "object",
          "required": [
            "floats"
          ],
          "properties": {
            "floats": {
              "type": "array",
              "items": {
                "type": "number",
                "format": "float"
              }
            }
          }
        }
      ]
    }
  }
}

#[serde(...)]

attributes can be overriden using

#[schemars(...)]

attributes, which behave identically (e.g.

#[schemars(rename_all = "camelCase")]

). You may find this useful if you want to change the generated schema without affecting Serde's behaviour, or if you're just not using Serde.

Feature Flags

```
derive
```
(enabled by default) - provides
```
#[derive(JsonSchema)]
```
macro
```
impl_json_schema
```
- implements
```
JsonSchema
```
for Schemars types themselves
```
preserve_order
```
- keep the order of struct fields in
```
Schema
```
and
```
SchemaObject
```

Optional Dependencies

Schemars can implement

JsonSchema

on types from several popular crates, enabled via optional dependencies (dependency versions are shown in brackets): -

chrono

(^0.4) -

indexmap

(^1.2) -

either

(^1.3) -

uuid

(^0.8) -

smallvec

(^1.0) -

arrayvec

(^0.5)