Merge pull request #2258 from Netflix/federation-transform-flag

Add flag to turn off apollo federation transform on the schema

Author: jjacobs44

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

@@ -33,6 +33,7 @@ data class DgsConfigurationProperties(
         DgsPreparsedDocumentProviderConfigurationProperties(),
     val introspection: DgsIntrospectionConfigurationProperties = DgsIntrospectionConfigurationProperties(),
     val strictMode: DgsStrictModeProperties = DgsStrictModeProperties(),
+    val federation: DgsFederationProperties = DgsFederationProperties(),
 ) {
     data class DgsPreparsedDocumentProviderConfigurationProperties(
         val enabled: Boolean = false,
@@ -50,4 +51,8 @@ data class DgsConfigurationProperties(
     data class DgsStrictModeProperties(
         val enabled: Boolean = true,
     )
+
+    data class DgsFederationProperties(
+        val enabled: Boolean = true,
+    )
 }

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

@@ -380,6 +380,7 @@ open class DgsSpringGraphQLAutoConfiguration(
             enableEntityFetcherCustomScalarParsing = configProps.enableEntityFetcherCustomScalarParsing,
             fallbackTypeResolver = fallbackTypeResolver,
             enableStrictMode = configProps.strictMode.enabled,
+            federationEnabled = configProps.federation.enabled,
         )
 
     @Bean

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

@@ -113,6 +113,7 @@ class DgsSchemaProvider
         private val enableEntityFetcherCustomScalarParsing: Boolean = false,
         private val fallbackTypeResolver: TypeResolver? = null,
         private val enableStrictMode: Boolean = true,
+        private val federationEnabled: Boolean = true,
     ) {
         @Suppress("UNUSED_PARAMETER")
         @Deprecated("The mockProviders argument is no longer supported")
@@ -266,27 +267,32 @@ class DgsSchemaProvider
 
             val runtimeWiring = runtimeWiringBuilder.build()
 
-            findEntityFetchers(dgsComponents, mergedRegistry, runtimeWiring, dataFetcherInfo)
+            val schemaOptions = SchemaGenerator.Options.defaultOptions().useCommentsAsDescriptions(showSdlComments)
 
-            val federationResolverInstance =
-                federationResolver.orElseGet {
-                    DefaultDgsFederationResolver(
-                        entityFetcherRegistry,
-                        dataFetcherExceptionHandler,
-                        applicationContext,
-                    )
-                }
+            val graphQLSchema =
+                if (federationEnabled) {
+                    findEntityFetchers(dgsComponents, mergedRegistry, runtimeWiring, dataFetcherInfo)
 
-            val entityFetcher = federationResolverInstance.entitiesFetcher()
-            val typeResolver = federationResolverInstance.typeResolver()
-            val schemaOptions = SchemaGenerator.Options.defaultOptions().useCommentsAsDescriptions(showSdlComments)
+                    val federationResolverInstance =
+                        federationResolver.orElseGet {
+                            DefaultDgsFederationResolver(
+                                entityFetcherRegistry,
+                                dataFetcherExceptionHandler,
+                                applicationContext,
+                            )
+                        }
+
+                    val entityFetcher = federationResolverInstance.entitiesFetcher()
+                    val typeResolver = federationResolverInstance.typeResolver()
 
-            var graphQLSchema =
-                Federation
-                    .transform(mergedRegistry, runtimeWiring, schemaOptions)
-                    .fetchEntities(entityFetcher)
-                    .resolveEntityType(typeResolver)
-                    .build()
+                    Federation
+                        .transform(mergedRegistry, runtimeWiring, schemaOptions)
+                        .fetchEntities(entityFetcher)
+                        .resolveEntityType(typeResolver)
+                        .build()
+                } else {
+                    SchemaGenerator().makeExecutableSchema(schemaOptions, mergedRegistry, runtimeWiring)
+                }
 
             val endTime = System.currentTimeMillis()
             val totalTime = endTime - startTime

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

@@ -87,6 +87,7 @@ internal class DgsSchemaProviderTest {
         dataFetcherResultProcessors: List<DataFetcherResultProcessor> = emptyList(),
         fallbackTypeResolver: TypeResolver? = null,
         strictMode: Boolean = true,
+        federationEnabled: Boolean = true,
     ): DgsSchemaProvider =
         DgsSchemaProvider(
             applicationContext = applicationContext,
@@ -105,6 +106,7 @@ internal class DgsSchemaProviderTest {
             dataFetcherResultProcessors = dataFetcherResultProcessors,
             fallbackTypeResolver = fallbackTypeResolver,
             enableStrictMode = strictMode,
+            federationEnabled = federationEnabled,
         )
 
     @DgsComponent
@@ -1418,4 +1420,102 @@ internal class DgsSchemaProviderTest {
             return builder
         }
     }
+
+    @Test
+    fun `Federation enabled by default should include _service and _entities queries`() {
+        data class Movie(
+            val movieId: Int,
+            val title: String,
+        )
+
+        val schema =
+            """
+            type Query {
+                hello: String
+            }
+
+            type Movie @key(fields: "movieId") {
+                movieId: Int!
+                title: String
+            }
+            """.trimIndent()
+
+        @DgsComponent
+        class Fetcher {
+            @DgsData(parentType = "Query", field = "hello")
+            fun hello(): String = "Hello"
+
+            @DgsEntityFetcher(name = "Movie")
+            fun movieEntityFetcher(values: Map<String, Any>): Movie? {
+                val movieId = values["movieId"] as? Int ?: return null
+                return Movie(movieId, "Test Movie")
+            }
+        }
+
+        contextRunner.withBeans(Fetcher::class).run { context ->
+            val provider = schemaProvider(applicationContext = context, federationEnabled = true)
+            val graphQLSchema = provider.schema(schema).graphQLSchema
+
+            assertThat(graphQLSchema.queryType.getFieldDefinition("_service")).isNotNull
+            assertThat(graphQLSchema.queryType.getFieldDefinition("_entities")).isNotNull
+
+            assertThat(graphQLSchema.getType("_Entity")).isNotNull
+
+            val build = GraphQL.newGraphQL(graphQLSchema).build()
+            val executionResult = build.execute("{_service { sdl }}")
+            assertTrue(executionResult.isDataPresent)
+        }
+    }
+
+    @Test
+    fun `Federation disabled should NOT include _service and _entities queries`() {
+        data class Movie(
+            val movieId: Int,
+            val title: String,
+        )
+
+        val schema =
+            """
+            type Query {
+                hello: String
+            }
+
+            type Movie {
+                movieId: Int!
+                title: String
+            }
+            """.trimIndent()
+
+        @DgsComponent
+        class Fetcher {
+            @DgsData(parentType = "Query", field = "hello")
+            fun hello(): String = "Hello"
+
+            @DgsEntityFetcher(name = "Movie")
+            fun movieEntityFetcher(values: Map<String, Any>): Movie? {
+                val movieId = values["movieId"] as? Int ?: return null
+                return Movie(movieId, "Test Movie")
+            }
+        }
+
+        contextRunner.withBeans(Fetcher::class).run { context ->
+            val provider = schemaProvider(applicationContext = context, federationEnabled = false)
+            val graphQLSchema = provider.schema(schema).graphQLSchema
+
+            assertThat(graphQLSchema.queryType.getFieldDefinition("_service")).isNull()
+            assertThat(graphQLSchema.queryType.getFieldDefinition("_entities")).isNull()
+
+            assertThat(graphQLSchema.getType("_Entity")).isNull()
+
+            val build = GraphQL.newGraphQL(graphQLSchema).build()
+
+            val executionResult = build.execute("{hello}")
+            assertTrue(executionResult.isDataPresent)
+            val data = executionResult.getData<Map<String, *>>()
+            assertEquals("Hello", data["hello"])
+
+            val serviceResult = build.execute("{_service { sdl }}")
+            assertThat(serviceResult.errors).isNotEmpty
+        }
+    }
 }