reactive_graph_client/client/instances/entities/
api.rs

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