Generate structs for all used input types

Author: tomhoule

graphql_client_codegen/src/codegen.rs

@@ -27,6 +27,7 @@ pub(crate) fn response_for_query(
         generate_fragment_definitions(&operation, &all_used_types, &response_derives, options);
     let input_object_definitions =
         generate_input_object_definitions(&operation, &all_used_types, options);
+
     let variables_struct = generate_variables_struct(&operation, options);
 
     let definitions = render_response_data_fields(&operation, options).render(&response_derives);

graphql_client_codegen/src/resolution.rs

@@ -826,9 +826,14 @@ impl<'a> VariableRef<'a> {
 
     fn collect_used_types(&self, used_types: &mut UsedTypes) {
         match self.0.focus.1.r#type.id {
-            type_id @ TypeId::Input(_)
-            | type_id @ TypeId::Scalar(_)
-            | type_id @ TypeId::Enum(_) => {
+            TypeId::Input(input_id) => {
+                used_types.types.insert(TypeId::Input(input_id));
+
+                let input = self.0.schema.input(input_id);
+
+                input.used_input_ids_recursive(used_types)
+            }
+            type_id @ TypeId::Scalar(_) | type_id @ TypeId::Enum(_) => {
                 used_types.types.insert(type_id);
             }
             _ => (),
@@ -878,7 +883,7 @@ impl<'a> FragmentRef<'a> {
 
 #[derive(Debug, Default)]
 pub(crate) struct UsedTypes {
-    types: HashSet<TypeId>,
+    pub(crate) types: HashSet<TypeId>,
     fragments: HashSet<ResolvedFragmentId>,
 }
 

graphql_client_codegen/src/schema.rs

@@ -2,6 +2,7 @@ mod graphql_parser_conversion;
 mod json_conversion;
 
 use crate::field_type::GraphqlTypeQualifier;
+use crate::resolution::UsedTypes;
 use std::collections::HashMap;
 
 #[derive(Clone, Copy)]
@@ -13,7 +14,6 @@ struct SchemaWith<'a, T> {
 
 #[derive(Clone, Copy)]
 pub(crate) struct TypeRef<'a>(SchemaWith<'a, TypeId>);
-pub(crate) struct InputRef<'a>(SchemaWith<'a, InputId>);
 
 pub(crate) const DEFAULT_SCALARS: &[&str] = &["ID", "String", "Int", "Float", "Boolean"];
 
@@ -217,6 +217,13 @@ impl TypeId {
         }
     }
 
+    pub(crate) fn as_input_id(&self) -> Option<InputId> {
+        match self {
+            TypeId::Input(id) => Some(*id),
+            _ => None,
+        }
+    }
+
     pub(crate) fn as_scalar_id(&self) -> Option<ScalarId> {
         match self {
             TypeId::Scalar(id) => Some(*id),
@@ -266,7 +273,7 @@ struct StoredEnum {
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct StoredInputFieldType {
     id: TypeId,
-    pub(crate) qualifiers: Vec<GraphqlTypeQualifier>,
+    qualifiers: Vec<GraphqlTypeQualifier>,
 }
 
 impl StoredInputFieldType {
@@ -610,6 +617,8 @@ impl<'a> FieldRef<'a> {
     }
 }
 
+pub(crate) struct InputRef<'a>(SchemaWith<'a, InputId>);
+
 impl<'a> InputRef<'a> {
     fn get(&self) -> &'a StoredInputType {
         self.0.schema.get_stored_input(self.0.focus)
@@ -623,6 +632,30 @@ impl<'a> InputRef<'a> {
         &self.get().name
     }
 
+    pub(crate) fn used_input_ids_recursive<'b>(&'b self, used_types: &mut UsedTypes) {
+        for input_id in self
+            .fields()
+            .map(|(_, type_id)| type_id)
+            .filter_map(|type_id| type_id.as_input_id())
+        {
+            let type_id = TypeId::Input(input_id);
+            if used_types.types.contains(&type_id) {
+                continue;
+            } else {
+                used_types.types.insert(type_id);
+                let input_ref = self.0.schema.input(input_id);
+                input_ref.used_input_ids_recursive(used_types);
+            }
+        }
+    }
+
+    pub(crate) fn fields<'b>(&'b self) -> impl Iterator<Item = (&'a str, TypeId)> + 'b {
+        self.get()
+            .fields
+            .iter()
+            .map(|(name, f)| (name.as_str(), f.id))
+    }
+
     pub(crate) fn contains_type_without_indirection(&self, type_name: &str) -> bool {
         todo!("contains type without indirection")
         // let input = self.get();

graphql_client_codegen/src/schema/graphql_parser_conversion.rs

@@ -1,4 +1,4 @@
-use super::{InputId, Schema, TypeId};
+use super::{InputId, Schema, StoredInputFieldType, TypeId};
 use crate::schema::resolve_field_type;
 use graphql_parser::schema::{self as parser, Definition, Document, TypeDefinition, UnionType};
 
@@ -244,12 +244,22 @@ fn find_deprecation(directives: &[parser::Directive]) -> Option<Option<String>>
 }
 
 fn ingest_input(schema: &mut Schema, input: &mut parser::InputObjectType) {
-    let input_id = InputId::new(schema.stored_inputs.len());
-
-    // TODO: input object fields
     let input = super::StoredInputType {
         name: std::mem::replace(&mut input.name, String::new()),
-        fields: Vec::new(),
+        fields: input
+            .fields
+            .iter_mut()
+            .map(|val| {
+                let field_type = super::resolve_field_type(schema, &val.value_type);
+                (
+                    std::mem::replace(&mut val.name, String::new()),
+                    StoredInputFieldType {
+                        qualifiers: field_type.qualifiers,
+                        id: field_type.id,
+                    },
+                )
+            })
+            .collect(),
     };
 
     schema.stored_inputs.push(input);