Validation support about schemars

[GREsau]

This is finally available in v0.8.4 😃
https://crates.io/crates/schemars/0.8.4

[GREsau]

There's nothing like this implemented yet, but it is something I've thought about.

One way of specifying validations that #[derive(JsonSchema)] could hook into would be using something like the validator crate's validate attributes.

Any fields with a validate attribute could have the appropriate JSON Schema validation properties and/or format property set. e.g.

lazy_static! {
    static ref USERNAME_RE: Regex = Regex::new(r"^\w{2,}$").unwrap();
}

#[derive(JsonSchema)]
pub struct User{
  #[validate(regex = "USERNAME_RE")]
  pub username: String,
  #[validate(email)]
  pub email: String,
}

Could produce a schema like:

{
  "title": "User",
  "type": "object",
  "properties": {
    "username": {
      "type": "string",
      "pattern": "^\\w{2,}$"
    },
    "email": {
      "type": "string",
      "format": "email"
    }
  }
}

Alternatively, I could just add more options to #[schemars(...)] attributes to allow setting more properties on the generated schema

[patriksvensson]

@GREsau I like the approach with the validate attribute!

I would be happy to try to submit a pull request for this unless this is something you want to do yourself (if it's something that you would consider adding to Schemars that is).

[GREsau]

Sure, I'd be happy to accept a PR for this

[tamasfe]

@GREsau @patriksvensson I've made some effort towards validation in #40. If that approach is accepted, I'd advise just setting fields with schemars(max_items = 1, ...) so that integration is still possible with validator.

[tamasfe]

I've created a validation library based on #40 that provides integration with Schemars. Types can validate themselves by generating a schema and validating against it. The generated schema just has to contain all validation-related fields.

I could start working on a PR to set those fields with attributes.

What would be the best way to get info about fields in the derive macro? I would personally like to deny attributes that make no sense for a type.

[sbihel]

Would it make sense to use Valico's DSL to generate the schema?

1. It would be inherently consistent with the goal of this project.
2. It might be possible to reduce the glue and pass attributes' options generically.
3. And going with custom #[schemars(...)] attributes might be the safest choice in case the validator crate, or any other generic validator, were to have conflicts with the JSONSchema standard?

[MarcAntoine-Arnaud]

Hello,

I'm interested into this feature too.
I'm just wondering if it's not a SerDe feature ?

For me I expect more to define something like:

#[derive(Serialize, Deserialize, JsonSchema)]
pub struct User{
  #[serde(regex = "^\w{2,}$", getter = true, setter = true)]
  username: String,
}

So like that Serde can generate:

• Deserializer with internal check while parsing a file
• implement a setter to update the value, validating first the regex

Like that Schemars can use that parameter to ad the right field in the generated schema.
Does it make sense ?