[federation] skip validation of nested objects under construction (ExpediaGroup#403)

When generating federated GraphQL schema we attempt to validate the generated objects. This is problematic when we are dealing with nested relationships as at validation time, those objects are still being built so we only have access to their `GraphQLTypeReference`. Those references are replaced as the last step of schema generation lifecycle which means we won't be able to perform any validations on those objects when they are still being built. This PR disables the validation of `@provides` directive when it references objects that are still being built.

Author: dariuszkuc

graphql-kotlin-federation/src/main/kotlin/com/expediagroup/graphql/federation/validation/validateProvidesDirective.kt

@@ -19,6 +19,7 @@ package com.expediagroup.graphql.federation.validation
 import com.expediagroup.graphql.federation.extensions.isExtendedType
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLObjectType
+import graphql.schema.GraphQLTypeReference
 import graphql.schema.GraphQLTypeUtil
 
 // [OK]    @provides on base type references valid @external fields on @extend object
@@ -28,25 +29,22 @@ import graphql.schema.GraphQLTypeUtil
 // [OK]    @provides references list of valid @extend objects
 // [ERROR] @provides references @external list field
 // [ERROR] @provides references @external interface field
-internal fun validateProvidesDirective(federatedType: String, field: GraphQLFieldDefinition): List<String> {
-    val errors = mutableListOf<String>()
-    val returnType = GraphQLTypeUtil.unwrapAll(field.type)
-    if (returnType is GraphQLObjectType) {
+internal fun validateProvidesDirective(federatedType: String, field: GraphQLFieldDefinition): List<String> = when (val returnType = GraphQLTypeUtil.unwrapType(field.type).last()) {
+    is GraphQLObjectType -> {
         if (!returnType.isExtendedType()) {
-            errors.add("@provides directive is specified on a $federatedType.${field.name} field references local object")
+            listOf("@provides directive is specified on a $federatedType.${field.name} field references local object")
         } else {
             val returnTypeFields = returnType.fieldDefinitions.associateBy { it.name }
             // @provides is applicable on both base and federated types and always references @external fields
-            errors.addAll(
-                validateDirective(
-                    "$federatedType.${field.name}",
-                    "provides",
-                    field.directivesByName,
-                    returnTypeFields,
-                    true))
+            validateDirective(
+                "$federatedType.${field.name}",
+                "provides",
+                field.directivesByName,
+                returnTypeFields,
+                true)
         }
-    } else {
-        errors.add("@provides directive is specified on a $federatedType.${field.name} field but it does not return an object type")
     }
-    return errors
+    // skip validation for nested object types as they are still under construction
+    is GraphQLTypeReference -> emptyList()
+    else -> listOf("@provides directive is specified on a $federatedType.${field.name} field but it does not return an object type")
 }

graphql-kotlin-federation/src/test/kotlin/com/expediagroup/graphql/federation/validation/FederatedSchemaValidatorProvidesDirectiveTest.kt

@@ -1,3 +1,4 @@
+@file:Suppress("MethodOverloading")
 /*
  * Copyright 2019 Expedia, Inc
  *
@@ -27,9 +28,11 @@ import com.expediagroup.graphql.federation.directives.KeyDirective
 import com.expediagroup.graphql.federation.directives.ProvidesDirective
 import com.expediagroup.graphql.federation.exception.InvalidFederatedSchema
 import graphql.schema.GraphQLObjectType
+import graphql.schema.GraphQLTypeReference
 import graphql.schema.GraphQLTypeUtil
 import io.mockk.mockk
 import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
@@ -99,6 +102,27 @@ class FederatedSchemaValidatorProvidesDirectiveTest {
         }
     }
 
+    @Test
+    fun `validated nested relationship with @provide directive`() {
+        // order of object instantiation matters
+        // - BUG #397 - typeA -> typeB with provides (apply validation) -> reference typeA
+        // - NO ISSUE - typeB with provides -> typeA (no validation) -> reference typeB
+        val validatedType = schemaGenerator.objectType(NestedProvidedType::class) as? GraphQLObjectType
+        assertNotNull(validatedType)
+        assertEquals(NestedProvidedType::class.simpleName, validatedType.name)
+        validator.validateGraphQLType(validatedType)
+        assertNotNull(validatedType.getDirective("key"))
+
+        val typeWithProvides = schemaGenerator.objectType(NestedProvides::class) as? GraphQLObjectType
+        assertNotNull(typeWithProvides)
+        validator.validateGraphQLType(typeWithProvides)
+        val providedField = typeWithProvides.getFieldDefinition("provided")
+        assertNotNull(providedField)
+        assertNotNull(providedField.getDirective("provides"))
+        val providedType = GraphQLTypeUtil.unwrapType(providedField.type).last() as? GraphQLTypeReference
+        assertNotNull(providedType)
+    }
+
     // ======================= TEST DATA ===========
     /*
     type SimpleProvides @key(fields : "id") {
@@ -276,4 +300,33 @@ class FederatedSchemaValidatorProvidesDirectiveTest {
         @ExternalDirective val id: String,
         @ExternalDirective val data: ProvidedInterface = throw UnsupportedOperationException("not implemented")
     )
+
+    /*
+    type NestedProvidedType @extends @key(fields : "id") {
+      id: String! @external
+      nested: NestedProvides!
+      text: String! @external
+    }
+
+    type NestedProvides @key(fields : "id") {
+      description: String!
+      id: String!
+      provided: NestedProvidedType! @provides(fields : "text")
+    }
+     */
+    @KeyDirective(fields = FieldSet("id"))
+    private class NestedProvides(val id: String, val description: String) {
+
+        @ProvidesDirective(fields = FieldSet("text"))
+        fun provided() = NestedProvidedType(id, "some text")
+    }
+
+    @KeyDirective(fields = FieldSet("id"))
+    @ExtendsDirective
+    private class NestedProvidedType(
+        @ExternalDirective val id: String,
+        @ExternalDirective val text: String
+    ) {
+        fun nested(): NestedProvides = NestedProvides("123", "some description")
+    }
 }