reactive_graph_graphql_schema/mutation/instances/
relation_instance.rs

1use 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/// Mutation of relation instances.
39#[Object]
40impl MutationRelationInstances {
41    /// Creates a new relation instance with the given relation_instance_id.
42    ///
43    /// The relation instance id is the primary key of a relation instance and consists of the id of the
44    /// outbound entity instance, the name of the relation type and the id of the inbound
45    /// entity instance.
46    ///
47    /// The relation type must exist and the given type name is matched by a prefix search.
48    /// For example a given type name "default_connector--property_name--property_name" will match
49    /// as relation type "default_connector".
50    ///
51    /// Furthermore, the outbound and the inbound entity instance must exist.
52    ///
53    /// The given properties consists of a list of pairs of property name and property value.
54    /// If properties are not provided, default values will be used depending on the data type
55    /// of the property.
56    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 id = RelationInstanceId::from(relation_instance_id);
109        // let id: RelationInstanceId = .into();
110
111        let reactive_relation = reactive_relation_manager.create_reactive_instance(relation_instance)?;
112
113        for component_ty in component_tys {
114            // TODO: handle components which have not been added
115            let _ = reactive_relation_manager.add_component(&relation_instance_id, &component_ty);
116        }
117        Ok(reactive_relation.into())
118    }
119
120    /// Creates a connector from a property of the outbound entity instance to a property of the inbound entity instance.
121    ///
122    /// The type_name must match a relation type exactly.
123    #[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        // Resolve the relation type or throw error
145        let relation_type = relation_type_manager
146            .get(&relation_ty)
147            .ok_or(CreateRelationInstanceError::RelationTypeDoesNotExist(relation_ty.clone()))?;
148
149        // The outbound entity instance must exist
150        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        // The inbound entity instance must exist
155        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        // The outbound entity instance's property must exist
160        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        // The inbound entity instance's property must exist
170        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        // The relationship stores references to the outbound property and inbound property in its
185        // own properties:
186        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            // TODO: handle components which have not been added
205            let _ = reactive_relation_manager.add_component(&id, &component_ty);
206        }
207        Ok(reactive_relation.into())
208    }
209
210    /// Updates the properties of the given relation instance by its relation instance id.
211    #[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            // TODO: handle components which have not been added
255            let _ = reactive_relation_manager.add_component(&relation_instance_id, &component_ty);
256        }
257        for component_ty in remove_component_tys {
258            // TODO: handle components which have not been removed
259            let _ = reactive_relation_manager.remove_component(&relation_instance_id, &component_ty);
260        }
261        if let Some(properties) = properties {
262            // fill all values first without propagation
263            for property in properties.clone() {
264                debug!("set property {} = {}", property.name.clone(), property.value.clone());
265                // Set with respect to the mutability state
266                reactive_relation.set_no_propagate_checked(&property.name, property.value.clone());
267            }
268            // tick every property that has been changed before, this is still not transactional
269            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                    // Tick with respect to the mutability state
273                    property_instance.tick_checked();
274                }
275            }
276            // TODO: it's still not a transactional mutation
277        }
278        for property_type in add_properties.iter() {
279            // let property_type: PropertyType = property_type.into();
280            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    /// Triggers the relation instance with the given id.
293    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    /// Manually tick the relation instance. This means for each property of the entity instance
311    /// the corresponding reactive stream will be activated with its last value.
312    ///
313    /// This leads to a recalculation if the relation instance is controlled by a behaviour which
314    /// consumes the reactive streams.
315    ///
316    /// In case of the default_connector it does NOT lead to a new value propagation, because the
317    /// reactive streams are not consumed by the default_connector behaviour.
318    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    /// Deletes a relation instance.
329    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}