reactive_graph_graphql_schema/mutation/instances/
relation_instance.rs1use std::str::FromStr;
2use std::sync::Arc;
3
4use crate::mutation::GraphQLExtensionDefinition;
5use crate::mutation::GraphQLExtensionDefinitions;
6use crate::mutation::GraphQLPropertyConnectorId;
7use crate::mutation::GraphQLRelationInstanceId;
8use crate::mutation::PropertyTypeDefinitions;
9use crate::query::GraphQLPropertyInstance;
10use crate::query::GraphQLRelationInstance;
11use async_graphql::Context;
12use async_graphql::Object;
13use async_graphql::Result;
14use log::debug;
15use reactive_graph_behaviour_model_api::BehaviourTypeId;
16use reactive_graph_behaviour_service_api::RelationBehaviourManager;
17use reactive_graph_behaviour_service_api::RelationComponentBehaviourManager;
18use reactive_graph_graph::ComponentTypeIds;
19use reactive_graph_graph::CreatePropertyConnectorError;
20use reactive_graph_graph::CreateRelationInstanceError;
21use reactive_graph_graph::PropertyInstanceSetter;
22use reactive_graph_graph::RelationInstance;
23use reactive_graph_graph::RelationInstanceId;
24use reactive_graph_graph::RemoveRelationInstanceError;
25use reactive_graph_graph::TriggerRelationInstanceError;
26use reactive_graph_graph::UpdateRelationInstanceError;
27use reactive_graph_model_core::reactive_graph::core::action::ActionProperties::TRIGGER;
28use reactive_graph_reactive_model_api::ReactivePropertyContainer;
29use reactive_graph_reactive_service_api::ReactiveEntityManager;
30use reactive_graph_reactive_service_api::ReactiveRelationManager;
31use reactive_graph_type_system_api::ComponentManager;
32use reactive_graph_type_system_api::RelationTypeManager;
33use serde_json::json;
34
35#[derive(Default)]
36pub struct MutationRelationInstances;
37
38#[Object]
40impl MutationRelationInstances {
41 async fn create(
57 &self,
58 context: &Context<'_>,
59 #[graphql(desc = "Specifies the outbound id, the inbound id, the relation type and the instance_id.")] relation_instance_id: GraphQLRelationInstanceId,
60 #[graphql(desc = "Name of the relation instance.")] name: Option<String>,
61 #[graphql(desc = "Description of the relation instance.")] description: Option<String>,
62 #[graphql(desc = "Creates the relation instance with the given components.")] components: Option<Vec<String>>,
63 #[graphql(
64 desc = "Initial value of the properties to set. If properties are not provided, default values will be used depending on the data type of the property."
65 )]
66 properties: Option<Vec<GraphQLPropertyInstance>>,
67 #[graphql(desc = "The extensions of the relation instance.")] extensions: Option<Vec<GraphQLExtensionDefinition>>,
68 ) -> Result<GraphQLRelationInstance> {
69 let component_manager = context.data::<Arc<dyn ComponentManager + Send + Sync>>()?;
70 let relation_type_manager = context.data::<Arc<dyn RelationTypeManager + Send + Sync>>()?;
71 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
72 let reactive_entity_manager = context.data::<Arc<dyn ReactiveEntityManager + Send + Sync>>()?;
73
74 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
75 let relation_ty = relation_instance_id.ty.relation_type_id();
76
77 let component_tys = ComponentTypeIds::parse_optional_namespaces(components)?;
78 let extensions = GraphQLExtensionDefinitions::parse_optional_definitions(extensions)?;
79
80 let relation_type = relation_type_manager
81 .get(&relation_ty)
82 .ok_or(CreateRelationInstanceError::RelationTypeDoesNotExist(relation_ty.clone()))?;
83
84 if !reactive_entity_manager.has(relation_instance_id.outbound_id) {
85 return Err(CreateRelationInstanceError::OutboundEntityInstanceDoesNotExist(relation_ty, relation_instance_id.outbound_id).into());
86 }
87
88 if !reactive_entity_manager.has(relation_instance_id.inbound_id) {
89 return Err(CreateRelationInstanceError::InboundEntityInstanceDoesNotExist(relation_ty, relation_instance_id.inbound_id).into());
90 }
91
92 if !component_manager.has_all(&component_tys) {
93 return Err(CreateRelationInstanceError::ComponentsDoesNotExist.into());
94 }
95
96 let properties = GraphQLPropertyInstance::to_property_instances_with_defaults(properties, relation_type.properties);
97
98 let relation_instance = RelationInstance::builder()
99 .outbound_id(relation_instance_id.outbound_id)
100 .ty(relation_instance_id.ty.clone())
101 .inbound_id(relation_instance_id.inbound_id)
102 .name(name.unwrap_or_default())
103 .description(description.unwrap_or_default())
104 .properties(properties)
105 .extensions(extensions)
106 .build();
107
108 let reactive_relation = reactive_relation_manager.create_reactive_instance(relation_instance)?;
112
113 for component_ty in component_tys {
114 let _ = reactive_relation_manager.add_component(&relation_instance_id, &component_ty);
116 }
117 Ok(reactive_relation.into())
118 }
119
120 #[allow(clippy::too_many_arguments)]
124 async fn create_connector(
125 &self,
126 context: &Context<'_>,
127 #[graphql(name = "id", desc = "The id of the property connector instance")] connector_id: GraphQLPropertyConnectorId,
128 #[graphql(desc = "Name of the relation instance.")] name: Option<String>,
129 #[graphql(desc = "Description of the relation instance.")] description: Option<String>,
130 #[graphql(desc = "Creates the relation instance with the given components.")] components: Option<Vec<String>>,
131 #[graphql(desc = "The initial property values")] properties: Option<Vec<GraphQLPropertyInstance>>,
132 #[graphql(desc = "The extensions of the relation instance.")] extensions: Option<Vec<GraphQLExtensionDefinition>>,
133 ) -> Result<GraphQLRelationInstance> {
134 let component_manager = context.data::<Arc<dyn ComponentManager + Send + Sync>>()?;
135 let relation_type_manager = context.data::<Arc<dyn RelationTypeManager + Send + Sync>>()?;
136 let reactive_entity_manager = context.data::<Arc<dyn ReactiveEntityManager + Send + Sync>>()?;
137 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
138
139 let ty = connector_id.parse()?;
140 let relation_ty = ty.relation_type_id();
141 let component_tys = ComponentTypeIds::parse_optional_namespaces(components)?;
142 let extensions = GraphQLExtensionDefinitions::parse_optional_definitions(extensions)?;
143
144 let relation_type = relation_type_manager
146 .get(&relation_ty)
147 .ok_or(CreateRelationInstanceError::RelationTypeDoesNotExist(relation_ty.clone()))?;
148
149 let outbound = reactive_entity_manager
151 .get(connector_id.outbound.id)
152 .ok_or(CreateRelationInstanceError::OutboundEntityInstanceDoesNotExist(relation_ty.clone(), connector_id.outbound.id))?;
153
154 let inbound = reactive_entity_manager
156 .get(connector_id.inbound.id)
157 .ok_or(CreateRelationInstanceError::InboundEntityInstanceDoesNotExist(relation_ty.clone(), connector_id.inbound.id))?;
158
159 if !outbound.has_property(&connector_id.outbound.property_name) {
161 return Err(CreatePropertyConnectorError::OutboundPropertyDoesNotExist(
162 relation_ty.clone(),
163 connector_id.outbound.id,
164 connector_id.outbound.property_name.clone(),
165 )
166 .into());
167 }
168
169 if !inbound.has_property(&connector_id.inbound.property_name) {
171 return Err(CreatePropertyConnectorError::InboundPropertyDoesNotExist(
172 relation_ty.clone(),
173 connector_id.inbound.id,
174 connector_id.inbound.property_name.clone(),
175 )
176 .into());
177 }
178
179 if !component_manager.has_all(&component_tys) {
180 return Err(CreateRelationInstanceError::ComponentsDoesNotExist.into());
181 }
182
183 let properties = GraphQLPropertyInstance::to_property_instances_with_defaults(properties, relation_type.properties);
184 properties.insert("outbound_property_name".to_string(), json!(connector_id.outbound.property_name));
187 properties.insert("inbound_property_name".to_string(), json!(connector_id.inbound.property_name));
188
189 let relation_instance = RelationInstance::builder()
190 .outbound_id(connector_id.outbound.id)
191 .ty(ty)
192 .inbound_id(connector_id.inbound.id)
193 .name(name.unwrap_or_default())
194 .description(description.unwrap_or_default())
195 .properties(properties)
196 .extensions(extensions)
197 .build();
198
199 let id = relation_instance.id();
200
201 let reactive_relation = reactive_relation_manager.create_reactive_instance(relation_instance)?;
202
203 for component_ty in component_tys {
204 let _ = reactive_relation_manager.add_component(&id, &component_ty);
206 }
207 Ok(reactive_relation.into())
208 }
209
210 #[allow(clippy::too_many_arguments)]
212 async fn update(
213 &self,
214 context: &Context<'_>,
215 #[graphql(desc = "Specifies the outbound id, the inbound id, the relation type and the instance_id.")] relation_instance_id: GraphQLRelationInstanceId,
216 #[graphql(desc = "Adds the components with the given name")] add_components: Option<Vec<String>>,
217 #[graphql(desc = "Removes the components with the given name")] remove_components: Option<Vec<String>>,
218 #[graphql(desc = "Updates the given properties")] properties: Option<Vec<GraphQLPropertyInstance>>,
219 #[graphql(desc = "Adds the given properties")] add_properties: Option<Vec<crate::mutation::PropertyTypeDefinition>>,
220 #[graphql(desc = "Removes the given properties")] remove_properties: Option<Vec<String>>,
221 ) -> Result<GraphQLRelationInstance> {
222 let component_manager = context.data::<Arc<dyn ComponentManager + Send + Sync>>()?;
223 let relation_type_manager = context.data::<Arc<dyn RelationTypeManager + Send + Sync>>()?;
224 let reactive_entity_manager = context.data::<Arc<dyn ReactiveEntityManager + Send + Sync>>()?;
225 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
226
227 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
228 let relation_ty = relation_instance_id.ty.relation_type_id();
229 let add_component_tys = ComponentTypeIds::parse_optional_namespaces(add_components)?;
230 let remove_component_tys = ComponentTypeIds::parse_optional_namespaces(remove_components)?;
231 let add_properties = PropertyTypeDefinitions::parse_optional_definitions(add_properties)?;
232
233 if !relation_type_manager.has(&relation_ty) {
234 return Err(UpdateRelationInstanceError::RelationTypeDoesNotExist(relation_ty.clone()).into());
235 }
236
237 if !reactive_entity_manager.has(relation_instance_id.outbound_id) {
238 return Err(UpdateRelationInstanceError::OutboundEntityInstanceDoesNotExist(relation_instance_id.outbound_id).into());
239 }
240
241 if !reactive_entity_manager.has(relation_instance_id.inbound_id) {
242 return Err(UpdateRelationInstanceError::InboundEntityInstanceDoesNotExist(relation_instance_id.inbound_id).into());
243 }
244
245 if !component_manager.has_all(&add_component_tys) || !component_manager.has_all(&remove_component_tys) {
246 return Err(CreateRelationInstanceError::ComponentsDoesNotExist.into());
247 }
248
249 let reactive_relation = reactive_relation_manager
250 .get(&relation_instance_id)
251 .ok_or(UpdateRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id.clone()))?;
252
253 for component_ty in add_component_tys {
254 let _ = reactive_relation_manager.add_component(&relation_instance_id, &component_ty);
256 }
257 for component_ty in remove_component_tys {
258 let _ = reactive_relation_manager.remove_component(&relation_instance_id, &component_ty);
260 }
261 if let Some(properties) = properties {
262 for property in properties.clone() {
264 debug!("set property {} = {}", property.name.clone(), property.value.clone());
265 reactive_relation.set_no_propagate_checked(&property.name, property.value.clone());
267 }
268 for property in properties {
270 debug!("tick property {} = {}", property.name.clone(), property.value.clone());
271 if let Some(property_instance) = reactive_relation.properties.get(property.name.as_str()) {
272 property_instance.tick_checked();
274 }
275 }
276 }
278 for property_type in add_properties.iter() {
279 debug!("add property {} ({})", &property_type.name, &property_type.data_type);
281 reactive_relation.add_property_by_type(&property_type);
282 }
283 if let Some(remove_properties) = remove_properties {
284 for property_name in remove_properties.iter() {
285 debug!("remove property {property_name}");
286 reactive_relation.remove_property(property_name);
287 }
288 }
289 Ok(reactive_relation.into())
290 }
291
292 async fn trigger(
294 &self,
295 context: &Context<'_>,
296 #[graphql(desc = "Specifies the outbound id, the inbound id, the relation type and the instance_id.")] relation_instance_id: GraphQLRelationInstanceId,
297 ) -> Result<GraphQLRelationInstance> {
298 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
299 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
300 let reactive_relation = reactive_relation_manager
301 .get(&relation_instance_id)
302 .ok_or(TriggerRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id.clone()))?;
303 if !reactive_relation.has_property(TRIGGER.as_ref()) {
304 return Err(TriggerRelationInstanceError::TriggerPropertyMissing(relation_instance_id).into());
305 }
306 reactive_relation.set_checked(TRIGGER.as_ref(), json!(true));
307 Ok(reactive_relation.into())
308 }
309
310 async fn tick(&self, context: &Context<'_>, relation_instance_id: GraphQLRelationInstanceId) -> Result<GraphQLRelationInstance> {
319 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
320 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
321 let relation_instance = reactive_relation_manager
322 .get(&relation_instance_id)
323 .ok_or(UpdateRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id))?;
324 relation_instance.tick();
325 Ok(relation_instance.into())
326 }
327
328 async fn delete(&self, context: &Context<'_>, relation_instance_id: GraphQLRelationInstanceId) -> Result<bool> {
330 let reactive_relation_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
331 let entity_instance_manager = context.data::<Arc<dyn ReactiveEntityManager + Send + Sync>>()?;
332 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
333 if !reactive_relation_manager.has(&relation_instance_id) {
334 return Err(RemoveRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id).into());
335 }
336 if !entity_instance_manager.has(relation_instance_id.outbound_id) {
337 return Err(RemoveRelationInstanceError::OutboundEntityInstanceDoesNotExist(relation_instance_id.outbound_id).into());
338 }
339 if !entity_instance_manager.has(relation_instance_id.inbound_id) {
340 return Err(RemoveRelationInstanceError::InboundEntityInstanceDoesNotExist(relation_instance_id.inbound_id).into());
341 }
342 Ok(reactive_relation_manager.delete(&relation_instance_id))
343 }
344
345 async fn connect(
346 &self,
347 context: &Context<'_>,
348 relation_instance_id: GraphQLRelationInstanceId,
349 #[graphql(name = "behaviour", desc = "The fully qualified namespace of the behaviour")] behaviour_namespace: String,
350 ) -> Result<GraphQLRelationInstance> {
351 let relation_instance_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
352 let relation_behaviour_manager = context.data::<Arc<dyn RelationBehaviourManager + Send + Sync>>()?;
353 let relation_component_behaviour_manager = context.data::<Arc<dyn RelationComponentBehaviourManager + Send + Sync>>()?;
354 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
355 let behaviour_ty = BehaviourTypeId::from_str(&behaviour_namespace)?;
356 let reactive_instance = relation_instance_manager
357 .get(&relation_instance_id)
358 .ok_or(UpdateRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id))?;
359 let behaviour_ty = BehaviourTypeId::from(behaviour_ty);
360 if relation_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
361 relation_behaviour_manager.connect(reactive_instance.clone(), &behaviour_ty)?;
362 }
363 if relation_component_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
364 relation_component_behaviour_manager.connect(reactive_instance.clone(), &behaviour_ty)?;
365 }
366 Ok(reactive_instance.into())
367 }
368
369 async fn disconnect(
370 &self,
371 context: &Context<'_>,
372 relation_instance_id: GraphQLRelationInstanceId,
373 #[graphql(name = "behaviour", desc = "The fully qualified namespace of the behaviour")] behaviour_namespace: String,
374 ) -> Result<GraphQLRelationInstance> {
375 let relation_instance_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
376 let relation_behaviour_manager = context.data::<Arc<dyn RelationBehaviourManager + Send + Sync>>()?;
377 let relation_component_behaviour_manager = context.data::<Arc<dyn RelationComponentBehaviourManager + Send + Sync>>()?;
378 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
379 let behaviour_ty = BehaviourTypeId::from_str(&behaviour_namespace)?;
380 let reactive_instance = relation_instance_manager
381 .get(&relation_instance_id)
382 .ok_or(UpdateRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id))?;
383 let behaviour_ty = BehaviourTypeId::from(behaviour_ty);
384 if relation_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
385 relation_behaviour_manager.disconnect(reactive_instance.clone(), &behaviour_ty)?;
386 }
387 if relation_component_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
388 relation_component_behaviour_manager.disconnect(reactive_instance.clone(), &behaviour_ty)?;
389 }
390 Ok(reactive_instance.into())
391 }
392
393 async fn reconnect(
394 &self,
395 context: &Context<'_>,
396 relation_instance_id: GraphQLRelationInstanceId,
397 #[graphql(name = "behaviour", desc = "The fully qualified namespace of the behaviour")] behaviour_namespace: String,
398 ) -> Result<GraphQLRelationInstance> {
399 let relation_instance_manager = context.data::<Arc<dyn ReactiveRelationManager + Send + Sync>>()?;
400 let relation_behaviour_manager = context.data::<Arc<dyn RelationBehaviourManager + Send + Sync>>()?;
401 let relation_component_behaviour_manager = context.data::<Arc<dyn RelationComponentBehaviourManager + Send + Sync>>()?;
402 let relation_instance_id = RelationInstanceId::try_from(relation_instance_id)?;
403 let behaviour_ty = BehaviourTypeId::from_str(&behaviour_namespace)?;
404 let reactive_instance = relation_instance_manager
405 .get(&relation_instance_id)
406 .ok_or(UpdateRelationInstanceError::RelationInstanceDoesNotExist(relation_instance_id))?;
407 let behaviour_ty = BehaviourTypeId::from(behaviour_ty);
408 if relation_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
409 relation_behaviour_manager.reconnect(reactive_instance.clone(), &behaviour_ty)?;
410 }
411 if relation_component_behaviour_manager.has(reactive_instance.clone(), &behaviour_ty) {
412 relation_component_behaviour_manager.reconnect(reactive_instance.clone(), &behaviour_ty)?;
413 }
414 Ok(reactive_instance.into())
415 }
416}