lightql 0.2.0

lightweight graphql request builder.
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


# LightQl

This library is a lightweight library that let you make graphql request and serialize them
into the given type. The fields of the given type should match with the "data" content of the reponses.
**Examples**:

```no_test
use lightql::{Request, QlType};

let response = json!(
    "data": {
        "players": [
            {
                "id": 1,
                "name": "fred"
            },
            {
                "id": 2,
                "name": "marcel"
            },
            {
                "id": 3,
                "name": "roger"
            }
        ]
    }
)

// The given type should look like that:
#[derive(Deserialize)]
struct Player {
    #[serde(default = "get_default_id")]
    id: i32,
    name: String
}

#[derive(Deserialize)]
struct Players {
    players: Vec<Player>
}

// This will work.
// But here if you want to request one player:

let response = json!(
    "data": {
        "player": {
            "id": 4,
            "name": "bouras"
        }
    }
);

#[derive(Deserialize)]
struct OnePlayer {
    player: Player
}

// default function
fn get_default_id() -> i32 {
    0
}

// You have to match the "data" content with field.
```

# Usage
To use the library there is the `Request` struct that encapsulate the request.
```no_test
    let player: OnePlayer = Request::new("player(id: 1) { name }", QlType::Query)
        .send("https://your-api/")
        .expect("Cannot fetch player");

    // print: Player { id: 0, name: "fred" }
    println!("{:?}", player);

```
Send automatically infer type of deserialisation.

# From file

You can make complexe request request from a file for example:
```no_test
let response = Request::from_path("path/to/ql/request.query")
    .send::<OnePlayer>("http://your-api/") // Note the turbo-fish
    .unwrap();
```

# Parameter

If you need runtime parameter you can use prepare and an hasmap.
```no_test
let user_id = get_user_id(&user);

let mut params = Hasmap::new();
params.insert(
    "_id",
    user_id.parse()
);

let response = Request::new("player(id: _id) { id, name }", QlType::Query)
    .prepare(Some(params)) // Should prepare before sending !
    .send::<OnePlayer>("https://your-api/")
    .unwrap(); // If not prepared return Err(QlNotPrepared)

```

# Contribution
You can post issues and pull requests I will read them.
Please respect the [Rust style](https://github.com/rust-dev-tools/fmt-rfcs/blob/master/guide/guide.md).