serdev_derive 0.3.0

• Just a wrapper of Serde and 100% compatible,
• implementing serde::{Serialize, Deserialize} for your structs,
• with providing #[serde(validate = "...")] for declarative validation in #[derive(Deserialize)].

Example (closure.rs)

[dependencies]
serdev     = "0.3"
serde_json = "1.0"

use serdev::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
#[serde(validate = "|p| (p.x * p.y <= 100)
    .then_some(())
    .ok_or(\"x * y must not exceed 100\")")]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = serde_json::from_str::<Point>(r#"
        { "x" : 1, "y" : 2 }
    "#).unwrap();

    // Prints point = Point { x: 1, y: 2 }
    println!("point = {point:?}");

    let error = serde_json::from_str::<Point>(r#"
        { "x" : 10, "y" : 20 }
    "#).unwrap_err();

    // Prints error = x * y must not exceed 100
    println!("error = {error}");
}

Of course, you can use it in combination with some validation tools like validator! ( working example: validator.rs )

Attribute

• #[serde(validate = "function")]

  Automatically validate the deserialized struct by the function. The function must be an expression that is callable as type fn(&self) -> Result<(), impl Display> (of course the error type must be known at compile time).

  (expression: an inlined closure as above, or name/path to a fn or a method, or even a block expression or function calling or anything that are finally evaluated as fn(&self) -> Result<(), impl Display>)

  Errors are internally converted to a String and passed to serde::de::Error::custom.

• #[serde(validate(by = "function", error = "Type"))]

  Using given Type for the validation error, without conversion. The function signature must be fn(&self) -> Result<(), Type>.

  This will be preferred in no-std use, or, maybe when you need better performance in error cases.

Both "function" and "Type" above accept path like "crate::util::validate".

Additionally, #[serdev(crate = "path::to::serdev")] is supported for reexport from another crate.

License

Licensed under MIT LICENSE ( LICENSE or https://opensource.org/licenses/MIT ).