adds support for custom scalars

Author: roryc89

Cargo.lock

@@ -18,6 +18,9 @@ stringcase = "0.3.0"
 tokio = { version = "1.40.0", features = ["full"] }
 yaml-rust2 = "0.8.1"
 serde_json = "1.0"
+serde = "1.0"
+serde_derive = "1.0"
+serde_yaml = "0.9.34"
 
 [[bin]]
 edition = "2021"

Cargo.toml

@@ -1,6 +1,5 @@
 use std::{
     collections::HashMap,
-    fmt::format,
     sync::{Arc, Mutex},
     thread::Result,
 };
@@ -10,11 +9,14 @@ use cynic_introspection::{
     Directive, DirectiveLocation, FieldWrapping, InputValue, InterfaceType, IntrospectionQuery,
     Type, UnionType, WrappingType,
 };
-use stringcase::{kebab_case};
+use stringcase::{kebab_case, pascal_case};
 use tokio::task::spawn_blocking;
 
 use crate::{
-    config::{parse_outside_types::OutsideTypes, workspace::WorkspaceConfig},
+    config::{
+        parse_outside_types::{Mod, OutsideTypes}, parse_scalar_types::ScalarTypes,
+        workspace::WorkspaceConfig,
+    },
     enums::generate_enum::generate_enum,
     hasura_types::as_gql_field,
     purescript_gen::{
@@ -26,7 +28,6 @@ use crate::{
         purescript_record::{show_field_name, Field, PurescriptRecord},
         purescript_type::PurescriptType,
         purescript_variant::Variant,
-        upper_first::*,
     },
     write::write,
 };
@@ -35,6 +36,7 @@ pub async fn build_schema(
     role: String,
     postgres_types: Arc<Mutex<HashMap<String, (String, String, String)>>>,
     outside_types: Arc<Mutex<OutsideTypes>>,
+    scalar_types: Arc<Mutex<ScalarTypes>>,
     workspace_config: WorkspaceConfig,
 ) -> Result<()> {
     // Fetch the introspection schema
@@ -99,7 +101,7 @@ pub async fn build_schema(
     let query_type = PurescriptType::new(
         "Query",
         vec![],
-        Argument::new_type(&upper_first(schema.query_type.as_str())),
+        Argument::new_type(&pascal_case(schema.query_type.as_str())),
     );
     schema_record.add_field(Field::new("query").with_type(&query_type.name));
     types.push(query_type);
@@ -114,7 +116,7 @@ pub async fn build_schema(
         let mutation_type = PurescriptType::new(
             "Mutation",
             vec![],
-            Argument::new_type(&upper_first(&mut_type)),
+            Argument::new_type(&pascal_case(&mut_type)),
         );
         schema_record.add_field(Field::new("mutation").with_type(&mutation_type.name));
         types.push(mutation_type);
@@ -125,7 +127,7 @@ pub async fn build_schema(
         let mutation_type = PurescriptType::new(
             "Subscription",
             vec![],
-            Argument::new_type(&upper_first(&mut_type)),
+            Argument::new_type(&pascal_case(&mut_type)),
         );
         schema_record.add_field(Field::new("subscription").with_type(&mutation_type.name));
         types.push(mutation_type);
@@ -140,7 +142,7 @@ pub async fn build_schema(
             }
 
             // Convert the gql_type_name to a PurescriptTypeName
-            let name = upper_first(&obj.name);
+            let name = pascal_case(&obj.name);
 
             // Creates a new record for the object
             let mut record = PurescriptRecord::new("Ignored");
@@ -201,11 +203,12 @@ pub async fn build_schema(
             types.push(query_type);
         };
         match type_ {
-            Type::Object(obj) => handle_obj(obj),
+            Type::Object(obj) => handle_obj(&obj),
             Type::Scalar(scalar) => {
                 // Add imports for common scalar types if they are used.
                 // TODO maybe move these to config so they can be updated outside of rust
                 match scalar.name.as_str() {
+                    "ID" => add_import("graphql-client", "GraphQL.Client.ID", "ID", &mut imports),
                     _ if scalar.is_builtin() => {} // ignore built in types like String, Int, etc.
                     "date" => add_import("datetime", "Data.Date", "Date", &mut imports),
                     "timestamp" | "timestamptz" => {
@@ -215,8 +218,19 @@ 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),
-                    _ => {}
+                    scalar_name => {
+                      match scalar_types.lock().unwrap().get(scalar_name) {
+                        Some(Mod { package, import, name }) => {
+                          add_import(package, import, name, &mut imports);
+                          types.push(PurescriptType::new(scalar_name, vec![], Argument::new_type(name)));
+                        }
+                        None => {
+                          add_import("argonaut-core", "Data.Argonaut.Core", "Json", &mut imports);
+                          types.push(PurescriptType::new(scalar_name, vec![], Argument::new_type("Json")));
+
+                        }
+                      }
+                    }
                 }
             }
             Type::Enum(en) => {
@@ -241,7 +255,7 @@ pub async fn build_schema(
                 }
 
                 // Convert the gql_type_name to a PurescriptTypeName
-                let name = upper_first(&obj.name);
+                let name = pascal_case(&obj.name);
 
                 // Build a purescript record with all fields
                 let mut record = PurescriptRecord::new("Query");
@@ -304,7 +318,7 @@ pub async fn build_schema(
                 union.with_values(
                     &possible_types
                         .iter()
-                        .map(|t| (t.clone(), upper_first(&t)))
+                        .map(|t| (t.clone(), pascal_case(&t)))
                         .collect(),
                 );
 
@@ -467,13 +481,7 @@ fn directive_type_str(directive: &Directive) -> Option<String> {
         .map(input_value_type_str)
         .collect::<Vec<String>>()
         .join("\n    , ");
-    let locations = directive_locations_str(&directive.locations);
-
-    if locations.is_none() {
-       return None
-    }
-
-    let locations = locations.unwrap();
+    let locations = directive_locations_str(&directive.locations)?;
 
     Some(format!("( Directive \"{name}\" \n    \"{description}\" \n    {{ {args} }}  \n    {locations} \n  )"))
 }
@@ -542,7 +550,6 @@ fn build_directives(lib_path: String, role: String, directives: Vec<Directive>)
         "module {role}.Directives where \n{DIRECTIVE_IMPORTS}\ntype Directives :: List' Type\n{directive_str}\n\n{directive_fns}"
     ));
 
-   
     write(
         &format!("{lib_path}/src/{role}/Directives.purs"),
         &directive_mod,

src/build_schema.rs

@@ -1,3 +1,4 @@
 pub mod parse_outside_types;
 pub mod parse_roles;
 pub mod workspace;
+pub mod parse_scalar_types;

src/config.rs

@@ -4,9 +4,11 @@ use std::{
     io::Read,
 };
 
+use serde::Deserialize;
+use stringcase::pascal_case;
 use yaml_rust2::{yaml, Yaml};
 
-use crate::{purescript_gen::upper_first::upper_first, write::write};
+use crate::write::write;
 
 use super::workspace::WorkspaceConfig;
 
@@ -200,7 +202,7 @@ fn to_type_value(type_value: &String, types_fn: &impl Fn(&str, &str) -> Option<M
     }
 }
 
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq, Deserialize)]
 pub struct Mod {
     pub import: String,
     pub name: String,
@@ -217,8 +219,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 = upper_first(&(&workspace_config.postgres_enums_lib).clone().unwrap());
-        let gql_enums_lib = upper_first(&workspace_config.shared_graphql_enums_lib);
+        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);
         for module in to_write.iter() {
             let is_enum_mod = module.import.contains(&postgres_enums_lib)
                 || module.import.contains(&gql_enums_lib);

src/config/parse_outside_types.rs

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

src/hasura_types.rs

@@ -1,15 +1,12 @@
 use std::{
-    fs::remove_dir_all,
-    sync::{Arc, Mutex},
-    thread::Result,
+    collections::HashMap, fs::remove_dir_all, sync::{Arc, Mutex}, thread::Result
 };
 
 use build_schema::build_schema;
 use config::{
-    parse_outside_types::{fetch_all_outside_types, OutsideTypes},
-    parse_roles::parse_roles,
-    workspace::parse_workspace,
+    parse_outside_types::{fetch_all_outside_types, OutsideTypes}, parse_roles::parse_roles, parse_scalar_types::{fetch_all_scalar_types, ScalarTypes}, workspace::parse_workspace
 };
+use cynic_introspection::ScalarType;
 use dotenv::dotenv;
 use enums::postgres_types::fetch_types;
 use tokio::spawn;
@@ -63,13 +60,16 @@ async fn main() -> Result<()> {
     // Parse all outside type config
     let outside_types: OutsideTypes = fetch_all_outside_types(&workspace_config);
 
+    let scalar_types: ScalarTypes = fetch_all_scalar_types().unwrap_or(HashMap::new());
+
     // Fetch role config
     let roles: Vec<String> = parse_roles();
     let num_roles = roles.len();
 
     // Postgres types are shared between all roles
     let types_ = Arc::new(Mutex::new(postgres_types));
     let outside_types = Arc::new(Mutex::new(outside_types));
+    let scalar_types = Arc::new(Mutex::new(scalar_types));
 
     // Run schema gen for each role concurrently
     let mut tasks = Vec::with_capacity(num_roles);
@@ -79,6 +79,7 @@ async fn main() -> Result<()> {
             role.clone(),
             types_.clone(),
             outside_types.clone(),
+            scalar_types.clone(),
             workspace_config.clone(),
         )));
     }