Merge branch 'master' into custom-paging

Author: guy120494

README.md

@@ -54,6 +54,45 @@ GraphQLInterfaceType object = GraphQLAnnotations.iface(SomeInterface.class);
 An instance of the type resolver will be created from the specified class. If a `getInstance` method is present on the
 class, it will be used instead of the default constructor.
 
+## Defining Unions
+
+To have a union, you must annotate an interface with `@GraphQLUnion`. In the annotation, you must declare all the 
+possible types of the union, and a type resolver.
+If no type resolver is specified, `UnionTypeResovler` is used. It follows this algorithm:
+The resolver assumes the the DB entity's name is the same as  the API entity's name.
+ If so, it takes the result from the dataFetcher and decides to which
+API entity it should be mapped (according to the name). 
+Example: If you have a `Pet` union type, and the dataFetcher returns `Dog`, the typeResolver
+will check for each API entity if its name is equal to `Dog`, and returns if it finds something
+
+```java
+@GraphQLUnion(possibleTypes={Dog.class, Cat.class})
+public interface Pet {}
+``` 
+and an example with custom `TypeResovler`:
+```java
+@GraphQLUnion(possibleTypes={DogApi.class, Cat.class}, typeResolver = PetTypeResolver.class)
+public interface Pet {}
+
+
+public class PetTypeResolver implements TypeResolver {
+    @Override
+    GraphQLObjectType getType(TypeResolutionEnvironment env) {
+        Object obj = env.getObject();
+        if(obj instanceof DogDB) {
+            return (GraphQLObjectType) env.getSchema().getType("DogApi");
+        }
+        else {
+            return (GraphQLObjectType) env.getSchema().getType("Cat");
+        }
+      
+    }
+}
+```
+NOTE: you can have (but not mandatory) a type resolver with constructor that has `Class<?>[]` as the first parameter and
+`ProcessingElementsContainer` as the second. the `Class<?>[]` parameter contains the possibleTypes class
+and `ProcessingElementsContainer` has all sorts of utils (you can check `UnionTypeResolver` to see how we use it there)
+
 ## Fields
 
 In addition to specifying a field over a Java class field, a field can be defined over a method:

build.gradle

@@ -69,7 +69,7 @@ gradle.projectsEvaluated {
 
 dependencies {
     compile 'javax.validation:validation-api:1.1.0.Final'
-    compile 'com.graphql-java:graphql-java:7.0'
+    compile 'com.graphql-java:graphql-java:8.0'
 
     // OSGi
     compileOnly 'org.osgi:org.osgi.core:6.0.0'
@@ -78,7 +78,7 @@ dependencies {
     compileOnly 'biz.aQute.bnd:biz.aQute.bndlib:3.2.0'
 
     testCompile 'org.testng:testng:6.9.10'
-    testCompile 'org.hamcrest:hamcrest-core:1.3'
+    testCompile 'org.hamcrest:hamcrest-all:1.3'
 }
 
 test.useTestNG()

gradle.properties

@@ -7,3 +7,4 @@ org.gradle.jvmargs=-Dfile.encoding=UTF-8
 
 bintray.user=DUMMY_USER
 bintray.key=DUMMY_KEY
+version = 5.2

src/main/java/graphql/annotations/GraphQLFieldDefinitionWrapper.java

@@ -18,11 +18,13 @@
 import graphql.schema.DataFetcherFactories;
 import graphql.schema.GraphQLFieldDefinition;
 
-public  class GraphQLFieldDefinitionWrapper extends GraphQLFieldDefinition {
+public class GraphQLFieldDefinitionWrapper extends GraphQLFieldDefinition {
 
     public GraphQLFieldDefinitionWrapper(GraphQLFieldDefinition fieldDefinition) {
         super(fieldDefinition.getName(), fieldDefinition.getDescription(), fieldDefinition.getType(),
-                DataFetcherFactories.useDataFetcher((DataFetcher<?>)fieldDefinition.getDataFetcher()), fieldDefinition.getArguments(), fieldDefinition.getDeprecationReason(),
+                DataFetcherFactories.useDataFetcher((DataFetcher<?>) fieldDefinition.getDataFetcher()),
+                fieldDefinition.getArguments(), fieldDefinition.getDeprecationReason(),
+                fieldDefinition.getDirectives(),
                 fieldDefinition.getDefinition());
     }
 

src/main/java/graphql/annotations/annotationTypes/GraphQLUnion.java

@@ -14,6 +14,9 @@
  */
 package graphql.annotations.annotationTypes;
 
+import graphql.annotations.typeResolvers.UnionTypeResolver;
+import graphql.schema.TypeResolver;
+
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -23,4 +26,6 @@
 @Retention(RetentionPolicy.RUNTIME)
 public @interface GraphQLUnion {
     Class<?>[] possibleTypes();
+
+    Class<? extends TypeResolver> typeResolver() default UnionTypeResolver.class;
 }

src/main/java/graphql/annotations/processor/typeBuilders/UnionBuilder.java

@@ -19,17 +19,20 @@
 import graphql.annotations.annotationTypes.GraphQLType;
 import graphql.annotations.annotationTypes.GraphQLUnion;
 import graphql.annotations.processor.ProcessingElementsContainer;
-import graphql.annotations.processor.util.ReflectionKit;
 import graphql.annotations.processor.exceptions.GraphQLAnnotationsException;
-import graphql.annotations.processor.typeFunctions.TypeFunction;
 import graphql.annotations.processor.retrievers.GraphQLObjectInfoRetriever;
+import graphql.annotations.processor.typeFunctions.TypeFunction;
 import graphql.annotations.typeResolvers.UnionTypeResolver;
 import graphql.schema.GraphQLObjectType;
-import graphql.schema.GraphQLUnionType;
+import graphql.schema.GraphQLUnionType.Builder;
+import graphql.schema.TypeResolver;
 
+import java.lang.reflect.Constructor;
 import java.util.Arrays;
-import java.util.function.Function;
+import java.util.Optional;
 
+import static graphql.annotations.processor.util.ReflectionKit.constructNewInstance;
+import static graphql.annotations.processor.util.ReflectionKit.newInstance;
 import static graphql.schema.GraphQLUnionType.newUnionType;
 
 public class UnionBuilder {
@@ -41,18 +44,18 @@ public UnionBuilder(GraphQLObjectInfoRetriever graphQLObjectInfoRetriever) {
     }
 
     /**
-     * This will examine the class and return a {@link GraphQLUnionType.Builder} ready for further definition
+     * This will examine the class and return a {@link Builder} ready for further definition
      * @param container a class that hold several members that are required in order to build schema
      * @param iface interface to examine
-     * @return a {@link GraphQLUnionType.Builder}
+     * @return a {@link Builder}
      * @throws GraphQLAnnotationsException if the class cannot be examined
      */
 
-    public GraphQLUnionType.Builder getUnionBuilder(Class<?> iface, ProcessingElementsContainer container) throws GraphQLAnnotationsException, IllegalArgumentException {
+    public Builder getUnionBuilder(Class<?> iface, ProcessingElementsContainer container) throws GraphQLAnnotationsException, IllegalArgumentException {
         if (!iface.isInterface()) {
             throw new IllegalArgumentException(iface + " is not an interface");
         }
-        GraphQLUnionType.Builder builder = newUnionType();
+        Builder builder = newUnionType();
 
         GraphQLUnion unionAnnotation = iface.getAnnotation(GraphQLUnion.class);
         builder.name(graphQLObjectInfoRetriever.getTypeName(iface));
@@ -65,21 +68,41 @@ public GraphQLUnionType.Builder getUnionBuilder(Class<?> iface, ProcessingElemen
         TypeFunction typeFunction = container.getDefaultTypeFunction();
 
         if (typeAnnotation != null) {
-            typeFunction = ReflectionKit.newInstance(typeAnnotation.value());
+            typeFunction = newInstance(typeAnnotation.value());
         }
 
         TypeFunction finalTypeFunction = typeFunction;
-        Arrays.asList(unionAnnotation.possibleTypes()).stream()
-                .map(new Function<Class<?>, graphql.schema.GraphQLType>() {
-                    @Override
-                    public graphql.schema.GraphQLType apply(Class<?> aClass) {
-                        return finalTypeFunction.buildType(aClass, null, container);
-                    }
-                })
+        Arrays.stream(unionAnnotation.possibleTypes())
+                .map(aClass -> finalTypeFunction.buildType(aClass, null, container))
                 .map(v -> (GraphQLObjectType) v)
                 .forEach(builder::possibleType);
 
-        builder.typeResolver(new UnionTypeResolver(unionAnnotation.possibleTypes(), container));
+        TypeResolver typeResolver = getTypeResolver(container, unionAnnotation);
+
+        builder.typeResolver(typeResolver);
         return builder;
     }
+
+    private TypeResolver getTypeResolver(ProcessingElementsContainer container, GraphQLUnion unionAnnotation) {
+        Optional<Constructor<?>> typeResolverConstructorOptional = Arrays.stream(unionAnnotation.typeResolver().getConstructors())
+                .filter(constructor -> constructor.getParameterCount() == 0 || constructorHasPossibleTypesAndContainerAsParameters(container, constructor))
+                .findFirst();
+
+        return typeResolverConstructorOptional
+                .map(constructor -> {
+                    if(constructor.getParameterCount() == 0) {
+                        return (TypeResolver) constructNewInstance(constructor);
+                    }
+                    else {
+                        return (TypeResolver) constructNewInstance(constructor, unionAnnotation.possibleTypes(), container);
+                    }
+                })
+                .orElseGet(() -> new UnionTypeResolver(unionAnnotation.possibleTypes(), container));
+    }
+
+    private boolean constructorHasPossibleTypesAndContainerAsParameters(ProcessingElementsContainer container, Constructor<?> constructor) {
+        return constructor.getParameterCount() == 2 &&
+                Class[].class.isAssignableFrom(constructor.getParameterTypes()[0]) &&
+                container.getClass().isAssignableFrom(constructor.getParameterTypes()[1]);
+    }
 }

src/main/java/graphql/annotations/processor/typeFunctions/FloatFunction.java

@@ -29,7 +29,7 @@ public String getTypeName(Class<?> aClass, AnnotatedType annotatedType) {
 
     @Override
     public boolean canBuildType(Class<?> aClass, AnnotatedType annotatedType) {
-        return aClass == Float.class || aClass == float.class || aClass == Double.class || aClass == double.class;
+        return aClass == Double.class || aClass == double.class;
     }
 
     @Override

src/main/java/graphql/annotations/strategies/EnhancedExecutionStrategy.java

@@ -31,8 +31,8 @@ public class EnhancedExecutionStrategy extends AsyncSerialExecutionStrategy {
 
     @Override
     protected CompletableFuture<ExecutionResult> resolveField(ExecutionContext executionContext, ExecutionStrategyParameters parameters) {
-        GraphQLObjectType parentType = (GraphQLObjectType) parameters.typeInfo().getType();
-        GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, parameters.field().get(0));
+        GraphQLObjectType parentType = (GraphQLObjectType) parameters.getTypeInfo().getType();
+        GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, parameters.getField().get(0));
         if (fieldDef == null) return null;
 
         if (fieldDef.getName().contentEquals(CLIENT_MUTATION_ID)) {
@@ -52,11 +52,11 @@ protected CompletableFuture<ExecutionResult> resolveField(ExecutionContext execu
                 clientMutationId = clientMutationIdVal.getValue();
             }
 
-            ExecutionTypeInfo fieldTypeInfo = ExecutionTypeInfo.newTypeInfo().type(fieldDef.getType()).parentInfo(parameters.typeInfo()).build();
+            ExecutionTypeInfo fieldTypeInfo = ExecutionTypeInfo.newTypeInfo().type(fieldDef.getType()).parentInfo(parameters.getTypeInfo()).build();
             ExecutionStrategyParameters newParameters = ExecutionStrategyParameters.newParameters()
-                    .arguments(parameters.arguments())
-                    .fields(parameters.fields())
-                    .nonNullFieldValidator(parameters.nonNullFieldValidator())
+                    .arguments(parameters.getArguments())
+                    .fields(parameters.getFields())
+                    .nonNullFieldValidator(parameters.getNonNullFieldValidator())
                     .typeInfo(fieldTypeInfo)
                     .source(clientMutationId)
                     .build();
@@ -70,8 +70,8 @@ protected CompletableFuture<ExecutionResult> resolveField(ExecutionContext execu
 
     @Override
     protected CompletableFuture<ExecutionResult> completeValue(ExecutionContext executionContext, ExecutionStrategyParameters parameters) throws NonNullableFieldWasNullException {
-        graphql.schema.GraphQLType fieldType = parameters.typeInfo().getType();
-        Object result = parameters.source();
+        graphql.schema.GraphQLType fieldType = parameters.getTypeInfo().getType();
+        Object result = parameters.getSource();
         if (result instanceof Enum && fieldType instanceof GraphQLEnumType) {
             Object value = ((GraphQLEnumType) fieldType).getCoercing().parseValue(((Enum) result).name());
             return super.completeValue(executionContext, withSource(parameters, value));
@@ -88,10 +88,10 @@ protected CompletableFuture<ExecutionResult> completeValue(ExecutionContext exec
      */
     private ExecutionStrategyParameters withSource(ExecutionStrategyParameters parameters, Object source) {
         return ExecutionStrategyParameters.newParameters()
-                .arguments(parameters.arguments())
-                .fields(parameters.fields())
-                .nonNullFieldValidator(parameters.nonNullFieldValidator())
-                .typeInfo(parameters.typeInfo())
+                .arguments(parameters.getArguments())
+                .fields(parameters.getFields())
+                .nonNullFieldValidator(parameters.getNonNullFieldValidator())
+                .typeInfo(parameters.getTypeInfo())
                 .source(source)
                 .build();
     }

src/main/java/graphql/annotations/typeResolvers/UnionTypeResolver.java

@@ -23,10 +23,11 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 
 public class UnionTypeResolver implements TypeResolver {
-    private final Map<Class<?>, graphql.schema.GraphQLType> types = new HashMap<>();
+    private final Map<Class<?>, GraphQLType> types = new HashMap<>();
 
     public UnionTypeResolver(Class<?>[] classes, ProcessingElementsContainer container) {
         Arrays.stream(classes).
@@ -36,8 +37,10 @@ public UnionTypeResolver(Class<?>[] classes, ProcessingElementsContainer contain
     @Override
     public GraphQLObjectType getType(TypeResolutionEnvironment env) {
         Object object = env.getObject();
-        Optional<Map.Entry<Class<?>, GraphQLType>> maybeType = types.entrySet().
-                stream().filter(e -> e.getKey().isAssignableFrom(object.getClass())).findFirst();
+        Optional<Entry<Class<?>, GraphQLType>> maybeType = types.entrySet().
+                stream().filter(e -> object.getClass().getSimpleName()
+                .equals(e.getKey().getSimpleName())).findFirst();
+
         if (maybeType.isPresent()) {
             return (GraphQLObjectType) maybeType.get().getValue();
         } else {

src/test/java/graphql/annotations/GraphQLObjectTest.java

@@ -125,6 +125,7 @@ public String getZ() {
         public void setZ(String z) {
             this.z = z;
         }
+
     }
 
     private static class TestDefaults {
@@ -825,6 +826,7 @@ public String getOn() {
         public String getOff() {
             return "off";
         }
+
     }
 
     @Test
@@ -836,4 +838,5 @@ public void inheritGraphQLField() {
         assertNull(object.getFieldDefinition("forcedOff"));
     }
 
+
 }