Nested structure errors

[axos88]

Hey, nice crate, was thinking about something similar in ya7010/serde_valid#106, but just stumbled upon your solution.

You seem to have a similar issue with nested structure errors:

#[derive(Validate, Deserialize, Debug)]
#[serde(validate = "serde_valid::Validate::validate")]
struct Foo {
  #[validate(multiple_of = 2)] even: i32,
  #[validate(pattern= r"^[^@\s]+@[^@\s]+\.[^@\s]+$")] email: String,
  #[validate(minimum = 0)] #[validate(maximum = 100)] percentage: u8
}

#[derive(Validate, Deserialize, Debug)]
#[serde(validate = "serde_valid::Validate::validate")]
struct Bar { foo: Foo }

  let json_invalid = r#"
{
    "foo": 
        {
            "even": 5,
            "email": "bad_email",
            "percentage": 125
        }
}
"#;

  println!("JSON invalid reslt: {:?}", serde_json::from_str::<Bar>(json_invalid).err().unwrap());

Reports:

{
  "errors": [],
  "properties": {
    "even": {
      "errors": [
        "The value must be multiple of `2`."
      ]
    },
    "email": {
      "errors": [
        "The value must match the pattern of ..."
      ]
    },
    "percentage": {
      "errors": [
        "The number must be `<= 100`."
      ]
    }
  }
}

If this was a deeply nested struct (or an array), it would cause some issue finding which path caused the issue. It would be great if there could be visibility on which nested struct causes the issue.

[kanarus]

Hi @axos88 , thank you for using serdev !

---

First, the Bar definition in your code:

#[derive(Validate, Deserialize, Debug)]
#[serde(validate = "serde_valid::Validate::validate")]
struct Bar { foo: Foo }

seems deriving serde_valid::Validate with no actual validation (i.e. always reports Ok(())).
In order to perform nested validation using serde_valid, in my understanding, we have to attach a specific custom validator to each nested field like:

fn serde_valid_nested_validate<V: serde_valid::Validate>(
    v: &V
) -> Result<(), serde_valid::validation::Error> {
    serde_valid::Validate::validate(v).map_err(
        |e| serde_valid::validation::Error::Custom(e.to_string())
    )
}

#[derive(Validate, Deserialize, Debug)]
struct Bar {
    #[validate(custom = serde_valid_nested_validate)]
    foo: Foo,
}

---

Based on this, one workaround for the issue will be like:

#[derive(Validate, Deserialize, Debug)]
/* 1. Remove `#[serde(validate = "...")]` from the intermediate structs */
// #[serde(validate = "serde_valid::Validate::validate")]
struct Foo {
    #[validate(multiple_of = 2)]
    even: i32,
    #[validate(pattern= r"^[^@\s]+@[^@\s]+\.[^@\s]+$")]
    email: String,
    #[validate(minimum = 0)]
    #[validate(maximum = 100)]
    percentage: u8
}

#[derive(Validate, Deserialize, Debug)]
/* 2. Just attach `#[serde(validate = "...")]` for the final structs */
#[serde(validate = "serde_valid::Validate::validate")]
struct Bar {
    #[validate(custom = serde_valid_nested_validate)]
    foo: Foo,
}

---

It's not applicable when we really need #[serde(validate = "...")] for Foo itself, too. The solution for those situations, if implemented in future, may be like:

#[derive(Validate, Deserialize, Debug)]
#[serde(validate = "serde_valid::Validate::validate")]
struct Foo {
    #[validate(multiple_of = 2)]
    even: i32,
    #[validate(pattern= r"^[^@\s]+@[^@\s]+\.[^@\s]+$")]
    email: String,
    #[validate(minimum = 0)]
    #[validate(maximum = 100)]
    percentage: u8
}

#[derive(Validate, Deserialize, Debug)]
#[serde(validate = "serde_valid::Validate::validate")]
struct Bar {
    #[validate(custom = serde_valid_nested_validate)]
    /*
      `delegate_validation` skips `Foo`'s (sub-)validation
      and delegates the validation step into `Bar`
    */
    #[serde(delegate_validation)]
    foo: Foo,
}

Let me know if you have any feedback for my idea!

[axos88]

Hmmm. Yeah...something like that...

The issue i am mainly looking to solve here is that although one may create a restricted type say EvenNumber(u32) for whatever reason and validate in the constructor that the wrapped number is indeed even. Now i want to trust that the type system can prove that if I get an EvenNumber, that number really is even. Which works.... as long as I dont derive Deserialize, at which point i can instantiate members of that type violating that invariant.

And thats where serdev would step in.

However i dislike the notion that we neee special annotations for nested members that also implement Validate. For both deferring the validation and for defining a custom validation function. I want it to just work, the same way serde can compose cleanly without special annotations unless special behaviour is requested.

It kinda does btw, because an error WILL be thrown when deserializing Bar with an invalid Foo in the example above, but the error message is misleading. How would that work for collections? Monads, such as result, etc?...

We need to think about it some more.

[axos88]

Problem is at the point the inner Foo value is deserialized the validation needs to run, which will return an error. And at the point that error is built it needs to know its span, and i am unsure of serde has support for it.

I may be wanting an unimplementable thing here.