reactive_graph_dynamic_graph_impl/field/property/
mod.rs1use 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
31pub 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
47pub 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 })
78 })
79 .description(&property_type.description)
80}
81
82pub fn property_container_validate_input_fields<T: PropertyTypeContainer>(
84 property_type_container: &T,
85 ctx: &ResolverContext,
86) -> Result<(), PropertyContainerValidateUpdateError> {
87 for property in property_type_container.get_own_properties_cloned().iter() {
89 if let Ok(value) = ctx.args.try_get(&property.name) {
90 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 }
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 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}