fix issue

Author: guy120494

src/main/java/graphql/annotations/processor/graphQLProcessors/GraphQLInputProcessor.java

@@ -1,12 +1,12 @@
 /**
  * Copyright 2016 Yurii Rashkovskii
- *
+ * <p>
  * 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
- *
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
  * 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.
@@ -52,18 +52,26 @@ public GraphQLInputProcessor() {
      */
 
     public GraphQLInputType getInputType(Class<?> object, ProcessingElementsContainer container) {
-        String typeName = DEFAULT_INPUT_PREFIX + graphQLObjectInfoRetriever.getTypeName(object);
+        boolean considerAsInput = true;
+        if (Enum.class.isAssignableFrom(object)) {
+            considerAsInput = false;
+        }
+
+        String typeName = graphQLObjectInfoRetriever.getTypeName(object);
+
+        if (considerAsInput)
+            typeName = DEFAULT_INPUT_PREFIX + typeName;
+
         Map<String, GraphQLType> typeRegistry = container.getTypeRegistry();
 
         if (typeRegistry.containsKey(typeName)) {
-            return (GraphQLInputObjectType) container.getTypeRegistry().get(typeName);
+            return (GraphQLInputType) container.getTypeRegistry().get(typeName);
         } else {
-            graphql.schema.GraphQLType graphQLType = graphQLOutputObjectRetriever.getGraphQLType(object, container, true);
+
+            graphql.schema.GraphQLType graphQLType = graphQLOutputObjectRetriever.getGraphQLType(object, container, considerAsInput);
             GraphQLInputType inputObject = graphQLInputObjectRetriever.getInputObject(graphQLType, DEFAULT_INPUT_PREFIX, typeRegistry);
             typeRegistry.put(inputObject.getName(), inputObject);
             return inputObject;
         }
     }
-
-
 }

src/main/java/graphql/annotations/processor/retrievers/GraphQLTypeRetriever.java

@@ -54,14 +54,14 @@ public GraphQLTypeRetriever() {
      * @throws graphql.annotations.processor.exceptions.GraphQLAnnotationsException if the object class cannot be examined
      * @throws graphql.annotations.processor.exceptions.CannotCastMemberException   if the object class cannot be examined
      */
-    public GraphQLType getGraphQLType(Class<?> object, ProcessingElementsContainer container, boolean isInputHirerarchy) throws GraphQLAnnotationsException, CannotCastMemberException {
+    public GraphQLType getGraphQLType(Class<?> object, ProcessingElementsContainer container, boolean isInput) throws GraphQLAnnotationsException, CannotCastMemberException {
         // 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 = graphQLObjectInfoRetriever.getTypeName(object);
         GraphQLType type;
-        if (isInputHirerarchy) {
+        if (isInput) {
             String typeNameWithPrefix = "Input" + typeName;
             type = container.getTypeRegistry().get(typeNameWithPrefix);
             if (type != null) return type;
@@ -83,7 +83,7 @@ public GraphQLType getGraphQLType(Class<?> object, ProcessingElementsContainer c
             type = new ObjectBuilder(graphQLObjectInfoRetriever, new ParentalSearch(graphQLObjectInfoRetriever), new BreadthFirstSearch(graphQLObjectInfoRetriever), graphQLFieldRetriever, new GraphQLInterfaceRetriever()).getObjectBuilder(object, container).build();
         }
 
-        if (isInputHirerarchy) typeName = "Input" + typeName;
+        if (isInput) typeName = "Input" + typeName;
         container.getTypeRegistry().put(typeName, type);
         container.getProcessing().pop();
 

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/ArgumentBuilder.java

@@ -57,12 +57,11 @@ public ArgumentBuilder(Method method, TypeFunction typeFunction, GraphQLInputObj
     @Override
     public List<GraphQLArgument> build() {
         TypeFunction finalTypeFunction = typeFunction;
-        List<GraphQLArgument> args = Arrays.asList(method.getParameters()).stream().
+        List<GraphQLArgument> args = Arrays.stream(method.getParameters()).
                 filter(p -> !DataFetchingEnvironment.class.isAssignableFrom(p.getType())).
                 map(parameter -> {
                     Class<?> t = parameter.getType();
-                    graphql.schema.GraphQLInputType graphQLType = graphQLInputObjectRetriever.getInputObject(finalTypeFunction.buildType(true, t, parameter.getAnnotatedType(), container)
-                            , DEFAULT_INPUT_PREFIX, container.getTypeRegistry());
+                    graphql.schema.GraphQLInputType graphQLType = (GraphQLInputType) finalTypeFunction.buildType(true, t, parameter.getAnnotatedType(), container);
                     return getArgument(parameter, graphQLType);
                 }).collect(Collectors.toList());
 

src/test/java/graphql/annotations/GraphQLInputTest.java

@@ -26,6 +26,7 @@
 import org.testng.annotations.Test;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static graphql.schema.GraphQLSchema.newSchema;
 import static org.testng.Assert.assertEquals;
@@ -226,41 +227,74 @@ public void queryWithInterface() {
     }
 
     @GraphQLName("hero")
-    public class Hero {
+    public static class Hero {
         @GraphQLField
         int a;
     }
 
     @GraphQLName("hero")
-    public class HeroInput {
+    public static class HeroInput {
         @GraphQLField
         String b;
 
         @GraphQLField
         Skill skill;
     }
 
-    public class Skill{
+    public static class Skill {
         @GraphQLField
         String c;
     }
 
-    public class QueryInputAndOutput {
+    public static class QueryInputAndOutput {
         @GraphQLField
         public Hero getHero() {
             return null;
         }
 
         @GraphQLField
-        public String getString(HeroInput input) {
+        public String getString(@GraphQLName("input") HeroInput input) {
             return "asdf";
         }
+
+        // todo: if another method with input argument with type Hero and not HeroInput, it will consider HeroInput as its type because its defined before
+        /*
+        public String getString2(Hero input) {return "Asdfasdf";}
+         */
+    }
+
+
+    public static class QueryInputAndOutput2 {
+        @GraphQLField
+        public String getA(@GraphQLName("skill") Skill skill) {
+            return "asdfasdf";
+        }
+
+        @GraphQLField
+        public Skill getSkill() {
+            return null;
+        }
     }
 
+
     @Test
     public void testInputAndOutputWithSameName() {
+        // arrange + act
         GraphQLSchema schema = newSchema().query(GraphQLAnnotations.object(QueryInputAndOutput.class)).build();
-        int x =5;
+        // assert
+        assertEquals(schema.getQueryType().getFieldDefinition("hero").getType().getName(), "hero");
+        assertEquals(schema.getQueryType().getFieldDefinition("string").getArgument("input").getType().getName(), "Inputhero");
+        assertEquals(((GraphQLInputObjectType) schema.getQueryType().getFieldDefinition("string")
+                .getArgument("input").getType()).getField("skill").getType().getName(), "InputSkill");
+    }
+
+    @Test
+    public void testInputAndOutputSameClass(){
+        // arrange + act
+        GraphQLSchema schema = newSchema().query(GraphQLAnnotations.object(QueryInputAndOutput2.class)).build();
+        // assert
+        assertEquals(schema.getQueryType().getFieldDefinition("skill").getType().getName(), "Skill");
+        assertEquals(schema.getQueryType().getFieldDefinition("a").getArgument("skill").getType().getName(), "InputSkill");
     }
 
 }