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 crate::schema_graphql::instances::relation_instance::RelationInstances as RelationInstancesVec;
16
17use cynic::http::ReqwestExt;
18use reactive_graph_graph::ComponentTypeId;
19use reactive_graph_graph::PropertyInstances;
20use reactive_graph_graph::PropertyType;
21use reactive_graph_graph::RelationInstance;
22use reactive_graph_graph::RelationInstanceId;
23use serde_json::Value;
24
25pub struct RelationInstances {
26    client: Arc<ReactiveGraphClient>,
27}
28
29impl RelationInstances {
30    pub fn new(client: Arc<ReactiveGraphClient>) -> Self {
31        Self { client }
32    }
33
34    pub async fn search(
35        &self,
36        search_query: SearchRelationInstancesVariables,
37    ) -> Result<Option<reactive_graph_graph::RelationInstances>, ReactiveGraphClientExecutionError> {
38        let Some(relation_instances) = self
39            .client
40            .client
41            .post(self.client.url_reactive_graph())
42            .run_graphql(search(search_query))
43            .await
44            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
45            .data
46            .map(|data| RelationInstancesVec(data.instances.relations))
47        else {
48            return Ok(None);
49        };
50        Ok(Some(
51            reactive_graph_graph::RelationInstances::try_from(relation_instances).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
52        ))
53    }
54
55    pub async fn get_by_id<ID: Into<RelationInstanceId>>(&self, id: ID) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
56        let id = id.into();
57        let Some(relation_instance) = self
58            .client
59            .client
60            .post(self.client.url_reactive_graph())
61            .run_graphql(get_by_id(&id))
62            .await
63            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
64            .data
65            .and_then(|data| data.instances.relations.first().cloned())
66        else {
67            return Ok(None);
68        };
69        Ok(Some(
70            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
71        ))
72    }
73
74    pub async fn set_property<ID: Into<RelationInstanceId>, S: Into<String>, V: Into<Value>>(
75        &self,
76        id: ID,
77        name: S,
78        value: V,
79    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
80        let id = id.into();
81        let name = name.into();
82        let value = value.into();
83        let Some(relation_instance) = self
84            .client
85            .client
86            .post(self.client.url_reactive_graph())
87            .run_graphql(set_property(&id, name, value))
88            .await
89            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
90            .data
91            .map(|data| data.instances.relations.update)
92        else {
93            return Ok(None);
94        };
95        Ok(Some(
96            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
97        ))
98    }
99
100    pub async fn add_property<ID: Into<RelationInstanceId>, PT: Into<PropertyType>>(
101        &self,
102        id: ID,
103        property_type: PT,
104    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
105        let id = id.into();
106        let property_type = property_type.into();
107        let Some(relation_instance) = self
108            .client
109            .client
110            .post(self.client.url_reactive_graph())
111            .run_graphql(add_property(&id, property_type))
112            .await
113            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
114            .data
115            .map(|data| data.instances.relations.update)
116        else {
117            return Ok(None);
118        };
119        Ok(Some(
120            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
121        ))
122    }
123
124    pub async fn remove_property<ID: Into<RelationInstanceId>, S: Into<String>>(
125        &self,
126        id: ID,
127        property_name: S,
128    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
129        let id = id.into();
130        let property_name = property_name.into();
131        let Some(relation_instance) = self
132            .client
133            .client
134            .post(self.client.url_reactive_graph())
135            .run_graphql(remove_property(&id, property_name))
136            .await
137            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
138            .data
139            .map(|data| data.instances.relations.update)
140        else {
141            return Ok(None);
142        };
143        Ok(Some(
144            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
145        ))
146    }
147
148    pub async fn add_component<ID: Into<RelationInstanceId>, C: Into<ComponentTypeId>>(
149        &self,
150        id: ID,
151        component_ty: C,
152    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
153        let id = id.into();
154        let component_ty = component_ty.into();
155        let Some(relation_instance) = self
156            .client
157            .client
158            .post(self.client.url_reactive_graph())
159            .run_graphql(add_component(&id, component_ty))
160            .await
161            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
162            .data
163            .map(|data| data.instances.relations.update)
164        else {
165            return Ok(None);
166        };
167        Ok(Some(
168            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
169        ))
170    }
171
172    pub async fn remove_component<ID: Into<RelationInstanceId>, C: Into<ComponentTypeId>>(
173        &self,
174        id: ID,
175        component_ty: C,
176    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
177        let id = id.into();
178        let component_ty = component_ty.into();
179        let Some(relation_instance) = self
180            .client
181            .client
182            .post(self.client.url_reactive_graph())
183            .run_graphql(remove_component(&id, component_ty))
184            .await
185            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
186            .data
187            .map(|data| data.instances.relations.update)
188        else {
189            return Ok(None);
190        };
191        Ok(Some(
192            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
193        ))
194    }
195
196    pub async fn create<ID: Into<RelationInstanceId>>(
197        &self,
198        id: ID,
199        description: Option<String>,
200        properties: PropertyInstances,
201    ) -> Result<Option<RelationInstance>, ReactiveGraphClientExecutionError> {
202        let id = id.into();
203        let Some(relation_instance) = self
204            .client
205            .client
206            .post(self.client.url_reactive_graph())
207            .run_graphql(create(&id, description, properties))
208            .await
209            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
210            .data
211            .map(|data| data.instances.relations.create)
212        else {
213            return Ok(None);
214        };
215        Ok(Some(
216            reactive_graph_graph::RelationInstance::try_from(relation_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidRelationInstance(e))?,
217        ))
218    }
219
220    pub async fn delete<ID: Into<RelationInstanceId>>(&self, id: ID) -> Result<Option<bool>, ReactiveGraphClientExecutionError> {
221        let id = id.into();
222        let success = self
223            .client
224            .client
225            .post(self.client.url_reactive_graph())
226            .run_graphql(delete(&id))
227            .await
228            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
229            .data
230            .map(|data| data.instances.relations.delete);
231        Ok(success)
232    }
233}