feat(#5): support GraphQL interfaces

Author: BlasiusSecundus

README.md

@@ -439,6 +439,12 @@ demonstrates possible workarounds for this issue.
 `GraphQLDirectiveDefinition` and `GraphQLTypeExtension`-annotated classes are subject to the same limitation regarding
 dependency injection - but there can be any number of them.
 
+### Interfaces
+
+Interfaces in the configured package having at least one of their methods marked as `@GraphQLField` are considered a 
+GraphQL interface, and their implementations are automatically added to the schema. Furthermore, you have to add the 
+following annotation to GraphQL interfaces: `@GraphQLTypeResolver(GraphQLInterfaceTypeResolver.class)`
+
 ### Custom scalars and type functions
 
 Custom scalars can be defined in the same way as in the case of using GraphQL Java Tools - just define the 

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/main/java/graphql/kickstart/graphql/annotations/GraphQLAnnotationsAutoConfiguration.java

@@ -1,6 +1,7 @@
 package graphql.kickstart.graphql.annotations;
 
 import graphql.annotations.AnnotationsSchemaCreator;
+import graphql.annotations.annotationTypes.GraphQLField;
 import graphql.annotations.annotationTypes.GraphQLTypeExtension;
 import graphql.annotations.annotationTypes.directives.definition.GraphQLDirectiveDefinition;
 import graphql.annotations.processor.GraphQLAnnotations;
@@ -20,13 +21,17 @@
 import lombok.extern.slf4j.Slf4j;
 import org.reflections.Reflections;
 import org.reflections.ReflectionsException;
+import org.reflections.scanners.MethodAnnotationsScanner;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.scanners.TypeAnnotationsScanner;
 import org.springframework.boot.autoconfigure.AutoConfigureBefore;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
@@ -46,6 +51,11 @@ public class GraphQLAnnotationsAutoConfiguration {
     private final List<TypeFunction> typeFunctions;
     private final List<GraphQLScalarType> customScalarTypes;
 
+    @Bean
+    public GraphQLInterfaceTypeResolver graphQLInterfaceTypeResolver() {
+        return new GraphQLInterfaceTypeResolver();
+    }
+
     @Bean
     @ConditionalOnMissingBean
     public GraphQLAnnotations graphQLAnnotations() {
@@ -58,7 +68,8 @@ public GraphQLSchema graphQLSchema(final GraphQLAnnotations graphQLAnnotations)
         log.info("GraphQL classes are searched in the following package (including subpackages): {}",
             graphQLAnnotationsProperties.getBasePackage());
         final AnnotationsSchemaCreator.Builder builder = newAnnotationsSchema();
-        final Reflections reflections = new Reflections(graphQLAnnotationsProperties.getBasePackage());
+        final Reflections reflections = new Reflections(graphQLAnnotationsProperties.getBasePackage(),
+            new MethodAnnotationsScanner(), new SubTypesScanner(), new TypeAnnotationsScanner());
         builder.setAlwaysPrettify(graphQLAnnotationsProperties.isAlwaysPrettify());
         setQueryResolverClass(builder, reflections);
         setMutationResolverClass(builder, reflections);
@@ -88,6 +99,7 @@ public GraphQLSchema graphQLSchema(final GraphQLAnnotations graphQLAnnotations)
             log.info("Registering relay {}", r.getClass());
             builder.setRelay(r);
         });
+        registerGraphQLInterfaceImplementations(reflections, builder);
         return builder.build();
     }
 
@@ -176,4 +188,30 @@ private <T> Set<Class<? extends T>> getSubTypesOf(
             return Collections.emptySet();
         }
     }
+
+    /**
+     * This is required, because normally implementations of interfaces are not explicitly returned by any resolver
+     * method, and therefor not added to the schema automatically.
+     *
+     * All interfaces are considered GraphQL interfaces if they are declared in the configured package and
+     * have at least one {@link GraphQLField}-annotated methods.
+     *
+     * @param reflections the reflections instance.
+     * @param builder the schema builder instance.
+     */
+    private void registerGraphQLInterfaceImplementations(
+        final Reflections reflections,
+        final AnnotationsSchemaCreator.Builder builder
+    ) {
+        reflections.getMethodsAnnotatedWith(GraphQLField.class).stream()
+            .map(Method::getDeclaringClass)
+            .filter(Class::isInterface)
+            .forEach(graphQLInterface ->
+                reflections.getSubTypesOf(graphQLInterface)
+                    .forEach(implementation -> {
+                        log.info("Registering {} as an implementation of GraphQL interface {}", implementation,
+                            graphQLInterface);
+                        builder.additionalType(implementation);
+                    }));
+    }
 }

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/main/java/graphql/kickstart/graphql/annotations/GraphQLInterfaceTypeResolver.java

@@ -0,0 +1,31 @@
+package graphql.kickstart.graphql.annotations;
+
+import graphql.TypeResolutionEnvironment;
+import graphql.annotations.processor.GraphQLAnnotations;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.TypeResolver;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+/**
+ * Type resolver for GraphQL interfaces.
+ * @see <a href="https://github.com/Enigmatis/graphql-java-annotations/issues/100">Issue with workaround.</a>
+ *
+ * Apply this interface to GraphQL interfaces using the {@link graphql.annotations.annotationTypes.GraphQLTypeResolver}
+ * annotation.
+ */
+public class GraphQLInterfaceTypeResolver implements TypeResolver, ApplicationContextAware {
+
+    private static GraphQLAnnotations graphQLAnnotations;
+
+    @Override
+    public GraphQLObjectType getType(final TypeResolutionEnvironment env) {
+        return graphQLAnnotations.object(env.getObject().getClass());
+    }
+
+    @Override
+    public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
+        graphQLAnnotations = applicationContext.getBean(GraphQLAnnotations.class);
+    }
+}

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/java/graphql/kickstart/graphql/annotations/GraphQLInterfaceQueryTest.java

@@ -0,0 +1,39 @@
+package graphql.kickstart.graphql.annotations;
+
+import com.graphql.spring.boot.test.GraphQLResponse;
+import com.graphql.spring.boot.test.GraphQLTestTemplate;
+import graphql.kickstart.graphql.annotations.test.interfaces.Car;
+import graphql.kickstart.graphql.annotations.test.interfaces.Truck;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Testing interface handling.")
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles({"test", "interface-test"})
+public class GraphQLInterfaceQueryTest {
+
+    @Autowired
+    private GraphQLTestTemplate graphQLTestTemplate;
+
+    @Test
+    @DisplayName("Assert that GraphQL interfaces and their implementations are registered correctly.")
+    void testInterfaceQuery() throws IOException {
+        // WHEN
+        final GraphQLResponse actual = graphQLTestTemplate.postForResource("queries/test-interface-query.graphql");
+        // THEN
+        assertThat(actual.get("$.data.vehicles[0]", Car.class))
+            .usingRecursiveComparison().ignoringAllOverriddenEquals()
+            .isEqualTo(Car.builder().numberOfSeats(4).registrationNumber("ABC-123").build());
+        assertThat(actual.get("$.data.vehicles[1]", Truck.class))
+            .usingRecursiveComparison().ignoringAllOverriddenEquals()
+            .isEqualTo(Truck.builder().cargoWeightCapacity(12).registrationNumber("CBA-321").build());
+    }
+}
+

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/java/graphql/kickstart/graphql/annotations/test/interfaces/Car.java

@@ -0,0 +1,26 @@
+package graphql.kickstart.graphql.annotations.test.interfaces;
+
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class Car implements Vehicle {
+
+    /**
+     * Note that you have to repeat the annotations from the interface method!
+     */
+    @GraphQLField
+    @GraphQLNonNull
+    private String registrationNumber;
+
+    @GraphQLField
+    @GraphQLNonNull
+    private int numberOfSeats;
+}

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/java/graphql/kickstart/graphql/annotations/test/interfaces/InterfaceQuery.java

@@ -0,0 +1,19 @@
+package graphql.kickstart.graphql.annotations.test.interfaces;
+
+import graphql.annotations.annotationTypes.GraphQLDescription;
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
+import graphql.kickstart.tools.GraphQLQueryResolver;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class InterfaceQuery implements GraphQLQueryResolver {
+
+    @GraphQLField
+    @GraphQLNonNull
+    @GraphQLDescription("Returns vehicles")
+    public static List<Vehicle> vehicles() {
+        return Arrays.asList(new Car("ABC-123", 4), new Truck("CBA-321", 12));
+    }
+}

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/java/graphql/kickstart/graphql/annotations/test/interfaces/Truck.java

@@ -0,0 +1,26 @@
+package graphql.kickstart.graphql.annotations.test.interfaces;
+
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Truck implements Vehicle {
+
+    /**
+     * Note that you have to repeat the annotations from the interface method!
+     */
+    @GraphQLField
+    @GraphQLNonNull
+    private String registrationNumber;
+
+    @GraphQLField
+    @GraphQLNonNull
+    private int cargoWeightCapacity;
+}

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/java/graphql/kickstart/graphql/annotations/test/interfaces/Vehicle.java

@@ -0,0 +1,14 @@
+package graphql.kickstart.graphql.annotations.test.interfaces;
+
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.annotationTypes.GraphQLNonNull;
+import graphql.annotations.annotationTypes.GraphQLTypeResolver;
+import graphql.kickstart.graphql.annotations.GraphQLInterfaceTypeResolver;
+
+@GraphQLTypeResolver(GraphQLInterfaceTypeResolver.class)
+public interface Vehicle {
+
+    @GraphQLField
+    @GraphQLNonNull
+    String getRegistrationNumber();
+}

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/resources/application-interface-test.yaml

@@ -0,0 +1 @@
+graphql.annotations.base-package: graphql.kickstart.graphql.annotations.test.interfaces

graphql-kickstart-spring-boot-autoconfigure-graphql-annotations/src/test/resources/queries/test-interface-query.graphql

@@ -0,0 +1,11 @@
+query {
+    vehicles {
+        registrationNumber
+        ... on Car {
+            numberOfSeats
+        }
+        ... on Truck {
+            cargoWeightCapacity
+        }
+    }
+}