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
278 Stars 48 Forks MIT License 369 Commits 38 Opened issues

Description

Generate JSON Schema documents from Rust code

Services available

!
?

Need anything else?

Contributors list

# 176,247
HTML
Rust
Shell
serde
354 commits
# 637,817
Python
Shell
Rust
serde
2 commits
# 148,452
Amazon ...
Rust
cross-c...
linkerd
1 commit
# 298,441
Rust
rust-cr...
rust-la...
Shell
1 commit
# 313,293
Rust
Shell
TypeScr...
toml
1 commit
# 12,856
Rust
sentry
error-m...
crash-r...
1 commit
# 71,404
indenta...
Terrafo...
elm
PureScr...
1 commit
# 18,356
Windows
c-sharp
Shell
wsgi
1 commit
# 215,783
Rust
SQL
Git
elevent...
1 commit

Schemars

CI Build Crates.io Docs rustc 1.37+

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 }, }

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"
            }
          },
          "additionalProperties": false
        },
        {
          "type": "object",
          "required": [
            "StructVariant"
          ],
          "properties": {
            "StructVariant": {
              "type": "object",
              "required": [
                "floats"
              ],
              "properties": {
                "floats": {
                  "type": "array",
                  "items": {
                    "type": "number",
                    "format": "float"
                  }
                }
              }
            }
          },
          "additionalProperties": false
        }
      ]
    }
  }
}

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 }, }

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.

Schema from Example Value

If you want a schema for a type that can't/doesn't implement

JsonSchema
, but does implement
serde::Serialize
, then you can generate a JSON schema from a value of that type. However, this schema will generally be less precise than if the type implemented
JsonSchema
- particularly when it involves enums, since schemars will not make any assumptions about the structure of an enum based on a single variant.
use schemars::schema_for_value;
use serde::Serialize;

#[derive(Serialize)] pub struct MyStruct { pub my_int: i32, pub my_bool: bool, pub my_nullable_enum: Option, }

#[derive(Serialize)] pub enum MyEnum { StringNewType(String), StructVariant { floats: Vec }, }

let schema = schema_for_value!(MyStruct { my_int: 123, my_bool: true, my_nullable_enum: Some(MyEnum::StringNewType("foo".to_string())) }); 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",
  "examples": [
    {
      "my_bool": true,
      "my_int": 123,
      "my_nullable_enum": {
        "StringNewType": "foo"
      }
    }
  ],
  "type": "object",
  "properties": {
    "my_bool": {
      "type": "boolean"
    },
    "my_int": {
      "type": "integer"
    },
    "my_nullable_enum": true
  }
}

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) -
url
(^2.0) -
bytes
(^1.0) -
enumset
(^1.0)

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.