chore: fix recursion in checking resolvers (#2145)

Co-authored-by: Tushar Mathur <[email protected]>

src/core/blueprint/definitions.rs

@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use async_graphql_value::ConstValue;
 use regex::Regex;
 
@@ -322,8 +324,10 @@ pub fn fix_dangling_resolvers<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &str), FieldDefinition, String>::new(
         move |(config, field, ty, name), mut b_field| {
+            let mut set = HashSet::new();
             if !field.has_resolver()
-                && validate_field_has_resolver(name, field, &config.types, ty).is_succeed()
+                && validate_field_has_resolver(name, field, &config.types, ty, &mut set)
+                    .is_succeed()
             {
                 b_field = b_field.resolver(Some(IR::Dynamic(DynamicValue::Value(
                     ConstValue::Object(Default::default()),
@@ -375,7 +379,6 @@ fn to_fields(
     } else {
         GraphQLOperationType::Query
     };
-
     // Process fields that are not marked as `omit`
     let fields = Valid::from_iter(
         type_of

src/core/blueprint/schema.rs

@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 use async_graphql::parser::types::ConstDirective;
 
@@ -16,8 +16,8 @@ fn validate_query(config: &Config) -> Valid<(), String> {
         let Some(query) = config.find_type(query_type_name) else {
             return Valid::fail("Query type is not defined".to_owned()).trace(query_type_name);
         };
-
-        validate_type_has_resolvers(query_type_name, query, &config.types)
+        let mut set = HashSet::new();
+        validate_type_has_resolvers(query_type_name, query, &config.types, &mut set)
     })
     .unit()
 }
@@ -28,19 +28,28 @@ fn validate_type_has_resolvers(
     name: &str,
     ty: &Type,
     types: &BTreeMap<String, Type>,
+    visited: &mut HashSet<String>,
 ) -> Valid<(), String> {
+    if visited.contains(name) {
+        return Valid::succeed(());
+    }
+
+    visited.insert(name.to_string());
+
     Valid::from_iter(ty.fields.iter(), |(name, field)| {
-        validate_field_has_resolver(name, field, types, ty)
+        validate_field_has_resolver(name, field, types, ty, visited)
     })
     .trace(name)
     .unit()
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn validate_field_has_resolver(
     name: &str,
     field: &Field,
     types: &BTreeMap<String, Type>,
     parent_ty: &Type,
+    visited: &mut HashSet<String>,
 ) -> Valid<(), String> {
     Valid::<(), String>::fail("No resolver has been found in the schema".to_owned())
         .when(|| {
@@ -53,7 +62,7 @@ pub fn validate_field_has_resolver(
                     if ty.scalar() {
                         return true;
                     }
-                    let res = validate_type_has_resolvers(type_name, ty, types);
+                    let res = validate_type_has_resolvers(type_name, ty, types, visited);
                     return !res.is_succeed();
                 } else {
                     // It's a Scalar
@@ -94,8 +103,8 @@ fn validate_mutation(config: &Config) -> Valid<(), String> {
             return Valid::fail("Mutation type is not defined".to_owned())
                 .trace(mutation_type_name);
         };
-
-        validate_type_has_resolvers(mutation_type_name, mutation, &config.types)
+        let mut set = HashSet::new();
+        validate_type_has_resolvers(mutation_type_name, mutation, &config.types, &mut set)
     } else {
         Valid::succeed(())
     }

src/core/valid/valid.rs

@@ -123,7 +123,7 @@ impl<A, E> Valid<A, E> {
 
     pub fn from_iter<B>(
         iter: impl IntoIterator<Item = A>,
-        f: impl Fn(A) -> Valid<B, E>,
+        mut f: impl FnMut(A) -> Valid<B, E>,
     ) -> Valid<Vec<B>, E> {
         let mut values: Vec<B> = Vec::new();
         let mut errors: ValidationError<E> = ValidationError::empty();

tests/core/snapshots/test-recursive-types.md_error.snap

@@ -0,0 +1,14 @@
+---
+source: tests/core/spec.rs
+expression: errors
+---
+[
+  {
+    "message": "No resolver has been found in the schema",
+    "trace": [
+      "Query",
+      "foo"
+    ],
+    "description": null
+  }
+]

tests/execution/test-recursive-types.md

@@ -0,0 +1,24 @@
+---
+error: true
+---
+
+# test-recursive-types
+
+```graphql @config
+schema {
+  query: Query
+}
+
+type Query {
+  foo: Foo
+}
+
+type Foo {
+  bars: [Bar]
+}
+
+type Bar {
+  foo: Foo
+  relatedBars: [Bar]
+}
+```