reactive_graph_dynamic_graph_impl/
mutation_namespace_object_tree_factory_impl.rs

1use crate::field::namespace_field;
2use crate::field::namespace_field_name;
3use crate::field::namespace_path_field;
4use crate::field::root_object_namespace_path_field;
5use crate::object_type_name::namespace_type_name;
6use async_graphql::dynamic::Object;
7use async_trait::async_trait;
8use convert_case::Case::Pascal;
9use convert_case::Casing;
10use log::trace;
11use log::warn;
12use reactive_graph_dynamic_graph_api::ComponentMutationFieldFactory;
13use reactive_graph_dynamic_graph_api::EntityMutationFieldFactory;
14use reactive_graph_dynamic_graph_api::FlowMutationFieldFactory;
15use reactive_graph_dynamic_graph_api::MutationNamespaceObjectTreeFactory;
16use reactive_graph_dynamic_graph_api::ROOT_OBJECT_NAME_MUTATION;
17use reactive_graph_dynamic_graph_api::RelationMutationFieldFactory;
18use reactive_graph_dynamic_graph_api::RootObjectType::Mutation;
19use reactive_graph_graph::Namespace;
20use reactive_graph_lifecycle::Lifecycle;
21use reactive_graph_type_system_api::NamespacedTypeManager;
22use springtime_di::Component;
23use springtime_di::component_alias;
24use std::collections::BTreeMap;
25use std::sync::Arc;
26
27#[derive(Component)]
28pub struct MutationNamespaceObjectTreeFactoryImpl {
29    namespaced_type_manager: Arc<dyn NamespacedTypeManager + Send + Sync>,
30    component_mutation_field_factory: Arc<dyn ComponentMutationFieldFactory + Send + Sync>,
31    entity_mutation_field_factory: Arc<dyn EntityMutationFieldFactory + Send + Sync>,
32    flow_mutation_field_factory: Arc<dyn FlowMutationFieldFactory + Send + Sync>,
33    relation_mutation_field_factory: Arc<dyn RelationMutationFieldFactory + Send + Sync>,
34}
35
36impl MutationNamespaceObjectTreeFactoryImpl {}
37
38#[async_trait]
39#[component_alias]
40impl MutationNamespaceObjectTreeFactory for MutationNamespaceObjectTreeFactoryImpl {
41    fn get_namespace_objects(&self) -> Vec<Object> {
42        let namespaced_types = self.namespaced_type_manager.get_all();
43        let namespaces = namespaced_types.get_all_parent_paths_recursively();
44        let mut root_object = self.create_root_object();
45        let mut object_tree = BTreeMap::<Namespace, Object>::new();
46        for namespace in namespaces {
47            // Create object
48            let mut object = self.create_namespace_object(&namespace);
49            // Create fields
50            for field in self.component_mutation_field_factory.create_mutation_fields(&namespace) {
51                object = object.field(field);
52            }
53            for field in self.entity_mutation_field_factory.create_mutation_fields(&namespace) {
54                object = object.field(field);
55            }
56            for field in self.relation_mutation_field_factory.get_mutation_fields(&namespace) {
57                object = object.field(field);
58            }
59            for field in self.flow_mutation_field_factory.create_mutation_fields(&namespace) {
60                object = object.field(field);
61            }
62            object_tree.insert(namespace.clone(), object);
63            // Create field in parent object or root object if there is no parent object
64            let field = namespace_field(namespace.clone(), Mutation);
65            let namespace_field_name = namespace_field_name(&namespace);
66            match namespace.parent() {
67                None => {
68                    // Create field in root object
69                    root_object = root_object.field(field);
70                    trace!("Create field {namespace_field_name} for Namespace({namespace}) in root object {ROOT_OBJECT_NAME_MUTATION}");
71                }
72                Some(parent_namespace) => {
73                    // Create field in parent namespace
74                    match object_tree.remove(&parent_namespace) {
75                        None => {
76                            // Should never happen because of the BTreeMap
77                            warn!("Missing object for parent Namespace({parent_namespace})");
78                        }
79                        Some(parent_object) => {
80                            let parent_object = parent_object.field(field);
81                            object_tree.insert(parent_namespace.clone(), parent_object);
82                            trace!("Created field {namespace_field_name} for Namespace({namespace}) in parent Namespace({parent_namespace})");
83                        }
84                    }
85                }
86            }
87        }
88        let mut objects = vec![root_object];
89        for (_, object) in object_tree.into_iter() {
90            objects.push(object);
91        }
92        objects
93    }
94
95    fn create_namespace_object(&self, namespace: &Namespace) -> Object {
96        let object_type_name = namespace_type_name(namespace, Mutation);
97        trace!("Create namespace {Mutation} object {object_type_name} for Namespace({namespace})");
98        Object::new(namespace_type_name(namespace, Mutation))
99            .description(format!(
100                "Mutations for components, entities and relations on the namespace {}",
101                &namespace.to_string().to_case(Pascal)
102            ))
103            .field(namespace_path_field(namespace.clone()))
104    }
105
106    fn create_root_object(&self) -> Object {
107        trace!("Create root object {ROOT_OBJECT_NAME_MUTATION}");
108        Object::new(ROOT_OBJECT_NAME_MUTATION)
109            .description("Mutations")
110            .field(root_object_namespace_path_field())
111    }
112}
113
114#[async_trait]
115impl Lifecycle for MutationNamespaceObjectTreeFactoryImpl {}