reactive_graph_dynamic_graph_impl/field/property/
mod.rs

1use crate::field::json::to_field_value;
2use crate::field::property::datatype::to_input_type_ref;
3use crate::field::property::datatype::to_type_ref;
4use async_graphql::Error;
5use async_graphql::dynamic::Field;
6use async_graphql::dynamic::FieldFuture;
7use async_graphql::dynamic::InputValue;
8use async_graphql::dynamic::Object;
9use async_graphql::dynamic::ResolverContext;
10use itertools::Itertools;
11use log::trace;
12use log::warn;
13use reactive_graph_dynamic_graph_api::ImmutablePropertyError;
14use reactive_graph_dynamic_graph_api::PropertyContainerValidateUpdateError;
15use reactive_graph_dynamic_graph_api::PropertyDataTypeError;
16use reactive_graph_graph::DataType;
17use reactive_graph_graph::Mutability::Immutable;
18use reactive_graph_graph::Mutability::Mutable;
19use reactive_graph_graph::NamespacedTypeGetter;
20use reactive_graph_graph::PropertyInstanceGetter;
21use reactive_graph_graph::PropertyInstanceSetter;
22use reactive_graph_graph::PropertyType;
23use reactive_graph_graph::PropertyTypeContainer;
24use reactive_graph_reactive_model_api::ReactiveInstanceUnidentifiable;
25use serde_json::Value;
26use serde_json::json;
27use std::sync::Arc;
28
29pub mod datatype;
30
31/// Adds fields for all properties of a `PropertyTypeContainer` to the `PropertyTypeContainer`'s
32/// object.
33pub fn property_container_property_fields<T: PropertyTypeContainer, I: PropertyInstanceGetter + 'static>(
34    property_type_container: &T,
35    mut object: Object,
36) -> Object {
37    for property_type in property_type_container
38        .get_own_properties_cloned()
39        .iter()
40        .sorted_by(|a, b| Ord::cmp(&a.key(), &b.key()))
41    {
42        object = object.field(to_property_field::<I>(&property_type));
43    }
44    object
45}
46
47/// Creates a field for a property type of reactive instance.
48pub fn to_property_field<T: PropertyInstanceGetter + 'static>(property_type: &PropertyType) -> Field {
49    let property_type_inner = property_type.clone();
50    Field::new(&property_type.name, to_type_ref(&property_type.data_type), move |ctx| {
51        let property_type = property_type_inner.clone();
52        FieldFuture::new(async move {
53            if let Ok(reactive_instance) = ctx.parent_value.try_downcast_ref::<T>() {
54                trace!("Resolved reactive instance using type bound");
55                return Ok(reactive_instance.get(&property_type.name).and_then(to_field_value));
56            }
57            if let Ok(reactive_instance) = ctx.parent_value.try_downcast_ref::<Arc<Box<dyn ReactiveInstanceUnidentifiable>>>() {
58                trace!("Resolved reactive instance using downcast to ReactiveInstanceUnidentifiable");
59                return Ok(reactive_instance.as_ref().get(&property_type.name).and_then(to_field_value));
60            }
61            Err(Error::new("Failed to resolve reactive instance"))
62            // match ctx.parent_value.try_downcast_ref::<T>() {
63            //     Ok(reactive_instance) => {
64            //         info!("Using Type Bounds");
65            //         Ok(reactive_instance.get(&property_type.name).and_then(to_field_value))
66            //     }
67            //     Err(_) => {
68            //         info!("Downcast ReactiveInstanceUnidentifiable");
69            //         let reactive_instance = ctx.parent_value.try_downcast_ref::<Arc<Box<dyn ReactiveInstanceUnidentifiable>>>()?;
70            //         // let r = reactive_instance.as_ref().as_ref().get;
71            //         Ok(reactive_instance.as_ref().get(&property_type.name).and_then(to_field_value))
72            //     }
73            // }
74            // let reactive_instance = ctx.parent_value.try_downcast_ref::<T>()?;
75            // info!("y");
76            // Ok(reactive_instance.get(&property_type.name).and_then(to_field_value))
77        })
78    })
79    .description(&property_type.description)
80}
81
82/// Validate all input fields for mutability and correct datatype.
83pub fn property_container_validate_input_fields<T: PropertyTypeContainer>(
84    property_type_container: &T,
85    ctx: &ResolverContext,
86) -> Result<(), PropertyContainerValidateUpdateError> {
87    // First validate all input fields for mutability and correct datatype
88    for property in property_type_container.get_own_properties_cloned().iter() {
89        if let Ok(value) = ctx.args.try_get(&property.name) {
90            // Fail on every property which is immutable
91            if property.mutability == Immutable {
92                return Err(ImmutablePropertyError(property.key().clone()).into());
93            }
94            match &property.data_type {
95                DataType::Null => {
96                    return Err(PropertyDataTypeError::NullIsNotAValidDataType(property.key().clone()).into());
97                }
98                DataType::Bool => {
99                    if value.boolean().is_err() {
100                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Bool).into());
101                    }
102                }
103                DataType::Number => {
104                    if value.f64().is_err() && value.i64().is_err() && value.u64().is_err() {
105                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Number).into());
106                    }
107                }
108                DataType::String => {
109                    if value.string().is_err() {
110                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::String).into());
111                    }
112                }
113                DataType::Array => {
114                    if value.list().is_err() {
115                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Array).into());
116                    }
117                }
118                DataType::Object => {
119                    if value.object().is_err() {
120                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Object).into());
121                    }
122                }
123                DataType::Any => {
124                    // Accept input of any datatype
125                }
126            }
127        }
128    }
129    Ok(())
130}
131
132pub fn property_container_update_properties<T: PropertyTypeContainer, I: PropertyInstanceSetter + ?Sized>(
133    property_type_container: &T,
134    reactive_instance: &I,
135    ctx: &ResolverContext,
136) -> Result<(), Error> {
137    for property in property_type_container.get_own_properties_cloned().iter() {
138        if let Ok(value) = ctx.args.try_get(&property.name) {
139            match &property.data_type {
140                DataType::Null => {
141                    return Err(PropertyDataTypeError::NullIsNotAValidDataType(property.key().clone()).into());
142                }
143                DataType::Bool => {
144                    reactive_instance.set_checked(&property.name, Value::Bool(value.boolean()?));
145                }
146                DataType::Number => {
147                    if let Ok(value) = value.i64() {
148                        reactive_instance.set_checked(&property.name, json!(value));
149                    } else if let Ok(value) = value.u64() {
150                        reactive_instance.set_checked(&property.name, json!(value));
151                    } else if let Ok(value) = value.f64() {
152                        reactive_instance.set_checked(&property.name, json!(value));
153                    } else {
154                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Number).into());
155                    }
156                }
157                DataType::String => {
158                    reactive_instance.set_checked(&property.name, Value::String(value.string()?.to_string()));
159                }
160                DataType::Array => {
161                    let _list = value.list()?;
162                    let value = value.deserialize::<Value>()?;
163                    if !value.is_array() {
164                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Array).into());
165                    }
166                    reactive_instance.set_checked(&property.name, value);
167                }
168                DataType::Object => {
169                    let value = value.deserialize::<Value>()?;
170                    if !value.is_object() {
171                        return Err(PropertyDataTypeError::ValueIsNotOfTheExpectedDataType(property.name.clone(), property.data_type, DataType::Object).into());
172                    }
173                    reactive_instance.set_checked(&property.name, value);
174                }
175                DataType::Any => {
176                    // If it's possible to deserialize, accept the input
177                    let value = value.deserialize::<Value>()?;
178                    reactive_instance.set_checked(&property.name, value);
179                }
180            }
181        }
182    }
183    Ok(())
184}
185
186pub fn property_container_update_field_arguments<T: PropertyTypeContainer + NamespacedTypeGetter>(
187    property_type_container: &T,
188    mut field: Field,
189) -> Option<Field> {
190    let mut has_updatable_property = false;
191    for property in property_type_container.get_own_properties_cloned().iter() {
192        if property.mutability == Mutable {
193            if let Some(type_ref) = to_input_type_ref(property.value(), true) {
194                field = field.argument(InputValue::new(&property.name, type_ref));
195                has_updatable_property = true;
196            }
197        }
198    }
199    if !has_updatable_property {
200        warn!("{} has no updatable properties!", property_type_container.namespaced_type());
201        return None;
202    }
203    Some(field)
204}