Merge branch 'master' into custom-paging

Author: guy120494

README.md

@@ -34,18 +34,26 @@ GraphQLObjectType object = GraphQLAnnotations.object(SomeObject.class);
 
 ## Defining Interfaces
 
-This is very similar to defining objects:
+This is very similar to defining objects, with the addition of type resolver : 
 
 ```java
+@GraphQLTypeResolver(MyTypeResolver.class)
 public interface SomeInterface {
   @GraphQLField
   String field();
 }
 
+public class MyTypeResolver implements TypeResolver {
+  GraphQLObjectType getType(TypeResolutionEnvironment env) { ... }
+}
+
 // ...
 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.
+
 ## Fields
 
 In addition to specifying a field over a Java class field, a field can be defined over a method:
@@ -108,10 +116,21 @@ public String field(@GraphQLDefaultValue(DefaultValue.class) String value) {
 }
 ```
 
+The `DefaultValue` class can define a `getInstance` method that will be called instead of the default constructor.
+
 `@GraphQLDeprecate` and Java's `@Deprecated` can be used to specify a deprecated
 field.
 
-You can specify a custom data fetcher for a field with `@GraphQLDataFetcher`
+### Custom data fetcher
+
+You can specify a custom data fetcher for a field with `@GraphQLDataFetcher`. The annotation will reference a class name, 
+which will be used as data fetcher. 
+
+An instance of the data fetcher will be created. The `args` attribute on the annotation can be used to specify a list of 
+String arguments to pass to the construcor, allowing to reuse the same class on different fields, with different parameter. 
+The `firstArgIsTargetName` attribute can also be set on `@GraphQLDataFetcher` to pass the field name as a single parameter of the constructor.
+
+If no argument is needed and a `getInstance` method is present, this method will be called instead of the constructor.
 
 ## Type extensions
 

build.gradle

@@ -60,7 +60,9 @@ repositories {
 
 gradle.projectsEvaluated {
     tasks.withType(JavaCompile) {
-        options.compilerArgs << "-parameters"
+        doLast {
+            options.compilerArgs += "-parameters"
+        }
     }
 }
 

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

@@ -14,13 +14,16 @@
  */
 package graphql.annotations;
 
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetcherFactories;
 import graphql.schema.GraphQLFieldDefinition;
 
 public  class GraphQLFieldDefinitionWrapper extends GraphQLFieldDefinition {
 
     public GraphQLFieldDefinitionWrapper(GraphQLFieldDefinition fieldDefinition) {
         super(fieldDefinition.getName(), fieldDefinition.getDescription(), fieldDefinition.getType(),
-                fieldDefinition.getDataFetcher(), fieldDefinition.getArguments(), fieldDefinition.getDeprecationReason());
+                DataFetcherFactories.useDataFetcher((DataFetcher<?>)fieldDefinition.getDataFetcher()), fieldDefinition.getArguments(), fieldDefinition.getDeprecationReason(),
+                fieldDefinition.getDefinition());
     }
 
     @Override

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

@@ -0,0 +1,53 @@
+/**
+ * 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.processor.typeFunctions;
+
+import graphql.annotations.processor.ProcessingElementsContainer;
+import graphql.schema.GraphQLList;
+import graphql.schema.GraphQLType;
+
+import java.lang.reflect.AnnotatedArrayType;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.ParameterizedType;
+
+public class ArrayFunction implements TypeFunction {
+
+    private DefaultTypeFunction defaultTypeFunction;
+
+    public ArrayFunction(DefaultTypeFunction defaultTypeFunction) {
+        this.defaultTypeFunction = defaultTypeFunction;
+    }
+
+    @Override
+    public boolean canBuildType(Class<?> aClass, AnnotatedType annotatedType) {
+        return aClass.isArray();
+    }
+
+    @Override
+    public GraphQLType buildType(boolean input, Class<?> aClass, AnnotatedType annotatedType, ProcessingElementsContainer container) {
+        if (!(annotatedType instanceof AnnotatedArrayType)) {
+            throw new IllegalArgumentException("Array type parameter should be specified");
+        }
+        AnnotatedArrayType parameterizedType = (AnnotatedArrayType) annotatedType;
+        AnnotatedType arg = parameterizedType.getAnnotatedGenericComponentType();
+        Class<?> klass;
+        if (arg.getType() instanceof ParameterizedType) {
+            klass = (Class<?>) ((ParameterizedType) (arg.getType())).getRawType();
+        } else {
+            klass = (Class<?>) arg.getType();
+        }
+        return new GraphQLList(defaultTypeFunction.buildType(input, klass, arg, container));
+    }
+}

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

@@ -62,6 +62,7 @@ public void activate() {
         typeFunctions.add(new BigDecimalFunction());
         typeFunctions.add(new CharFunction());
         typeFunctions.add(new IterableFunction(DefaultTypeFunction.this));
+        typeFunctions.add(new ArrayFunction(DefaultTypeFunction.this));
         typeFunctions.add(new StreamFunction(DefaultTypeFunction.this));
         typeFunctions.add(new OptionalFunction(DefaultTypeFunction.this));
         typeFunctions.add(new ObjectFunction(graphQLInputProcessor, graphQLOutputProcessor));

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

@@ -25,12 +25,12 @@
 /**
  * Support for the Iterable things like Lists / Sets / Collections and so on..
  */
-class  IterableFunction implements TypeFunction {
+class IterableFunction implements TypeFunction {
 
     private DefaultTypeFunction defaultTypeFunction;
 
-    public IterableFunction(DefaultTypeFunction defaultTypeFunction){
-        this.defaultTypeFunction=defaultTypeFunction;
+    public IterableFunction(DefaultTypeFunction defaultTypeFunction) {
+        this.defaultTypeFunction = defaultTypeFunction;
     }
 
     @Override
@@ -51,6 +51,6 @@ public GraphQLType buildType(boolean input, Class<?> aClass, AnnotatedType annot
         } else {
             klass = (Class<?>) arg.getType();
         }
-        return new GraphQLList(defaultTypeFunction.buildType(input, klass, arg,container));
+        return new GraphQLList(defaultTypeFunction.buildType(input, klass, arg, container));
     }
-}
+}

src/main/java/graphql/annotations/processor/util/ReflectionKit.java

@@ -18,6 +18,8 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 
 /**
  * A package level helper in calling reflective methods and turning them into
@@ -26,8 +28,16 @@
 public class ReflectionKit {
     public static <T> T newInstance(Class<T> clazz) throws GraphQLAnnotationsException {
         try {
+            try {
+                Method getInstance = clazz.getMethod("getInstance", new Class<?>[0]);
+                if (Modifier.isStatic(getInstance.getModifiers()) && clazz.isAssignableFrom(getInstance.getReturnType())) {
+                    return (T) getInstance.invoke(null);
+                }
+            } catch (NoSuchMethodException e) {
+                // ignore, just call the constructor
+            }
             return clazz.newInstance();
-        } catch (InstantiationException | IllegalAccessException e) {
+        } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
             throw new GraphQLAnnotationsException("Unable to instantiate class : " + clazz, e);
         }
     }

src/test/java/graphql/annotations/GraphQLInterfaceTest.java

@@ -69,6 +69,10 @@ public void noResolver() {
 
     public static class Resolver implements TypeResolver {
 
+        public static Resolver getInstance() {
+            return new Resolver();
+        }
+
         @Override
         public GraphQLObjectType getType(TypeResolutionEnvironment env) {
             try {

src/test/java/graphql/annotations/GraphQLIterableAndArrayTest.java

@@ -0,0 +1,148 @@
+/**
+ * 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.annotations.annotationTypes.GraphQLDataFetcher;
+import graphql.annotations.annotationTypes.GraphQLField;
+import graphql.annotations.processor.GraphQLAnnotations;
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLSchema;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+import static graphql.schema.GraphQLSchema.newSchema;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+public class GraphQLIterableAndArrayTest {
+    @BeforeMethod
+    public void init() {
+        GraphQLAnnotations.getInstance().getTypeRegistry().clear();
+    }
+
+    static class TestMappedObject {
+        @GraphQLField
+        public String name;
+
+        @GraphQLField
+        public String foo;
+    }
+
+    static class TestObjectDB {
+        private String foo;
+
+        private String name;
+
+        TestObjectDB(String name, String foo) {
+            this.name = name;
+            this.foo = foo;
+        }
+    }
+
+    public static class IterableAndArrayTestQuery {
+        @GraphQLField
+        @GraphQLDataFetcher(ArrayFetcher.class)
+        public TestMappedObject[] array;
+
+        @GraphQLField
+        @GraphQLDataFetcher(ListFetcher.class)
+        public List<TestMappedObject> list;
+
+        @GraphQLField
+        @GraphQLDataFetcher(ArrayWithinArrayFetcher.class)
+        public TestMappedObject[][] arrayWithinArray;
+    }
+
+    public static class ArrayFetcher implements DataFetcher<TestObjectDB[]> {
+
+        @Override
+        public TestObjectDB[] get(DataFetchingEnvironment environment) {
+            return new TestObjectDB[]{new TestObjectDB("hello", "world")};
+        }
+    }
+
+    public static class ListFetcher implements DataFetcher<List<TestObjectDB>> {
+
+        @Override
+        public List<TestObjectDB> get(DataFetchingEnvironment environment) {
+            return Collections.singletonList(new TestObjectDB("test name", "test foo"));
+        }
+    }
+
+    public static class ArrayWithinArrayFetcher implements DataFetcher<TestObjectDB[][]> {
+
+        @Override
+        public TestObjectDB[][] get(DataFetchingEnvironment environment) {
+            return new TestObjectDB[][]{
+                    {new TestObjectDB("hello", "world")},
+                    {new TestObjectDB("a", "b"), new TestObjectDB("c", "d")}
+            };
+        }
+    }
+
+    @Test
+    public void queryWithArray() {
+        GraphQLObjectType object = GraphQLAnnotations.object(IterableAndArrayTestQuery.class);
+        GraphQLSchema schema = newSchema().query(object).build();
+
+        ExecutionResult result = GraphQL.newGraphQL(schema).build().execute("{array {name foo}}");
+        assertTrue(result.getErrors().isEmpty());
+        assertEquals(((LinkedHashMap) getQueryResultAtIndex(result, "array", 0)).get("name"), "hello");
+        assertEquals(((LinkedHashMap) getQueryResultAtIndex(result, "array", 0)).get("foo"), "world");
+    }
+
+    @Test
+    public void queryWithList() {
+        GraphQLObjectType object = GraphQLAnnotations.object(IterableAndArrayTestQuery.class);
+        GraphQLSchema schema = newSchema().query(object).build();
+
+        ExecutionResult result = GraphQL.newGraphQL(schema).build().execute("{list {name foo}}");
+        assertTrue(result.getErrors().isEmpty());
+        assertEquals(((LinkedHashMap) getQueryResultAtIndex(result, "list", 0)).get("name"), "test name");
+        assertEquals(((LinkedHashMap) getQueryResultAtIndex(result, "list", 0)).get("foo"), "test foo");
+    }
+
+    @Test
+    public void queryWithArrayWithinAnArray() {
+        GraphQLObjectType object = GraphQLAnnotations.object(IterableAndArrayTestQuery.class);
+        GraphQLSchema schema = newSchema().query(object).build();
+
+        ExecutionResult result = GraphQL.newGraphQL(schema).build().execute("{arrayWithinArray {name foo}}");
+        assertTrue(result.getErrors().isEmpty());
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 0, 0)).get("name"), "hello");
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 0, 0)).get("foo"), "world");
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 1, 0)).get("name"), "a");
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 1, 0)).get("foo"), "b");
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 1, 1)).get("name"), "c");
+        assertEquals(((LinkedHashMap) getQueryResultAtCell(result, "arrayWithinArray", 1, 1)).get("foo"), "d");
+    }
+
+    private Object getQueryResultAtIndex(ExecutionResult result, String queryName, int index) {
+        return ((ArrayList) (((LinkedHashMap) result.getData()).get(queryName))).get(index);
+    }
+
+    private Object getQueryResultAtCell(ExecutionResult result, String queryName, int rowIndex, int columnIndex) {
+        return (((ArrayList) (getQueryResultAtIndex(result, queryName, rowIndex))).get(columnIndex));
+    }
+}