Allow entity extensions to stitch and resolve deprecated fields

Author: kmoore-intuit

src/main/java/com/intuit/graphql/orchestrator/federation/EntityTypeMerger.java

@@ -45,7 +45,7 @@ private void pruneConflictingResolverInfo(EntityMergingContext entityMergingCont
     .filter(entityFieldDefinition-> !definitionContainsDirective(entityFieldDefinition, FEDERATION_EXTERNAL_DIRECTIVE))
     .forEach(newEntityField -> {
       getFieldDefinitions(entityMergingContext.getBaseType()).removeIf(preexistingField ->
-        definitionContainsDirective(preexistingField, RESOLVER_DIRECTIVE_NAME)
+        (definitionContainsDirective(preexistingField, RESOLVER_DIRECTIVE_NAME) || definitionContainsDirective(preexistingField, "deprecated"))
         && preexistingField.getName().equals(newEntityField.getName())
       );
 

src/main/java/com/intuit/graphql/orchestrator/schema/transform/FederationTransformerPostMerge.java

@@ -183,7 +183,9 @@ private void checkFederationFieldDirectives(EntityMergingContext entityMergingCo
 
       List<FieldDefinition> baseFields = getFieldDefinitions(entityMergingContext.getBaseType());
       List<String> baseFieldNames = baseFields.stream()
-              .map(FieldDefinition::getName).collect(Collectors.toList());
+              .filter(field -> !definitionContainsDirective(field, "deprecated"))
+              .map(FieldDefinition::getName)
+              .collect(Collectors.toList());
 
       List<String> baseFieldResolvers = baseFields.stream()
               .filter(fieldDefinition -> definitionContainsDirective(fieldDefinition, RESOLVER_DIRECTIVE_NAME))

src/test/groovy/com/intuit/graphql/orchestrator/federation/EntityTypeMergerSpec.groovy

@@ -181,6 +181,80 @@ class EntityTypeMergerSpec extends Specification {
         actualFieldNames containsInAnyOrder("requiredField", "testField2", "ExternalFieldResolver", "testField1")
     }
 
+    def "merge Into Base Type prunes deprecated base field success"(){
+        given:
+
+        TypeSystemDefinition typeSystemDefinition = createTypeSystemDefinition()
+
+        FieldDefinition requiredField = buildFieldDefinition("requiredField")
+
+        FieldDefinition entityRequiredField = buildFieldDefinition("requiredField")
+        entityRequiredField.getDirectives().add(buildDirective(buildDirectiveDefinition("external"), emptyList()))
+
+        FieldDefinition deprecatedField = buildFieldDefinition("deprecatedField")
+        deprecatedField.getDirectives().add(buildDirective(buildDirectiveDefinition("deprecated"), emptyList()))
+
+        FieldDefinition extField = buildFieldDefinition("deprecatedField")
+
+
+        ObjectTypeDefinition baseObjectType =
+                buildObjectTypeDefinition("EntityType", Arrays.asList(
+                        requiredField,
+                        deprecatedField,
+                ))
+
+        ObjectTypeExtensionDefinition objectTypeExtension =
+                buildObjectTypeExtensionDefinition("EntityType", Arrays.asList(
+                        entityRequiredField,
+                        extField
+                ))
+
+        typeSystemDefinition.setTypeExtension(objectTypeExtension)
+
+        entityMergingContextMock.getBaseType() >> baseObjectType
+        entityMergingContextMock.getExtensionSystemDefinition() >> typeSystemDefinition
+
+        unifiedXtextGraphMock.getFieldResolverContexts() >> fieldResolverContexts
+
+        Map<String, FederationMetadata> federationMetadataMap = new HashMap<>()
+
+        FederationMetadata baseFederationMetadataMock = Mock(FederationMetadata.class)
+        FederationMetadata extFederationMetadataMock = Mock(FederationMetadata.class)
+
+        FederationMetadata.EntityMetadata baseEntityMetaDataMock = Mock(FederationMetadata.EntityMetadata.class)
+        Set<String> baseFields = Sets.newHashSet("requiredField", "deprecatedField")
+        baseEntityMetaDataMock.getFields() >> baseFields
+
+        FederationMetadata.EntityMetadata extEntityMetaDataMock = Mock(FederationMetadata.EntityMetadata.class)
+        Set<String> extFields = Sets.newHashSet( "deprecatedField")
+        extEntityMetaDataMock.getFields() >> extFields
+
+        baseFederationMetadataMock.getEntityMetadataByName("EntityType") >> baseEntityMetaDataMock
+        extFederationMetadataMock.getEntityMetadataByName("EntityType") >> extEntityMetaDataMock
+
+        federationMetadataMap.put("baseService", baseFederationMetadataMock)
+        federationMetadataMap.put("extService", extFederationMetadataMock)
+
+        unifiedXtextGraphMock.getFederationMetadataByNamespace() >> federationMetadataMap
+        entityMergingContextMock.getTypename() >> "EntityType"
+
+        when:
+        TypeDefinition actual = subjectUnderTest.mergeIntoBaseType(entityMergingContextMock, unifiedXtextGraphMock)
+
+        then:
+        actual == baseObjectType
+        List<FieldDefinition> actualFieldDefinitions = getFieldDefinitions(actual)
+        actualFieldDefinitions.size() == 2
+
+        baseFields.size() == 1
+        baseFields containsInAnyOrder("requiredField")
+
+        List<String> actualFieldNames = actualFieldDefinitions.stream()
+                .map({ fieldDefinition -> fieldDefinition.getName() })
+                .collect(Collectors.toList())
+        actualFieldNames containsInAnyOrder("requiredField", "deprecatedField")
+    }
+
     def "merge Into Base Type interface Type Definition success"() {
         // TODO
     }

src/test/groovy/com/intuit/graphql/orchestrator/schema/transform/FederationTransformerPostMergeSpec.groovy

@@ -20,6 +20,10 @@ class FederationTransformerPostMergeSpec extends Specification {
 
     private FieldDefinition BASE_FIELD_DEFINITION = buildFieldDefinition("testField1")
 
+    private Directive DEPRECATED_DIRECTIVE = buildDirective(buildDirectiveDefinition("deprecated"), null)
+
+    private FieldDefinition BASE_DEPRECATED_FIELD_DEFINITION = buildFieldDefinition("deprecatedField", singletonList(DEPRECATED_DIRECTIVE))
+
     private Directive EXTERNAL_DIRECTIVE = buildDirective(buildDirectiveDefinition(FEDERATION_EXTERNAL_DIRECTIVE), null)
 
     private FieldDefinition EXTENSION_FIELD_DEFINITION = buildFieldDefinition("testField1", singletonList(EXTERNAL_DIRECTIVE))
@@ -34,8 +38,10 @@ class FederationTransformerPostMergeSpec extends Specification {
     Map<String, TypeDefinition> getEntities() {
         Map<String, TypeDefinition> entitiesByTypeName = new HashMap<>()
 
+        List<FieldDefinition> baseFields = Arrays.asList(BASE_FIELD_DEFINITION, BASE_DEPRECATED_FIELD_DEFINITION)
+
         ObjectTypeDefinition baseObjectType =
-                buildObjectTypeDefinition("EntityType", singletonList(BASE_FIELD_DEFINITION))
+                buildObjectTypeDefinition("EntityType", baseFields)
         entitiesByTypeName.put("EntityType", baseObjectType)
 
         return entitiesByTypeName
@@ -148,6 +154,32 @@ class FederationTransformerPostMergeSpec extends Specification {
         actual.is(unifiedXtextGraphMock)
     }
 
+    def "transform success shared field with deprecated field"(){
+        given:
+        def unifiedXtextGraphMock = Mock(UnifiedXtextGraph)
+
+        Map<String, Map<String, TypeSystemDefinition>> entityExtensionsByNamespace = new HashMap<>()
+        TypeSystemDefinition typeSystemDefinition = createTypeSystemDefinition()
+
+        ObjectTypeDefinition objectTypeExtension =
+                buildObjectTypeDefinition("EntityType", singletonList(buildFieldDefinition("deprecatedField")))
+        typeSystemDefinition.setType(objectTypeExtension)
+        entityExtensionsByNamespace.put("testNamespace", ImmutableMap.of("EntityType", typeSystemDefinition))
+
+        1 * unifiedXtextGraphMock.getEntitiesByTypeName() >> getEntities()
+        1 * unifiedXtextGraphMock.getFieldResolverContexts() >> Collections.emptyList()
+        2 * unifiedXtextGraphMock.getEntityExtensionsByNamespace() >> entityExtensionsByNamespace
+        unifiedXtextGraphMock.getEntityExtensionMetadatas() >> []
+        unifiedXtextGraphMock.getFederationMetadataByNamespace() >> new HashMap<>()
+        unifiedXtextGraphMock.getValueTypesByName() >> new HashMap<>()
+
+        when:
+        UnifiedXtextGraph actual = subjectUnderTest.transform(unifiedXtextGraphMock)
+
+        then:
+        actual.is(unifiedXtextGraphMock)
+    }
+
     def "transform adds inaccessible info"() {
         given:
         def unifiedXtextGraphMock = Mock(UnifiedXtextGraph)