use pascal for module names

Author: roryc89

src/build_schema.rs

@@ -10,7 +10,7 @@ use cynic_introspection::{
     Directive, DirectiveLocation, FieldWrapping, InputValue, InterfaceType, IntrospectionQuery,
     Type, UnionType, WrappingType,
 };
-use stringcase::{kebab_case, pascal_case};
+use stringcase::{kebab_case};
 use tokio::task::spawn_blocking;
 
 use crate::{
@@ -26,6 +26,7 @@ use crate::{
         purescript_record::{show_field_name, Field, PurescriptRecord},
         purescript_type::PurescriptType,
         purescript_variant::Variant,
+        upper_first::*,
     },
     write::write,
 };
@@ -98,7 +99,7 @@ pub async fn build_schema(
     let query_type = PurescriptType::new(
         "Query",
         vec![],
-        Argument::new_type(&pascal_case(schema.query_type.as_str())),
+        Argument::new_type(&upper_first(schema.query_type.as_str())),
     );
     schema_record.add_field(Field::new("query").with_type(&query_type.name));
     types.push(query_type);
@@ -113,7 +114,7 @@ pub async fn build_schema(
         let mutation_type = PurescriptType::new(
             "Mutation",
             vec![],
-            Argument::new_type(&pascal_case(&mut_type)),
+            Argument::new_type(&upper_first(&mut_type)),
         );
         schema_record.add_field(Field::new("mutation").with_type(&mutation_type.name));
         types.push(mutation_type);
@@ -124,7 +125,7 @@ pub async fn build_schema(
         let mutation_type = PurescriptType::new(
             "Subscription",
             vec![],
-            Argument::new_type(&pascal_case(&mut_type)),
+            Argument::new_type(&upper_first(&mut_type)),
         );
         schema_record.add_field(Field::new("subscription").with_type(&mutation_type.name));
         types.push(mutation_type);
@@ -139,7 +140,7 @@ pub async fn build_schema(
             }
 
             // Convert the gql_type_name to a PurescriptTypeName
-            let name = pascal_case(&obj.name);
+            let name = upper_first(&obj.name);
 
             // Creates a new record for the object
             let mut record = PurescriptRecord::new("Ignored");
@@ -214,6 +215,7 @@ pub async fn build_schema(
                         add_import("argonaut-core", "Data.Argonaut.Core", "Json", &mut imports)
                     }
                     "time" => add_import("datetime", "Data.Time", "Time", &mut imports),
+                    "ID" => add_import("graphql-client", "GraphQL.Client.ID", "ID", &mut imports),
                     _ => {}
                 }
             }
@@ -239,7 +241,7 @@ pub async fn build_schema(
                 }
 
                 // Convert the gql_type_name to a PurescriptTypeName
-                let name = pascal_case(&obj.name);
+                let name = upper_first(&obj.name);
 
                 // Build a purescript record with all fields
                 let mut record = PurescriptRecord::new("Query");
@@ -302,7 +304,7 @@ pub async fn build_schema(
                 union.with_values(
                     &possible_types
                         .iter()
-                        .map(|t| (t.clone(), pascal_case(&t)))
+                        .map(|t| (t.clone(), upper_first(&t)))
                         .collect(),
                 );
 

src/config/parse_outside_types.rs

@@ -4,10 +4,9 @@ use std::{
     io::Read,
 };
 
-use stringcase::pascal_case;
 use yaml_rust2::{yaml, Yaml};
 
-use crate::write::write;
+use crate::{purescript_gen::upper_first::upper_first, write::write};
 
 use super::workspace::WorkspaceConfig;
 
@@ -218,8 +217,8 @@ fn write_types(outside_types: &OutsideTypes, workspace_config: &WorkspaceConfig)
     let mock_outside_types = std::env::var("MOCK_OUTSIDE_TYPES");
     if mock_outside_types.is_ok() {
         let lib_path = workspace_config.shared_graphql_enums_dir.clone();
-        let postgres_enums_lib = pascal_case(&(&workspace_config.postgres_enums_lib).clone().unwrap());
-        let gql_enums_lib = pascal_case(&workspace_config.shared_graphql_enums_lib);
+        let postgres_enums_lib = upper_first(&(&workspace_config.postgres_enums_lib).clone().unwrap());
+        let gql_enums_lib = upper_first(&workspace_config.shared_graphql_enums_lib);
         for module in to_write.iter() {
             let is_enum_mod = module.import.contains(&postgres_enums_lib)
                 || module.import.contains(&gql_enums_lib);

src/enums/generate_enum.rs

@@ -5,6 +5,7 @@ use crate::config::workspace::WorkspaceConfig;
 use crate::purescript_gen::purescript_enum::Enum;
 use crate::purescript_gen::purescript_import::PurescriptImport;
 use crate::purescript_gen::purescript_variant::Variant;
+use crate::purescript_gen::upper_first::upper_first;
 use crate::write::write;
 
 pub async fn generate_enum(

src/hasura_types.rs

@@ -2,11 +2,10 @@ use std::{
     collections::HashMap,
     sync::{Arc, Mutex},
 };
-use stringcase::pascal_case;
 
 use crate::{
     config::parse_outside_types::{Mod, OutsideTypes},
-    purescript_gen::{purescript_argument::Argument, purescript_import::PurescriptImport},
+    purescript_gen::{purescript_argument::Argument, purescript_import::PurescriptImport, upper_first::upper_first},
 };
 
 pub fn as_gql_field(
@@ -26,7 +25,7 @@ pub fn as_gql_field(
     }
     Argument::new_type("AsGql")
         .with_argument(Argument::new_type(&format!("\"{}\"", name)))
-        .with_argument(Argument::new_type(&pascal_case(&type_)))
+        .with_argument(Argument::new_type(&upper_first(&type_)))
 }
 
 fn outside_type(

src/purescript_gen.rs

@@ -8,3 +8,4 @@ pub mod purescript_type;
 pub mod purescript_variant;
 pub mod purescript_row;
 pub mod purescript_gql_union;
+pub mod upper_first;

src/purescript_gen/upper_first.rs

@@ -0,0 +1,8 @@
+
+pub fn upper_first(str: &str) -> String { 
+    let mut c = str.chars();
+    match c.next() {
+        None => String::new(),
+        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+    }
+}