reactive_graph_client/client/instances/entities/
api.rs1use 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}