reactive_graph_dynamic_graph_impl/
query_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::ComponentQueryFieldFactory;
13use reactive_graph_dynamic_graph_api::EntityQueryFieldFactory;
14use reactive_graph_dynamic_graph_api::FlowQueryFieldFactory;
15use reactive_graph_dynamic_graph_api::QueryNamespaceObjectTreeFactory;
16use reactive_graph_dynamic_graph_api::ROOT_OBJECT_NAME_QUERY;
17use reactive_graph_dynamic_graph_api::RelationQueryFieldFactory;
18use reactive_graph_dynamic_graph_api::RootObjectType::Query;
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 QueryNamespaceObjectTreeFactoryImpl {
29    namespaced_type_manager: Arc<dyn NamespacedTypeManager + Send + Sync>,
30    component_query_field_factory: Arc<dyn ComponentQueryFieldFactory + Send + Sync>,
31    entity_query_field_factory: Arc<dyn EntityQueryFieldFactory + Send + Sync>,
32    flow_query_field_factory: Arc<dyn FlowQueryFieldFactory + Send + Sync>,
33    relation_query_field_factory: Arc<dyn RelationQueryFieldFactory + Send + Sync>,
34}
35
36impl QueryNamespaceObjectTreeFactoryImpl {}
37
38#[async_trait]
39#[component_alias]
40impl QueryNamespaceObjectTreeFactory for QueryNamespaceObjectTreeFactoryImpl {
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_query_field_factory.create_query_fields(&namespace) {
51                object = object.field(field);
52            }
53            for field in self.entity_query_field_factory.create_query_fields(&namespace) {
54                object = object.field(field);
55            }
56            for field in self.relation_query_field_factory.create_query_fields(&namespace) {
57                object = object.field(field);
58            }
59            for field in self.flow_query_field_factory.create_query_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(), Query);
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_QUERY}");
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!("Create 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, Query);
97        trace!("Create namespace {Query} object {object_type_name} for Namespace({namespace})");
98        let object = Object::new(object_type_name)
99            .description(format!(
100                "Queries for components, entities and relations on the namespace {}",
101                &namespace.to_string().to_case(Pascal)
102            ))
103            .field(namespace_path_field(namespace.clone()));
104        object
105    }
106
107    fn create_root_object(&self) -> Object {
108        trace!("Create root object {ROOT_OBJECT_NAME_QUERY}");
109        Object::new(ROOT_OBJECT_NAME_QUERY)
110            .description("Queries")
111            .field(root_object_namespace_path_field())
112    }
113}
114
115#[async_trait]
116impl Lifecycle for QueryNamespaceObjectTreeFactoryImpl {}