reactive_graph_dynamic_graph_impl/
dynamic_graph_schema_manager_impl.rs

1use std::ops::Deref;
2use std::sync::Arc;
3use std::sync::RwLock;
4use std::sync::atomic::AtomicBool;
5use std::sync::atomic::Ordering;
6use std::time::Instant;
7
8use async_graphql::dynamic::Schema;
9use async_graphql::dynamic::SchemaError;
10use async_trait::async_trait;
11use log::debug;
12use log::error;
13use log::info;
14use log::trace;
15use reactive_graph_dynamic_graph_api::DynamicGraphSchemaBuilder;
16use reactive_graph_dynamic_graph_api::DynamicGraphSchemaManager;
17use reactive_graph_lifecycle::Lifecycle;
18use reactive_graph_model_core::reactive_graph::core::event::EventProperties::EVENT;
19use reactive_graph_reactive_model_api::ReactivePropertyContainer;
20use reactive_graph_type_system_api::TypeSystemEventManager;
21use reactive_graph_type_system_api::TypeSystemEventTypes;
22use springtime_di::Component;
23use springtime_di::component_alias;
24use uuid::Uuid;
25
26static UUID_TYPE_SYSTEM_CHANGED_EVENT: Uuid = Uuid::from_u128(0x6ba7b8109e1511d150b900c04fe530c7);
27
28fn create_dynamic_schema() -> Arc<RwLock<Option<Arc<Schema>>>> {
29    Arc::new(RwLock::new(None))
30}
31
32fn create_dynamic_schema_modified() -> Arc<AtomicBool> {
33    Arc::new(AtomicBool::new(true))
34}
35
36#[derive(Component)]
37pub struct DynamicGraphSchemaManagerImpl {
38    dynamic_graph_schema_builder: Arc<dyn DynamicGraphSchemaBuilder + Send + Sync>,
39
40    type_system_event_manager: Arc<dyn TypeSystemEventManager + Send + Sync>,
41
42    #[component(default = "create_dynamic_schema")]
43    dynamic_schema: Arc<RwLock<Option<Arc<Schema>>>>,
44
45    #[component(default = "create_dynamic_schema_modified")]
46    type_system_modified_state: Arc<AtomicBool>,
47}
48
49impl DynamicGraphSchemaManagerImpl {
50    async fn generate_dynamic_schema(&self) {
51        let dynamic_schema_lock = self.dynamic_schema.clone();
52        let type_system_modified_state = self.type_system_modified_state.clone();
53        let dynamic_graph_schema_builder = self.dynamic_graph_schema_builder.clone();
54        tokio::spawn(async move {
55            debug!("Start generating dynamic schema");
56            let start = Instant::now();
57            match dynamic_graph_schema_builder.build_dynamic_schema() {
58                Ok(dynamic_schema) => {
59                    let mut guard = dynamic_schema_lock.write().unwrap();
60                    *guard = Some(Arc::new(dynamic_schema));
61                    type_system_modified_state.store(false, Ordering::Relaxed);
62                    let duration = start.elapsed();
63                    debug!("Successfully generated dynamic schema in {duration:?}");
64                }
65                Err(e) => {
66                    error!("Failed to generate dynamic schema: {e}");
67                }
68            }
69        });
70    }
71}
72
73#[async_trait]
74#[component_alias]
75impl DynamicGraphSchemaManager for DynamicGraphSchemaManagerImpl {
76    fn is_type_system_modified(&self) -> bool {
77        self.type_system_modified_state.load(Ordering::Relaxed)
78    }
79
80    async fn regenerate_dynamic_schema(&self) -> Result<(), SchemaError> {
81        trace!("Regenerating dynamic schema");
82        match self.dynamic_graph_schema_builder.build_dynamic_schema() {
83            Ok(dynamic_schema) => {
84                info!("Successfully regenerated dynamic schema");
85                trace!("{}", dynamic_schema.sdl());
86                let mut guard = self.dynamic_schema.write().unwrap();
87                *guard = Some(Arc::new(dynamic_schema));
88                self.type_system_modified_state.store(false, Ordering::Relaxed);
89                Ok(())
90            }
91            Err(e) => {
92                error!("Failed to regenerate dynamic schema: {e}");
93                Err(e)
94            }
95        }
96    }
97
98    async fn regenerate_dynamic_schema_if_modified(&self) -> Result<(), SchemaError> {
99        if !self.is_type_system_modified() {
100            return Ok(());
101        }
102        trace!("The type system has been modified. Regenerating the dynamic schema");
103        self.regenerate_dynamic_schema().await
104    }
105
106    async fn get_dynamic_schema(&self) -> Result<Arc<Schema>, SchemaError> {
107        self.regenerate_dynamic_schema_if_modified().await?;
108        let guard = self.dynamic_schema.read().unwrap();
109        match guard.deref() {
110            Some(schema) => Ok(schema.clone()),
111            None => {
112                error!("Can't get dynamic schema!");
113                Err(SchemaError("Dynamic schema is empty".to_string()))
114            }
115        }
116    }
117}
118
119#[async_trait]
120impl Lifecycle for DynamicGraphSchemaManagerImpl {
121    async fn init(&self) {}
122
123    async fn post_init(&self) {
124        // Initially generate dynamic schema concurrently
125        self.generate_dynamic_schema().await;
126
127        // Listen on type system
128        if let Some(event_type_system_changed) = self
129            .type_system_event_manager
130            .get_type_system_event_instance(TypeSystemEventTypes::TypeSystemChanged)
131        {
132            let type_system_modified_state = self.type_system_modified_state.clone();
133            event_type_system_changed.observe_with_handle(
134                EVENT.as_ref(),
135                move |v| {
136                    if v.is_boolean() && v.as_bool().unwrap() {
137                        // The type system has changed -> regenerate the dynamic schema
138                        info!("The type system has changed -> regenerate the dynamic schema");
139                        type_system_modified_state.store(true, Ordering::Relaxed);
140                    }
141                },
142                UUID_TYPE_SYSTEM_CHANGED_EVENT.as_u128(),
143            );
144        }
145    }
146
147    async fn pre_shutdown(&self) {
148        if let Some(event_type_system_changed) = self
149            .type_system_event_manager
150            .get_type_system_event_instance(TypeSystemEventTypes::TypeSystemChanged)
151        {
152            event_type_system_changed.remove_observer(&EVENT.as_ref(), UUID_TYPE_SYSTEM_CHANGED_EVENT.as_u128());
153        }
154    }
155
156    async fn shutdown(&self) {}
157}