infrahub 0.2.1

small graphql client for infrahub
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129

# case study: procurement contract

this example uses a custom object loaded via `extension_contract.yml`:

```yaml
nodes:
  - name: Contract
    namespace: Procurement
    attributes:
      - name: contract_ref
        kind: Text
      - name: description
        kind: Text
        optional: true
      - name: start_time
        kind: DateTime
      - name: end_time
        kind: DateTime
        optional: true
```

## typed query (concise)

```rust,no_run
use infrahub::{Client, ClientConfig};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Data {
    #[serde(rename = "ProcurementContract")]
    procurement_contract: Contracts,
}

#[derive(Debug, Deserialize)]
struct Contracts {
    edges: Vec<Edge>,
}

#[derive(Debug, Deserialize)]
struct Edge {
    node: Option<ContractNode>,
}

#[derive(Debug, Deserialize)]
struct ContractNode {
    id: String,
    contract_ref: TextAttr,
    description: Option<TextAttr>,
}

#[derive(Debug, Deserialize)]
struct TextAttr {
    value: Option<String>,
}

# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new(ClientConfig::new("http://localhost:8000", "token"))?;

let query = r#"
query($ref: String) {
  ProcurementContract(contract_ref__value: $ref) {
    edges {
      node {
        id
        contract_ref { value }
        description { value }
      }
    }
  }
}
"#;

let vars = serde_json::json!({ "ref": "contract-001" });
let response = client.execute::<Data>(query, Some(vars), None).await?;

for edge in response.data.unwrap().procurement_contract.edges {
    if let Some(node) = edge.node {
        println!("{} -> {:?}", node.id, node.contract_ref.value);
    }
}
# Ok(())
# }
```

## generated client (full surface)

if you generate a full client with `infrahub-codegen`, you get a method for the custom object:

```rust,no_run
use infrahub::{Client, ClientConfig};
use infrahub_generated::GeneratedClient;

# async fn example() -> Result<(), Box<dyn std::error::Error>> {
let client = Client::new(ClientConfig::new("http://localhost:8000", "token"))?;

let response = client
    .generated()
    .procurement_contract(
        None,        // offset
        Some(20),    // limit
        None,        // order
        None,        // ids
        None, None, None, // display_label filters
        None,        // hfid
        None, None, None, None, None, None, // start_time filters
        None, None, None, None, None, None, // description filters
        None, None, None, None, None, None, // contract_ref filters
        None, None, None, None, None, None, // end_time filters
        None, None, None, None, None, None, // any filters
        None,        // partial_match
        None, None, None, None, None, None, // node metadata filters
        None, None, None, None, None, None, // profiles filters
        None, None, None, None, None, None, // subscriber_of_groups filters
        None, None, None, None, None, None, // organization filters
        None, None, None, None, None, None, // member_of_groups filters
        None,        // request_branch
    )
    .await?;

let data = response.data.unwrap();
println!("count: {}", data.procurement_contract.count);
# Ok(())
# }
```

notes:
- generated methods include every filter arg exposed by the schema.
- for ergonomic usage, prefer the concise typed query form.
 - the generated crate also includes `api()` helpers for shorter accessors.