Keep all output types in registry, move type resolution from TypeFunctions to GraphQLAnnotations

Author: Thomas Draier

src/main/java/graphql/annotations/DefaultTypeFunction.java

@@ -15,27 +15,20 @@
 package graphql.annotations;
 
 import graphql.Scalars;
-import graphql.schema.GraphQLEnumType;
 import graphql.schema.GraphQLList;
 import graphql.schema.GraphQLType;
-import graphql.schema.GraphQLTypeReference;
-import org.osgi.service.component.annotations.Activate;
-import org.osgi.service.component.annotations.Component;
-import org.osgi.service.component.annotations.Reference;
-import org.osgi.service.component.annotations.ReferenceCardinality;
-import org.osgi.service.component.annotations.ReferencePolicy;
+import org.osgi.service.component.annotations.*;
 
 import java.lang.reflect.AnnotatedParameterizedType;
 import java.lang.reflect.AnnotatedType;
-import java.lang.reflect.Field;
 import java.lang.reflect.ParameterizedType;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.stream.Stream;
 
 import static graphql.annotations.util.NamingKit.toGraphqlName;
-import static graphql.schema.GraphQLEnumType.newEnum;
 
 @Component(property = "type=default")
 public class DefaultTypeFunction implements TypeFunction {
@@ -253,69 +246,7 @@ private Class<?> getClass(AnnotatedType annotatedType) {
         }
     }
 
-    private class EnumFunction implements TypeFunction {
-        private final Map<String, GraphQLTypeReference> processing = new ConcurrentHashMap<>();
-        private final Map<String, GraphQLType> types = new ConcurrentHashMap<>();
-
-        @Override
-        public String getTypeName(Class<?> aClass, AnnotatedType annotatedType) {
-            GraphQLName name = aClass.getAnnotation(GraphQLName.class);
-            return toGraphqlName(name == null ? aClass.getSimpleName() : name.value());
-        }
-
-        @Override
-        public boolean canBuildType(Class<?> aClass, AnnotatedType annotatedType) {
-            return Enum.class.isAssignableFrom(aClass);
-        }
-
-        @Override
-        public GraphQLType buildType(String typeName, Class<?> aClass, AnnotatedType annotatedType) {
-            if (types.containsKey(typeName)) {
-                return types.get(typeName);
-            } else if (processing.containsKey(typeName)) {
-                return processing.getOrDefault(typeName, new GraphQLTypeReference(typeName));
-            } else {
-
-                processing.put(typeName, new GraphQLTypeReference(typeName));
-
-                //noinspection unchecked
-                Class<? extends Enum> enumClass = (Class<? extends Enum>) aClass;
-                GraphQLEnumType.Builder builder = newEnum();
-                builder.name(typeName);
-
-                GraphQLDescription description = aClass.getAnnotation(GraphQLDescription.class);
-                if (description != null) {
-                    builder.description(description.value());
-                }
-
-                List<Enum> constants = Arrays.asList(enumClass.getEnumConstants());
-
-                Arrays.stream(enumClass.getEnumConstants()).map(Enum::name).forEachOrdered(n -> {
-                    try {
-                        Field field = aClass.getField(n);
-                        GraphQLName fieldName = field.getAnnotation(GraphQLName.class);
-                        GraphQLDescription fieldDescription = field.getAnnotation(GraphQLDescription.class);
-                        Enum constant = constants.stream().filter(c -> c.name().contentEquals(n)).findFirst().get();
-                        String name_ = fieldName == null ? n : fieldName.value();
-                        builder.value(name_, constant, fieldDescription == null ? name_ : fieldDescription.value());
-                    } catch (NoSuchFieldException ignore) {
-                    }
-                });
-
-                final GraphQLEnumType type = builder.build();
-                types.put(typeName, type);
-                //noinspection SuspiciousMethodCalls
-                processing.remove(type);
-                return type;
-            }
-        }
-    }
-
     private class ObjectFunction implements TypeFunction {
-
-        private final Map<String, GraphQLTypeReference> processing = new ConcurrentHashMap<>();
-        private final Map<String, GraphQLType> types = new ConcurrentHashMap<>();
-
         @Override
         public String getTypeName(Class<?> aClass, AnnotatedType annotatedType) {
             GraphQLName name = aClass.getAnnotation(GraphQLName.class);
@@ -329,22 +260,7 @@ public boolean canBuildType(Class<?> aClass, AnnotatedType annotatedType) {
 
         @Override
         public GraphQLType buildType(String typeName, Class<?> aClass, AnnotatedType annotatedType) {
-            if (types.containsKey(typeName)) {
-                return types.get(typeName);
-            } else if (processing.containsKey(typeName)) {
-                return processing.getOrDefault(typeName, new GraphQLTypeReference(typeName));
-            } else {
-                processing.put(typeName, new GraphQLTypeReference(typeName));
-                GraphQLType type;
-                if (aClass.isInterface()) {
-                    type = annotationsProcessor.getInterface(aClass);
-                } else {
-                    type = annotationsProcessor.getObjectOrRef(aClass);
-                }
-                types.put(typeName, type);
-                processing.remove(typeName);
-                return type;
-            }
+            return annotationsProcessor.getOutputTypeOrRef(aClass);
         }
     }
 
@@ -362,8 +278,6 @@ public DefaultTypeFunction() {
         typeFunctions.add(new IterableFunction());
         typeFunctions.add(new StreamFunction());
 
-        typeFunctions.add(new EnumFunction());
-
         typeFunctions.add(new OptionalFunction());
 
         typeFunctions.add(new ObjectFunction());

src/main/java/graphql/annotations/GraphQLAnnotations.java

@@ -33,6 +33,7 @@
 import static graphql.annotations.ReflectionKit.newInstance;
 import static graphql.annotations.util.NamingKit.toGraphqlName;
 import static graphql.schema.GraphQLArgument.newArgument;
+import static graphql.schema.GraphQLEnumType.newEnum;
 import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition;
 import static graphql.schema.GraphQLInputObjectField.newInputObjectField;
 import static graphql.schema.GraphQLInterfaceType.newInterface;
@@ -50,7 +51,7 @@ public class GraphQLAnnotations implements GraphQLAnnotationsProcessor {
 
     private static final List<Class> TYPES_FOR_CONNECTION = Arrays.asList(GraphQLObjectType.class, GraphQLInterfaceType.class, GraphQLUnionType.class, GraphQLTypeReference.class);
 
-    private Map<String, graphql.schema.GraphQLType> typeRegistry = new HashMap<>();
+    private Map<String, graphql.schema.GraphQLOutputType> typeRegistry = new HashMap<>();
     private Map<Class<?>, Set<Class<?>>> extensionsTypeRegistry = new HashMap<>();
     private final Stack<String> processing = new Stack<>();
     private Relay relay = new Relay();
@@ -75,21 +76,8 @@ public void setRelay(Relay relay) {
     }
 
     @Override
-    public graphql.schema.GraphQLType getInterface(Class<?> iface) throws GraphQLAnnotationsException {
-        String typeName = getTypeName(iface);
-        graphql.schema.GraphQLType type = typeRegistry.get(typeName);
-        if (type != null) { // type already exists, do not build a new new one
-            return type;
-        }
-        if (iface.getAnnotation(GraphQLUnion.class) != null) {
-            type = getUnionBuilder(iface).build();
-        } else if (!iface.isAnnotationPresent(GraphQLTypeResolver.class)) {
-            type = getObject(iface);
-        } else {
-            type = getIfaceBuilder(iface).build();
-        }
-        typeRegistry.put(typeName, type);
-        return type;
+    public graphql.schema.GraphQLOutputType getInterface(Class<?> iface) throws GraphQLAnnotationsException {
+        return getOutputType(iface);
     }
 
     public static graphql.schema.GraphQLType iface(Class<?> iface) throws GraphQLAnnotationsException {
@@ -252,26 +240,92 @@ private boolean parentalSearch(Field field) {
 
     @Override
     public GraphQLObjectType getObject(Class<?> object) throws GraphQLAnnotationsException {
+        GraphQLOutputType type = getOutputType(object);
+        if (type instanceof GraphQLObjectType) {
+            return (GraphQLObjectType) type;
+        } else {
+            throw new IllegalArgumentException("Object resolve to a "+type.getClass().getSimpleName());
+        }
+    }
+
+    @Override
+    public GraphQLOutputType getOutputType(Class<?> object) throws GraphQLAnnotationsException {
         // because the TypeFunction can call back to this processor and
         // Java classes can be circular, we need to protect against
         // building the same type twice because graphql-java 3.x requires
         // all type instances to be unique singletons
         String typeName = getTypeName(object);
-        processing.push(typeName);
 
-        GraphQLObjectType.Builder builder = getObjectBuilder(object);
+        GraphQLOutputType type = typeRegistry.get(typeName);
+        if (type != null) { // type already exists, do not build a new new one
+            return type;
+        }
 
+        processing.push(typeName);
+        if (object.getAnnotation(GraphQLUnion.class) != null) {
+            type = getUnionBuilder(object).build();
+        } else if (object.isAnnotationPresent(GraphQLTypeResolver.class)) {
+            type = getIfaceBuilder(object).build();
+        } else if (Enum.class.isAssignableFrom(object)) {
+            type = getEnumBuilder(object).build();
+        } else {
+            type = new GraphQLObjectTypeWrapper(object, getObjectBuilder(object).build());
+        }
+
+        typeRegistry.put(typeName, type);
         processing.pop();
-        return new GraphQLObjectTypeWrapper(object, builder.build());
+
+        return type;
+    }
+
+    public static GraphQLOutputType outputType(Class<?> object) {
+        return getInstance().getOutputType(object);
+    }
+
+    public GraphQLEnumType.Builder getEnumBuilder(Class<?> aClass) {
+        String typeName = getTypeName(aClass);
+        //noinspection unchecked
+        Class<? extends Enum> enumClass = (Class<? extends Enum>) aClass;
+        GraphQLEnumType.Builder builder = newEnum();
+        builder.name(typeName);
+
+        GraphQLDescription description = aClass.getAnnotation(GraphQLDescription.class);
+        if (description != null) {
+            builder.description(description.value());
+        }
+
+        List<Enum> constants = Arrays.asList(enumClass.getEnumConstants());
+
+        Arrays.stream(enumClass.getEnumConstants()).map(Enum::name).forEachOrdered(n -> {
+            try {
+                Field field = aClass.getField(n);
+                GraphQLName fieldName = field.getAnnotation(GraphQLName.class);
+                GraphQLDescription fieldDescription = field.getAnnotation(GraphQLDescription.class);
+                Enum constant = constants.stream().filter(c -> c.name().contentEquals(n)).findFirst().get();
+                String name_ = fieldName == null ? n : fieldName.value();
+                builder.value(name_, constant, fieldDescription == null ? name_ : fieldDescription.value());
+            } catch (NoSuchFieldException ignore) {
+            }
+        });
+        return builder;
+    }
+
+    public static  GraphQLEnumType.Builder enumBuilder(Class<?> object) throws GraphQLAnnotationsException {
+        return getInstance().getEnumBuilder(object);
     }
 
-    @Override
     public GraphQLOutputType getObjectOrRef(Class<?> object) throws GraphQLAnnotationsException {
+        return getOutputTypeOrRef(object);
+    }
+
+    @Override
+    public GraphQLOutputType getOutputTypeOrRef(Class<?> object) throws GraphQLAnnotationsException {
         String typeName = getTypeName(object);
         if (processing.contains(typeName)) {
             return new GraphQLTypeReference(typeName);
         }
-        return getObject(object);
+
+        return getOutputType(object);
     }
 
     public static GraphQLObjectType object(Class<?> object) throws GraphQLAnnotationsException {
@@ -726,7 +780,7 @@ public static void register(TypeFunction typeFunction) {
         getInstance().registerType(typeFunction);
     }
 
-    public Map<String, graphql.schema.GraphQLType> getTypeRegistry() {
+    public Map<String, graphql.schema.GraphQLOutputType> getTypeRegistry() {
         return typeRegistry;
     }
 

src/main/java/graphql/annotations/GraphQLAnnotationsProcessor.java

@@ -14,24 +14,11 @@
  */
 package graphql.annotations;
 
-import graphql.schema.GraphQLInputObjectType;
-import graphql.schema.GraphQLInterfaceType;
-import graphql.schema.GraphQLObjectType;
-import graphql.schema.GraphQLOutputType;
-import graphql.schema.GraphQLUnionType;
+import graphql.schema.*;
 
 public interface GraphQLAnnotationsProcessor {
     /**
-     * This will examine the class and if its annotated with {@link GraphQLUnion} it will return
-     * a {@link GraphQLUnionType.Builder}, if its annotated with {@link GraphQLTypeResolver} it will return
-     * a {@link GraphQLObjectType} otherwise it will return a {@link GraphQLInterfaceType.Builder}.
-     *
-     * @param iface interface to examine
-     *
-     * @return a GraphQLType that represents that interface
-     *
-     * @throws GraphQLAnnotationsException if the interface cannot be examined
-     * @throws IllegalArgumentException    if <code>iface</code> is not an interface
+     * @deprecated See {@link #getOutputType(Class)}
      */
     graphql.schema.GraphQLType getInterface(Class<?> iface) throws GraphQLAnnotationsException;
 
@@ -60,28 +47,53 @@ public interface GraphQLAnnotationsProcessor {
     GraphQLInterfaceType.Builder getIfaceBuilder(Class<?> iface) throws GraphQLAnnotationsException, IllegalArgumentException;
 
     /**
-     * This will examine the object class and return a {@link GraphQLObjectType} representation
+     * This will examine the object class and return a {@link GraphQLEnumType.Builder} ready for further definition
      *
      * @param object the object class to examine
      *
-     * @return a {@link GraphQLObjectType} that represents that object class
+     * @return a {@link GraphQLEnumType.Builder} that represents that object class
      *
      * @throws GraphQLAnnotationsException if the object class cannot be examined
      */
+    GraphQLEnumType.Builder getEnumBuilder(Class<?> object) throws GraphQLAnnotationsException;
+
+    /**
+     * @deprecated See {@link #getOutputType(Class)}
+     */
     GraphQLObjectType getObject(Class<?> object) throws GraphQLAnnotationsException;
 
     /**
-     * This will examine the object class and return a {@link GraphQLOutputType} representation
-     * which may be a {@link GraphQLObjectType} or a {@link graphql.schema.GraphQLTypeReference}
+     * This will examine the object and will return a {@link GraphQLOutputType} based on the class type and annotations.
+     * - If its annotated with {@link GraphQLUnion} it will return a {@link GraphQLUnionType}
+     * - If its annotated with {@link GraphQLTypeResolver} it will return a {@link GraphQLInterfaceType}
+     * - It it's an Enum it will return a {@link GraphQLEnumType},
+     * otherwise it will return a {@link GraphQLObjectType}.
      *
      * @param object the object class to examine
      *
      * @return a {@link GraphQLOutputType} that represents that object class
      *
      * @throws GraphQLAnnotationsException if the object class cannot be examined
      */
+    GraphQLOutputType getOutputType(Class<?> object) throws GraphQLAnnotationsException;
+
+    /**
+     * @deprecated See {@link #getOutputTypeOrRef(Class)}
+     */
     GraphQLOutputType getObjectOrRef(Class<?> object) throws GraphQLAnnotationsException;
 
+    /**
+     * This will examine the object class and return a {@link GraphQLOutputType} representation
+     * which may be a {@link GraphQLOutputType} or a {@link graphql.schema.GraphQLTypeReference}
+     *
+     * @param object the object class to examine
+     *
+     * @return a {@link GraphQLOutputType} that represents that object class
+     *
+     * @throws GraphQLAnnotationsException if the object class cannot be examined
+     */
+    GraphQLOutputType getOutputTypeOrRef(Class<?> object) throws GraphQLAnnotationsException;
+
     /**
      * This will examine the object class and return a {@link GraphQLObjectType.Builder} ready for further definition
      *

src/test/java/graphql/annotations/DefaultTypeFunctionTest.java

@@ -16,6 +16,8 @@
 
 import graphql.schema.*;
 import graphql.schema.GraphQLType;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.BeforeTest;
 import org.testng.annotations.Test;
 
 import java.lang.reflect.Field;
@@ -30,6 +32,11 @@
 
 public class DefaultTypeFunctionTest {
 
+    @BeforeMethod
+    public void init() {
+        GraphQLAnnotations.getInstance().getTypeRegistry().clear();
+    }
+
     private enum A {
         @GraphQLName("someA") @GraphQLDescription("a") A, B
     }