Merge pull request #2145 from Netflix/fallback-type-resolver

Support fallback/global type resolver

Author: jjacobs44

graphql-dgs-spring-graphql/src/main/kotlin/com/netflix/graphql/dgs/springgraphql/autoconfig/DgsSpringGraphQLAutoConfiguration.kt

@@ -73,6 +73,7 @@ import graphql.introspection.Introspection
 import graphql.schema.DataFetcherFactory
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLCodeRegistry
+import graphql.schema.TypeResolver
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.TypeDefinitionRegistry
 import io.micrometer.context.ContextRegistry
@@ -291,6 +292,7 @@ open class DgsSpringGraphQLAutoConfiguration(
         entityFetcherRegistry: EntityFetcherRegistry,
         defaultDataFetcherFactory: Optional<DataFetcherFactory<*>> = Optional.empty(),
         methodDataFetcherFactory: MethodDataFetcherFactory,
+        fallbackTypeResolver: TypeResolver? = null,
     ): DgsSchemaProvider =
         DgsSchemaProvider(
             applicationContext = applicationContext,
@@ -304,6 +306,7 @@ open class DgsSpringGraphQLAutoConfiguration(
             methodDataFetcherFactory = methodDataFetcherFactory,
             schemaWiringValidationEnabled = configProps.schemaWiringValidationEnabled,
             enableEntityFetcherCustomScalarParsing = configProps.enableEntityFetcherCustomScalarParsing,
+            fallbackTypeResolver = fallbackTypeResolver,
         )
 
     @Bean

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal/DgsSchemaProvider.kt

@@ -46,6 +46,7 @@ import graphql.schema.FieldCoordinates
 import graphql.schema.GraphQLCodeRegistry
 import graphql.schema.GraphQLScalarType
 import graphql.schema.GraphQLSchema
+import graphql.schema.TypeResolver
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaDirectiveWiring
 import graphql.schema.idl.SchemaGenerator
@@ -97,6 +98,7 @@ class DgsSchemaProvider
         private val componentFilter: ((Any) -> Boolean)? = null,
         private val schemaWiringValidationEnabled: Boolean = true,
         private val enableEntityFetcherCustomScalarParsing: Boolean = false,
+        private val fallbackTypeResolver: TypeResolver? = null,
     ) {
         @Suppress("UNUSED_PARAMETER")
         @Deprecated("The mockProviders argument is no longer supported")
@@ -824,7 +826,7 @@ class DgsSchemaProvider
                         .typeResolver { env: TypeResolutionEnvironment ->
                             val instance = env.getObject<Any>()
                             val resolvedType = env.schema.getObjectType(instance::class.java.simpleName)
-                            resolvedType
+                            resolvedType ?: fallbackTypeResolver?.getType(env)
                                 ?: throw InvalidTypeResolverException(
                                     "The default type resolver could not find a suitable Java type for GraphQL $typeName type `$it`. Provide a @DgsTypeResolver for `${instance::class.java.simpleName}`.",
                                 )

graphql-dgs/src/test/kotlin/com/netflix/graphql/dgs/DgsSchemaProviderTest.kt

@@ -36,6 +36,7 @@ import graphql.language.TypeName
 import graphql.schema.DataFetcher
 import graphql.schema.FieldCoordinates
 import graphql.schema.GraphQLCodeRegistry
+import graphql.schema.TypeResolver
 import graphql.schema.idl.TypeDefinitionRegistry
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatNoException
@@ -81,6 +82,7 @@ internal class DgsSchemaProviderTest {
         componentFilter: ((Any) -> Boolean)? = null,
         schemaWiringValidationEnabled: Boolean = true,
         dataFetcherResultProcessors: List<DataFetcherResultProcessor> = emptyList(),
+        fallbackTypeResolver: TypeResolver? = null,
     ): DgsSchemaProvider =
         DgsSchemaProvider(
             applicationContext = applicationContext,
@@ -97,6 +99,7 @@ internal class DgsSchemaProviderTest {
             componentFilter = componentFilter,
             schemaWiringValidationEnabled = schemaWiringValidationEnabled,
             dataFetcherResultProcessors = dataFetcherResultProcessors,
+            fallbackTypeResolver = fallbackTypeResolver,
         )
 
     @DgsComponent
@@ -427,7 +430,89 @@ internal class DgsSchemaProviderTest {
         contextRunner.withBean(FetcherWithDefaultResolver::class.java).withBean(VideoFetcher::class.java).run { context ->
             assertThatNoException().isThrownBy {
                 // verify that it should not trigger a build failure
-                GraphQL.newGraphQL(schemaProvider(applicationContext = context).schema(schema).graphQLSchema).build()
+                GraphQL
+                    .newGraphQL(
+                        schemaProvider(applicationContext = context).schema(schema).graphQLSchema,
+                    ).build()
+                    .execute("{video{title}}")
+            }
+        }
+    }
+
+    @Test
+    fun `Use fallback type resolver when no @DgsTypeResolver is present`() {
+        val schema =
+            """
+            type Query {
+                video: Video
+            }
+
+            interface Video {
+                title: String
+            }
+            type Show implements Video {
+                title: String
+            }
+            """.trimIndent()
+
+        class MyTypeResolverConfig {
+            fun myTypeResolver(): TypeResolver = TypeResolver { env -> env.schema.getObjectType("Show") }
+        }
+
+        contextRunner.withBean(VideoFetcher::class.java).run { context ->
+            assertThatNoException().isThrownBy {
+                // verify that it should not trigger a build failure
+                GraphQL
+                    .newGraphQL(
+                        schemaProvider(
+                            applicationContext = context,
+                            fallbackTypeResolver = MyTypeResolverConfig().myTypeResolver(),
+                        ).schema(schema).graphQLSchema,
+                    ).build()
+                    .execute("{video{title}}")
+            }
+        }
+    }
+
+    @Test
+    fun `@DgsTypeResolver should be preferred over fallback type resolver`() {
+        val schema =
+            """
+            type Query {
+                video: Video
+            }
+
+            interface Video {
+                title: String
+            }
+            type Show implements Video {
+                title: String
+            }
+            """.trimIndent()
+
+        class MyTypeResolverConfig {
+            fun myTypeResolver(): TypeResolver = TypeResolver { env -> env.schema.getObjectType("FakeType") }
+        }
+
+        @DgsComponent
+        class FetcherWithResolver {
+            @DgsTypeResolver(name = "Video")
+            fun resolveType(
+                @Suppress("unused_parameter") type: Any,
+            ): String? = null
+        }
+
+        contextRunner.withBean(FetcherWithResolver::class.java).withBean(VideoFetcher::class.java).run { context ->
+            assertThatNoException().isThrownBy {
+                // verify that it should not trigger a build failure
+                GraphQL
+                    .newGraphQL(
+                        schemaProvider(
+                            applicationContext = context,
+                            fallbackTypeResolver = MyTypeResolverConfig().myTypeResolver(),
+                        ).schema(schema).graphQLSchema,
+                    ).build()
+                    .execute("{video{title}}")
             }
         }
     }