deserr 0.6.4

Deserialization library with focus on error handling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

# Already available error type

Deserr comes with two predefined error type for json and query parameters.

### Json

Json support is made through the [`JsonError`](https://docs.rs/deserr/latest/deserr/errors/json/struct.JsonError.html) type.

#### Changes to the error messages 

Here's a non-exhaustive list of some of the changes that are made to the error message compared to `serde_json`:
- Instead of providing the bytes indice of the error it provides the path of the error using dot: `error.on.field[3]`.
- Use the word `array` instead of `Sequence`
- Use the word `object` instead of `Map`
- Never talk about rust type like `u8` and instead use words like number/integer or the bounds of the number directly.
- When using the `deny_unknown_parameter` container attribute deserr will:
  - List all the available fields of the object.
  - Find and propose the field with the closest name of what was typed with a "did you mean" message.

#### Examples

```rust
use deserr::{Deserr, errors::JsonError};
use serde_json::json;
#[derive(Deserr, Debug)]
#[deserr(deny_unknown_fields, rename_all = camelCase)]
struct Search {
    q: Values,
    filter: u8,
}
#[derive(Deserr, Debug)]
#[deserr(rename_all = camelCase)]
enum Values {
    Q,
    Filter,
}

// The field name is wrong but is close enough of `filter`
let value = json!({ "filler": "doggo" });
let err = deserr::deserialize::<Search, _, JsonError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown field `filler`: did you mean `filter`? expected one of `q`, `filter`");

// The field name isn't close to anything
let value = json!({ "a": "doggo" });
let err = deserr::deserialize::<Search, _, JsonError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown field `a`: expected one of `q`, `filter`");

// Did you mean also works with enum value
let value = json!({ "q": "filler" });
let err = deserr::deserialize::<Search, _, JsonError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown value `filler` at `.q`: did you mean `filter`? expected one of `q`, `filter`");

let value = json!({ "filter": [2] });
let err = deserr::deserialize::<Search, _, JsonError>(value).unwrap_err();
assert_eq!(err.to_string(), "Invalid value type at `.filter`: expected a positive integer, but found an array: `[2]`");
```

### Query Parameter

Query parameter support is made through the [`QueryParamError`](https://docs.rs/deserr/latest/deserr/errors/query_params/struct.QueryParamError.html) type.

#### Changes to the error messages 

Here's a non-exhaustive list of some of the changes that are made to the error message compared to `serde_qs`:
- Instead of providing the bytes indice of the error it provides the path of the error using dot: `error.on.parameter[3]`.
- Use the word `multiple values` instead of `Sequence`
- Use the word `multiple parameters` instead of `Map`
- Never talk about rust type like `u8` and instead use words like number/integer or the bounds of the number directly.
- When using the `deny_unknown_parameter` container attribute deserr will:
  - List all the available parameters of the object.
  - Find and propose the parameter with the closest name of what was typed with a "did you mean" message.

#### Examples


```rust
use deserr::{Deserr, errors::QueryParamError};
use serde_json::json;
#[derive(Deserr, Debug)]
#[deserr(deny_unknown_fields, rename_all = camelCase)]
struct Search {
    q: Values,
    filter: u8,
}
#[derive(Deserr, Debug)]
#[deserr(rename_all = camelCase)]
enum Values {
    Q,
    Filter,
}

// The field name is wrong but is close enough of `filter`
let value = json!({ "filler": "doggo" });
let err = deserr::deserialize::<Search, _, QueryParamError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown parameter `filler`: did you mean `filter`? expected one of `q`, `filter`");

// The parameter name isn't close to anything
let value = json!({ "a": "doggo" });
let err = deserr::deserialize::<Search, _, QueryParamError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown parameter `a`: expected one of `q`, `filter`");

// Did you mean also works with enum value
let value = json!({ "q": "filler" });
let err = deserr::deserialize::<Search, _, QueryParamError>(value).unwrap_err();
assert_eq!(err.to_string(), "Unknown value `filler` for parameter `q`: did you mean `filter`? expected one of `q`, `filter`");

let value = json!({ "filter": [2] });
let err = deserr::deserialize::<Search, _, QueryParamError>(value).unwrap_err();
// The query parameters are always expecting string in the values
assert_eq!(err.to_string(), "Invalid value type for parameter `filter`: expected a string, but found multiple values");
```

### Want another format

Feel free to open an issue or a PR