Merge pull request #64 from mattesja/master

introduced typeRegistry for GraphQLType objects to prevent duplicate …

Author: bbakerman

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

@@ -66,7 +66,6 @@
 import static graphql.schema.GraphQLObjectType.newObject;
 import static graphql.schema.GraphQLUnionType.newUnionType;
 import static java.util.Arrays.stream;
-import static java.util.Objects.isNull;
 import static java.util.Objects.nonNull;
 
 /**
@@ -76,6 +75,8 @@
 @Component
 public class GraphQLAnnotations implements GraphQLAnnotationsProcessor {
 
+    private Map<String, graphql.schema.GraphQLType> typeRegistry = new HashMap<>();
+
     public GraphQLAnnotations() {
         defaultTypeFunction = new DefaultTypeFunction();
         ((DefaultTypeFunction) defaultTypeFunction).setAnnotationsProcessor(this);
@@ -89,13 +90,20 @@ public static GraphQLAnnotations getInstance() {
 
     @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) {
-            return getUnionBuilder(iface).build();
+            type = getUnionBuilder(iface).build();
         } else if (!iface.isAnnotationPresent(GraphQLTypeResolver.class)) {
-            return getObject(iface);
+            type = getObject(iface);
         } else {
-            return getIfaceBuilder(iface).build();
+            type = getIfaceBuilder(iface).build();
         }
+        typeRegistry.put(typeName, type);
+        return type;
     }
 
     public static graphql.schema.GraphQLType iface(Class<?> iface) throws GraphQLAnnotationsException {
@@ -110,8 +118,7 @@ public GraphQLUnionType.Builder getUnionBuilder(Class<?> iface) throws GraphQLAn
         GraphQLUnionType.Builder builder = newUnionType();
 
         GraphQLUnion unionAnnotation = iface.getAnnotation(GraphQLUnion.class);
-        GraphQLName name = iface.getAnnotation(GraphQLName.class);
-        builder.name(name == null ? iface.getSimpleName() : name.value());
+        builder.name(getTypeName(iface));
         GraphQLDescription description = iface.getAnnotation(GraphQLDescription.class);
         if (description != null) {
             builder.description(description.value());
@@ -143,6 +150,11 @@ public static GraphQLUnionType.Builder unionBuilder(Class<?> iface) throws Graph
         return getInstance().getUnionBuilder(iface);
     }
 
+    public String getTypeName(Class<?> objectClass) {
+        GraphQLName name = objectClass.getAnnotation(GraphQLName.class);
+        return (name == null ? objectClass.getSimpleName() : name.value());
+    }
+
     @Override
     public GraphQLInterfaceType.Builder getIfaceBuilder(Class<?> iface) throws GraphQLAnnotationsException,
             IllegalArgumentException {
@@ -151,8 +163,7 @@ public GraphQLInterfaceType.Builder getIfaceBuilder(Class<?> iface) throws Graph
         }
         GraphQLInterfaceType.Builder builder = newInterface();
 
-        GraphQLName name = iface.getAnnotation(GraphQLName.class);
-        builder.name(name == null ? iface.getSimpleName() : name.value());
+        builder.name(getTypeName(iface));
         GraphQLDescription description = iface.getAnnotation(GraphQLDescription.class);
         if (description != null) {
             builder.description(description.value());
@@ -274,8 +285,7 @@ public boolean equals(Object obj) {
     @Override
     public GraphQLObjectType.Builder getObjectBuilder(Class<?> object) throws GraphQLAnnotationsException {
         GraphQLObjectType.Builder builder = newObject();
-        GraphQLName name = object.getAnnotation(GraphQLName.class);
-        builder.name(name == null ? object.getSimpleName() : name.value());
+        builder.name(getTypeName(object));
         GraphQLDescription description = object.getAnnotation(GraphQLDescription.class);
         if (description != null) {
             builder.description(description.value());
@@ -635,6 +645,9 @@ public static void register(TypeFunction typeFunction) {
         getInstance().registerType(typeFunction);
     }
 
+    public Map<String, graphql.schema.GraphQLType> getTypeRegistry() {
+        return typeRegistry;
+    }
 
     private static class ConnectionDataFetcher implements DataFetcher {
         private final Class<? extends Connection> connection;

src/test/java/graphql/annotations/GraphQLFragmentTest.java

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2016 Yurii Rashkovskii
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ */
+package graphql.annotations;
+
+import graphql.ExecutionResult;
+import graphql.GraphQL;
+import graphql.schema.GraphQLInterfaceType;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLSchema;
+import graphql.schema.TypeResolver;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+import static org.testng.AssertJUnit.assertEquals;
+
+
+public class GraphQLFragmentTest {
+
+    static Map<String, GraphQLObjectType> registry;
+
+    /**
+     * Test a query which returns a list (RootObject.items) of two different classes (MyObject + MyObject2) which implement the same interface (MyInterface).
+     */
+    @Test
+    public void testInterfaceInlineFragment() throws Exception {
+        // Given
+        registry = new HashMap<>();
+
+        GraphQLInterfaceType iface = (GraphQLInterfaceType) GraphQLAnnotations.iface(MyInterface.class);
+
+        GraphQLObjectType rootType = GraphQLAnnotations.object(RootObject.class);
+
+        GraphQLObjectType objectType2 = GraphQLAnnotations.object(MyObject2.class);
+
+        registry.put("MyObject2", objectType2);
+
+        GraphQLObjectType objectType = GraphQLAnnotations.object(MyObject.class);
+
+        registry.put("MyObject", objectType);
+
+        GraphQLSchema schema = GraphQLSchema.newSchema()
+                .query(rootType)
+                .build(new HashSet(Arrays.asList(iface, rootType, objectType, objectType2)));
+
+        GraphQL graphQL2 = new GraphQL(schema);
+
+        // When
+        ExecutionResult graphQLResult = graphQL2.execute("{items { ... on MyObject {a, my {b}} ... on MyObject2 {a, b}  }}", new RootObject());
+        Set resultMap = ((Map) graphQLResult.getData()).entrySet();
+
+        // Then
+        assertEquals(graphQLResult.getErrors().size(), 0);
+        assertEquals(resultMap.size(), 1);
+    }
+
+    public static class RootObject {
+        @GraphQLField
+        public List<MyInterface> getItems() {
+            return Arrays.asList(new MyObject(), new MyObject2());
+        }
+    }
+
+    public static class MyObject implements MyInterface {
+        public String getA() {
+            return "a1";
+        }
+
+        public String getB() {
+            return "b1";
+        }
+
+        @GraphQLField
+        public MyObject2 getMy() {
+            return new MyObject2();
+        }
+    }
+
+    public static class MyObject2 implements MyInterface {
+        public String getA() {
+            return "a2";
+        }
+
+        public String getB() {
+            return "b2";
+        }
+    }
+
+    @GraphQLTypeResolver(value = MyTypeResolver.class)
+    public static interface MyInterface {
+        @GraphQLField
+        public String getA();
+
+        @GraphQLField
+        public String getB();
+    }
+
+    public static class MyTypeResolver implements TypeResolver {
+
+        @Override
+        public GraphQLObjectType getType(Object object) {
+            return registry.get(object.getClass().getSimpleName());
+        }
+    }
+
+
+}