hypertune 0.6.2

Hypertune SDK for type safe configuration
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

use anyhow::anyhow;
use anyhow::Result;
use serde::Deserialize;
use serde::Serialize;
use serde_json::Value;
use std::collections::HashMap;

use crate::expression::Expression;

pub type Query = HashMap<String, Fragment>;
pub type Selection = HashMap<String, SelectionField>;

#[derive(Deserialize, Serialize, Debug)]
#[serde(try_from = "Value")]
pub struct SelectionField {
    pub field_arguments: Option<HashMap<String, Expression>>,
    pub field_query: Option<Query>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Fragment {
    pub object_type_name: String,
    pub selection: Selection,
}

impl TryFrom<Value> for SelectionField {
    type Error = anyhow::Error;

    fn try_from(value: Value) -> Result<Self> {
        match value {
            Value::Object(object) => {
                let field_arguments: Option<HashMap<String, Expression>> = object
                    .get("fieldArguments")
                    .map(|field_arguments| match field_arguments {
                        Value::Object(field_arguments) => field_arguments
                            .clone()
                            .into_iter()
                            .map(|(key, value)| match value.try_into() {
                                Ok(value) => Ok((key, value)),
                                Err(error) => Err(error),
                            })
                            .collect::<Result<_>>(),
                        _ => Err(anyhow!("Field arguments must be a JSON object")),
                    })
                    .transpose()?;

                let field_query: Option<Query> = match object.get("fieldQuery") {
                    Some(field_query) => serde_json::from_value(field_query.clone())?,
                    None => None,
                };

                Ok(Self {
                    field_arguments,
                    field_query,
                })
            }
            _ => Err(anyhow!(
                "Can only construct a selection field from an object query"
            )),
        }
    }
}