Merge pull request #165 from guy120494/fix-union

Fix union

Author: yarinvak

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

@@ -78,6 +78,7 @@ dependencies {
     compileOnly 'biz.aQute.bnd:biz.aQute.bndlib:3.2.0'
 
     testCompile 'org.testng:testng:6.9.10'
+    testCompile 'org.hamcrest:hamcrest-all:1.3'
 }
 
 test.useTestNG()

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/typeResolvers/UnionTypeResolver.java

@@ -16,16 +16,18 @@
 
 import graphql.TypeResolutionEnvironment;
 import graphql.annotations.processor.ProcessingElementsContainer;
-import graphql.schema.*;
+import graphql.schema.GraphQLObjectType;
 import graphql.schema.GraphQLType;
+import graphql.schema.TypeResolver;
 
 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).
@@ -35,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 {