reactive_graph_client/client/instances/relations/
api.rs

1use std::sync::Arc;
2
3use crate::client::ReactiveGraphClient;
4use crate::client::ReactiveGraphClientExecutionError;
5use crate::client::instances::relations::mutations::add_component::mutations::add_component;
6use crate::client::instances::relations::mutations::add_property::mutations::add_property;
7use crate::client::instances::relations::mutations::create::mutations::create;
8use crate::client::instances::relations::mutations::delete::mutations::delete;
9use crate::client::instances::relations::mutations::remove_component::mutations::remove_component;
10use crate::client::instances::relations::mutations::remove_property::mutations::remove_property;
11use crate::client::instances::relations::mutations::set_property::mutations::set_property;
12use crate::client::instances::relations::queries::get_by_id::queries::get_by_id;
13use crate::client::instances::relations::queries::search::queries::search;
14use crate::client::instances::relations::variables::search::variables::SearchRelationInstancesVariables;
15use cynic::http::ReqwestExt;
16use reactive_graph_graph::ComponentTypeId;
17use reactive_graph_graph::PropertyInstances;
18use reactive_graph_graph::PropertyType;
19use reactive_graph_graph::RelationInstance;
20use reactive_graph_graph::RelationInstanceId;
21use serde_json::Value;
22
23pub struct RelationInstances {
24    client: Arc<ReactiveGraphClient>,
25}
26
27impl RelationInstances {
28    pub fn new(client: Arc<ReactiveGraphClient>) -> Self {
29        Self { client }
30    }
31
32    pub async fn search(&self, search_query: SearchRelationInstancesVariables) -> Result<Option<Vec<RelationInstance>>, ReactiveGraphClientExecutionError> {
33        let relation_instances = self
34            .client
35            .client
36            .post(self.client.url_reactive_graph())
37            .run_graphql(search(search_query))
38            .await
39            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
40            .data
41            .map(|data| crate::schema_graphql::instances::relation_instance::RelationInstances(data.instances.relations))
42            .map(From::from);
43        Ok(relation_instances)
44    }
45
46    pub async fn get_by_id<ID: Into<RelationInstanceId>>(&self, id: ID) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
47        let id = id.into();
48        let relation_instance = self
49            .client
50            .client
51            .post(self.client.url_reactive_graph())
52            .run_graphql(get_by_id(&id))
53            .await
54            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
55            .data
56            .and_then(|data| data.instances.relations.first().cloned())
57            .map(From::from);
58        Ok(relation_instance)
59    }
60
61    pub async fn set_property<ID: Into<RelationInstanceId>, S: Into<String>, V: Into<Value>>(
62        &self,
63        id: ID,
64        name: S,
65        value: V,
66    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
67        let id = id.into();
68        let name = name.into();
69        let value = value.into();
70        let relation_instance = self
71            .client
72            .client
73            .post(self.client.url_reactive_graph())
74            .run_graphql(set_property(&id, name, value))
75            .await
76            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
77            .data
78            .map(|data| data.instances.relations.update)
79            .map(From::from);
80        Ok(relation_instance)
81    }
82
83    pub async fn add_property<ID: Into<RelationInstanceId>, PT: Into<PropertyType>>(
84        &self,
85        id: ID,
86        property_type: PT,
87    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
88        let id = id.into();
89        let property_type = property_type.into();
90        let relation_instance = self
91            .client
92            .client
93            .post(self.client.url_reactive_graph())
94            .run_graphql(add_property(&id, property_type))
95            .await
96            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
97            .data
98            .map(|data| data.instances.relations.update)
99            .map(From::from);
100        Ok(relation_instance)
101    }
102
103    pub async fn remove_property<ID: Into<RelationInstanceId>, S: Into<String>>(
104        &self,
105        id: ID,
106        property_name: S,
107    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
108        let id = id.into();
109        let property_name = property_name.into();
110        let relation_instance = self
111            .client
112            .client
113            .post(self.client.url_reactive_graph())
114            .run_graphql(remove_property(&id, property_name))
115            .await
116            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
117            .data
118            .map(|data| data.instances.relations.update)
119            .map(From::from);
120        Ok(relation_instance)
121    }
122
123    pub async fn add_component<ID: Into<RelationInstanceId>, C: Into<ComponentTypeId>>(
124        &self,
125        id: ID,
126        component_ty: C,
127    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
128        let id = id.into();
129        let component_ty = component_ty.into();
130        let relation_instance = self
131            .client
132            .client
133            .post(self.client.url_reactive_graph())
134            .run_graphql(add_component(&id, component_ty))
135            .await
136            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
137            .data
138            .map(|data| data.instances.relations.update)
139            .map(From::from);
140        Ok(relation_instance)
141    }
142
143    pub async fn remove_component<ID: Into<RelationInstanceId>, C: Into<ComponentTypeId>>(
144        &self,
145        id: ID,
146        component_ty: C,
147    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
148        let id = id.into();
149        let component_ty = component_ty.into();
150        let relation_instance = self
151            .client
152            .client
153            .post(self.client.url_reactive_graph())
154            .run_graphql(remove_component(&id, component_ty))
155            .await
156            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
157            .data
158            .map(|data| data.instances.relations.update)
159            .map(From::from);
160        Ok(relation_instance)
161    }
162
163    pub async fn create<ID: Into<RelationInstanceId>>(
164        &self,
165        id: ID,
166        description: Option<String>,
167        properties: PropertyInstances,
168    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
169        let id = id.into();
170        let relation_instance = self
171            .client
172            .client
173            .post(self.client.url_reactive_graph())
174            .run_graphql(create(&id, description, properties))
175            .await
176            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
177            .data
178            .map(|data| data.instances.relations.create)
179            .map(From::from);
180        Ok(relation_instance)
181    }
182
183    pub async fn delete<ID: Into<RelationInstanceId>>(&self, id: ID) -> Result<Option<bool>, ReactiveGraphClientExecutionError> {
184        let id = id.into();
185        let relation_instance = self
186            .client
187            .client
188            .post(self.client.url_reactive_graph())
189            .run_graphql(delete(&id))
190            .await
191            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
192            .data
193            .map(|data| data.instances.relations.delete);
194        Ok(relation_instance)
195    }
196}