handle preserved scalar and field replacement (#15)

Author: tacogips

Cargo.lock

@@ -4,6 +4,10 @@ version = "0.4.0"
 authors = ["tacogips <[email protected]>"]
 edition = "2018"
 
+
+# TODO(tacogips) is excluding apparantly not working when cargo test?
+exclude = ["examples"]
+
 [[bin]]
 name = "async-graphql-reverse"
 path = "src/bin/main.rs"
@@ -14,6 +18,8 @@ async-graphql = "4.0"
 async-graphql-parser = "4.0"
 clap = { version = "3.1.0", features = ["derive"] }
 env_logger = "0.8"
+# TODO(tacogips) lazy_static would be deprecated after rust 1.70
+# https://github.com/rust-lang-nursery/lazy-static.rs/issues/214
 lazy_static = "1.4"
 log = "0.4"
 structopt = "0.3"
@@ -26,3 +32,9 @@ heck = "0.3"
 paste = "1.0"
 toml = "0.5"
 serde = { version = "1.0", features = ["derive"] }
+
+
+[dev-dependencies]
+axum = { version = "0.5.1", features = ["headers"] }
+tokio = { version = "1.8", features = ["macros", "rt-multi-thread"] }
+async-graphql-axum = "4.0.10"

Cargo.toml

@@ -77,3 +77,9 @@ field_def = "this_is_another_hidden_field: i64"
 [ignore]
 object = ["WillBeIgnoredType"]
 enum = ["IgnoreStatus"]
+
+
+[[field]]
+target_type = "CreateFriendMutationInput"
+target_field = "large_data"
+replace_field_type = "Upload!"

examples/simple/input/reverse.toml

@@ -51,13 +51,15 @@ type CreateFriendMutationPayload
   friend: Friend!
 }
 
+scalar Upload
 """
 comment for object
 in multi line
 """
 input CreateFriendMutationInput {
   userId: ID!
   ignore_input: WillBeIgnoredType
+  large_data: String
 }
 
 input RecursiveInput {
@@ -100,6 +102,7 @@ type Friend implements User {
   userType: UserType
   others: [Friend]
   isActive: Boolean!
+  favo_rate: Int!
 }
 
 type FriendConnection {

examples/simple/input/schema.graphql

@@ -3,11 +3,12 @@
 use async_graphql::*;
 ///comment for object
 ///in multi line
-#[derive(Debug, InputObject, Clone)]
+#[derive(InputObject)]
 pub struct CreateFriendMutationInput {
     pub user_id: ID,
+    pub large_data: Upload,
 }
-#[derive(Debug, InputObject, Clone)]
+#[derive(InputObject)]
 pub struct RecursiveInput {
     pub id: Option<String>,
     pub input1: Option<Box<RecursiveInput>>,

examples/simple/output/input_objects.rs

@@ -96,6 +96,7 @@ impl Me {
 pub struct Friend {
     pub id: ID,
     pub is_active: bool,
+    pub favo_rate: i64,
     this_is_a_hidden_field: String,
     this_is_another_hidden_field: i64,
 }
@@ -127,6 +128,9 @@ impl Friend {
     pub async fn is_active(&self) -> bool {
         self.is_active
     }
+    pub async fn favo_rate(&self) -> i64 {
+        self.favo_rate
+    }
 }
 #[derive(Debug, Clone)]
 pub struct FriendConnection {

examples/simple/output/objects.rs

@@ -50,6 +50,13 @@ pub struct ResolverSetting {
     pub argument: Option<Vec<ResolverArgument>>,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct FieldSetting {
+    pub target_type: String,
+    pub target_field: String,
+    pub replace_field_type: Option<String>,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct Additional {
     pub body: String,
@@ -93,7 +100,13 @@ pub struct DefaultSetting {
     pub enum_rename_items: Option<String>,
 }
 
-pub type FieldsResolverSetting<'a> = HashMap<String, &'a ResolverSetting>;
+pub type DefinedEnumName = String;
+pub type DefinedTypeName = String;
+pub type DefinedFieldName = String;
+
+pub type FieldsResolverSetting<'a> = HashMap<DefinedFieldName, &'a ResolverSetting>;
+pub type FieldsSetting<'a> = HashMap<DefinedFieldName, &'a FieldSetting>;
+
 #[derive(Deserialize, Default, Debug)]
 pub struct RendererConfig {
     pub using: Option<HashMap<String, String>>,
@@ -106,6 +119,7 @@ pub struct RendererConfig {
     pub additional: Option<Vec<Additional>>,
     pub ignore: Option<Ignore>,
     pub r#enum: Option<Vec<EnumSetting>>,
+    pub field: Option<Vec<FieldSetting>>,
 }
 
 impl RendererConfig {
@@ -127,25 +141,25 @@ impl RendererConfig {
     }
 
     /// if a type contained this set, the field that has the type supposed to be a member instead of resolver method.
-    pub fn custom_member_types(&self) -> HashSet<String> {
+    pub fn custom_member_types(&self) -> HashSet<DefinedTypeName> {
         match self.custom_member_types.as_ref() {
-            None => HashSet::<String>::new(),
+            None => HashSet::<DefinedTypeName>::new(),
             Some(member_types) => member_types.iter().map(|v| v.to_string()).collect(),
         }
     }
 
-    pub fn resolver_setting(&self) -> HashMap<String, FieldsResolverSetting> {
+    pub fn resolver_setting(&self) -> HashMap<DefinedTypeName, FieldsResolverSetting> {
         match self.resolver.as_ref() {
             None => return HashMap::new(),
             Some(resolver) => {
                 if resolver.is_empty() {
                     return HashMap::new();
                 } else {
-                    let mut result = HashMap::<String, HashMap<String, &ResolverSetting>>::new();
+                    let mut result = HashMap::<DefinedTypeName, FieldsResolverSetting>::new();
                     for each_resolver in resolver.iter() {
                         let field_and_resolver_type = result
                             .entry(each_resolver.target_type.to_string())
-                            .or_insert(HashMap::<String, &ResolverSetting>::new());
+                            .or_insert(FieldsResolverSetting::new());
                         field_and_resolver_type
                             .insert(each_resolver.target_field.to_string(), each_resolver);
                     }
@@ -155,7 +169,29 @@ impl RendererConfig {
         }
     }
 
-    pub fn enum_settings(&self) -> HashMap<String, EnumSetting> {
+    pub fn field_setting(&self) -> HashMap<DefinedTypeName, FieldsSetting> {
+        match self.field.as_ref() {
+            None => return HashMap::new(),
+            Some(resolver) => {
+                if resolver.is_empty() {
+                    return HashMap::new();
+                } else {
+                    let mut result = HashMap::<DefinedTypeName, FieldsSetting>::new();
+                    for each_field in resolver.iter() {
+                        let field_and_resolver_type = result
+                            .entry(each_field.target_type.to_string())
+                            .or_insert(FieldsSetting::new());
+
+                        field_and_resolver_type
+                            .insert(each_field.target_field.to_string(), each_field);
+                    }
+                    result
+                }
+            }
+        }
+    }
+
+    pub fn enum_settings(&self) -> HashMap<DefinedEnumName, EnumSetting> {
         match self.r#enum.as_ref() {
             None => HashMap::new(),
             Some(enum_settings) => {
@@ -165,20 +201,20 @@ impl RendererConfig {
                     enum_settings
                         .into_iter()
                         .map(|each_enum| (each_enum.target_enum.to_string(), each_enum.clone()))
-                        .collect::<HashMap<String, EnumSetting>>()
+                        .collect::<HashMap<DefinedEnumName, EnumSetting>>()
                 }
             }
         }
     }
 
-    pub fn hidden_fields(&self) -> HashMap<String, HiddenFields> {
+    pub fn hidden_fields(&self) -> HashMap<DefinedTypeName, HiddenFields> {
         match self.hidden_field.as_ref() {
             None => return HashMap::new(),
             Some(hidden_field) => {
                 if hidden_field.is_empty() {
                     return HashMap::new();
                 } else {
-                    let mut result = HashMap::<String, HiddenFields>::new();
+                    let mut result = HashMap::<DefinedTypeName, HiddenFields>::new();
                     for each_hidden_field in hidden_field.iter() {
                         let hidden_field = result
                             .entry(each_hidden_field.target_type.to_string())
@@ -199,14 +235,14 @@ impl RendererConfig {
         }
     }
 
-    pub fn additional_resolvers(&self) -> HashMap<String, CustomResolvers> {
+    pub fn additional_resolvers(&self) -> HashMap<DefinedTypeName, CustomResolvers> {
         match self.additional_resolver.as_ref() {
             None => return HashMap::new(),
             Some(additional_resolver) => {
                 if additional_resolver.is_empty() {
                     return HashMap::new();
                 } else {
-                    let mut result = HashMap::<String, CustomResolvers>::new();
+                    let mut result = HashMap::<DefinedTypeName, CustomResolvers>::new();
                     for custom_resolver in additional_resolver.iter() {
                         let custom_resolvers = result
                             .entry(custom_resolver.target_type.to_string())

src/config.rs

@@ -59,7 +59,7 @@ macro_rules! accumulate_remove_target {
         {
             Err(e) => {
                 println!(
-                    "WARN: ignore element not found. {:?}, error {}",
+                    "WARN: ignore unknown element. {:?}, error {}",
                     $each_field.typ, e
                 );
             }