reactive_graph_dynamic_graph_impl/field/
namespace.rs

1use crate::object_type_name::namespace_type_ref;
2use crate::type_ref::TYPE_REF_ID;
3use async_graphql::dynamic::Field;
4use async_graphql::dynamic::FieldFuture;
5use async_graphql::dynamic::FieldValue;
6use convert_case::Case;
7use convert_case::Casing;
8use reactive_graph_dynamic_graph_api::RootObjectType;
9use reactive_graph_graph::Namespace;
10
11pub const NAMESPACE_FIELD_NAME: &str = "_namespace";
12
13pub fn namespace_field_name(namespace: &Namespace) -> String {
14    namespace
15        .last_segment()
16        .map(|segment| segment.as_ref().to_case(Case::Snake))
17        .unwrap_or(namespace.fully_qualified_type_name())
18}
19
20/// Namespace object field in the parent object
21pub fn namespace_field(namespace: Namespace, root_object_type: RootObjectType) -> Field {
22    Field::new(namespace_field_name(&namespace), namespace_type_ref(&namespace, root_object_type), move |_| {
23        FieldFuture::new({
24            let namespace_inner = namespace.clone();
25            async move { Ok(Some(FieldValue::value(namespace_inner.to_string()))) }
26        })
27    })
28}
29
30/// Field _namespace in the namespace object
31pub fn namespace_path_field(namespace: Namespace) -> Field {
32    let description = format!("The fully qualified namespace: {namespace}");
33    Field::new(NAMESPACE_FIELD_NAME, TYPE_REF_ID.clone(), move |_| {
34        FieldFuture::new({
35            let namespace_inner = namespace.clone();
36            async move { Ok(Some(FieldValue::value(namespace_inner.to_string()))) }
37        })
38    })
39    .description(description)
40}
41
42pub fn root_object_namespace_path_field() -> Field {
43    Field::new(NAMESPACE_FIELD_NAME, TYPE_REF_ID.clone(), move |_ctx| {
44        FieldFuture::new(async move { Ok(Some(FieldValue::value(""))) })
45    })
46    .description("Root namespace")
47}
48
49// use async_graphql::dynamic::Field;
50// use async_graphql::dynamic::FieldFuture;
51// use async_graphql::dynamic::FieldValue;
52// use async_graphql::dynamic::TypeRef;
53// use convert_case::Case::Camel;
54// use convert_case::Case::Pascal;
55// use convert_case::Casing;
56// use reactive_graph_graph::NamespacedType;
57//
58// pub fn namespace_field_name(namespace: &NamespacedType) -> String {
59//     namespace.namespace().to_string().to_case(Camel)
60// }
61//
62// pub fn namespace_type_name(namespace: &NamespacedType) -> String {
63//     format!("{}Namespace", namespace.namespace().to_string().to_case(Pascal))
64// }
65//
66// pub fn namespace_mutation_type_name(namespace: &NamespacedType) -> String {
67//     format!("{}Mutations", namespace.namespace().to_string().to_case(Pascal))
68// }
69//
70// pub fn namespace_query_type_ref(namespace: &NamespacedType) -> TypeRef {
71//     TypeRef::named_nn(namespace_type_name(namespace))
72// }
73//
74// pub fn namespace_mutation_type_ref(namespace: &NamespacedType) -> TypeRef {
75//     TypeRef::named_nn(namespace_mutation_type_name(namespace))
76// }
77//
78// pub fn namespace_query_field(namespace: &NamespacedType) -> Field {
79//     let namespace_inner = namespace.clone();
80//     Field::new(namespace_field_name(namespace), namespace_query_type_ref(namespace), move |_ctx| {
81//         let namespace = namespace_inner.clone();
82//         FieldFuture::new(async move { Ok(Some(FieldValue::value(namespace.namespace().to_string()))) })
83//     })
84// }
85//
86// pub fn namespace_mutation_field(namespace: &NamespacedType) -> Field {
87//     let namespace_inner = namespace.clone();
88//     Field::new(namespace_field_name(namespace), namespace_mutation_type_ref(namespace), move |_ctx| {
89//         let namespace = namespace_inner.clone();
90//         FieldFuture::new(async move { Ok(Some(FieldValue::value(namespace.namespace().to_string()))) })
91//     })
92// }