Merge branch 'up-master'

Author: yarinvak

README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/graphql-java/graphql-java-annotations.svg?branch=master)](https://travis-ci.org/yrashk/graphql-java-annotations)
+[![Build Status](https://travis-ci.org/graphql-java/graphql-java-annotations.svg?branch=master)](https://travis-ci.org/graphql-java/graphql-java-annotations)
 [![Maven Central](https://img.shields.io/maven-central/v/io.github.graphql-java/graphql-java-annotations.svg?maxAge=2592000)]()
 # GraphQL Annotations for Java
 
@@ -12,7 +12,7 @@ syntax for GraphQL schema definition.
 
 ```groovy
 dependencies {
-  compile "io.github.graphql-java:graphql-java-annotations:5.0.7"
+  compile "io.github.graphql-java:graphql-java-annotations:5.2"
 }
 ```
 
@@ -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

@@ -82,7 +82,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/connection/GraphQLConnection.java

@@ -52,4 +52,11 @@
      * @return a connection validator
      */
     Class <? extends ConnectionValidator> validator() default PaginatedDataConnectionTypeValidator.class;
+
+    /**
+     * By default, the paginated data is fetched synchronously. If explicitly specified, asynchronous data fetching
+     * will be used.
+     * @return if async fetching to be used.
+     */
+    boolean async() default false;
 }

src/main/java/graphql/annotations/dataFetchers/connection/AsyncConnectionDataFetcher.java

@@ -0,0 +1,36 @@
+/**
+ * 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.dataFetchers.connection;
+
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+
+import java.util.concurrent.CompletableFuture;
+
+import static java.util.concurrent.CompletableFuture.supplyAsync;
+
+public class AsyncConnectionDataFetcher<T> implements DataFetcher<CompletableFuture<graphql.relay.Connection<T>>> {
+    private final ConnectionDataFetcher connectionDataFetcher;
+
+    @SuppressWarnings("unchecked")
+    public AsyncConnectionDataFetcher(ConnectionDataFetcher connectionFetcher) {
+        this.connectionDataFetcher = connectionFetcher;
+    }
+
+    @Override
+    public CompletableFuture<graphql.relay.Connection<T>> get(DataFetchingEnvironment environment) {
+        return supplyAsync(() -> connectionDataFetcher.get(environment));
+    }
+}

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/field/FieldDataFetcherBuilder.java

@@ -19,17 +19,20 @@
 import graphql.annotations.connection.GraphQLConnection;
 import graphql.annotations.dataFetchers.ExtensionDataFetcherWrapper;
 import graphql.annotations.dataFetchers.MethodDataFetcher;
-import graphql.annotations.dataFetchers.connection.ConnectionDataFetcher;
 import graphql.annotations.processor.ProcessingElementsContainer;
 import graphql.annotations.processor.retrievers.fieldBuilders.Builder;
 import graphql.annotations.processor.typeFunctions.TypeFunction;
 import graphql.annotations.processor.util.DataFetcherConstructor;
-import graphql.schema.*;
+import graphql.schema.DataFetcher;
+import graphql.schema.GraphQLNonNull;
+import graphql.schema.GraphQLType;
+import graphql.schema.PropertyDataFetcher;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
 import static graphql.Scalars.GraphQLBoolean;
+import static graphql.annotations.processor.util.ConnectionUtil.getConnectionDataFetcher;
 import static java.util.Objects.nonNull;
 
 public class FieldDataFetcherBuilder implements Builder<DataFetcher> {
@@ -61,9 +64,8 @@ public DataFetcher build() {
             actualDataFetcher = handleNullCase(actualDataFetcher);
         }
 
-
         if (isConnection) {
-            actualDataFetcher = new ConnectionDataFetcher(field.getAnnotation(GraphQLConnection.class).connection(), actualDataFetcher);
+            actualDataFetcher = getConnectionDataFetcher(field.getAnnotation(GraphQLConnection.class), actualDataFetcher);
         }
         return actualDataFetcher;
     }
@@ -75,7 +77,7 @@ private DataFetcher handleNullCase(DataFetcher actualDataFetcher) {
             actualDataFetcher = getBooleanDataFetcher(actualDataFetcher);
         } else if (checkIfPrefixGetterExists(field.getDeclaringClass(), "get", field.getName())) {
             actualDataFetcher = wrapExtension(new PropertyDataFetcher(field.getName()), field);
-        } else{
+        } else {
             actualDataFetcher = getDataFetcherWithFluentGetter(actualDataFetcher);
         }
 

src/main/java/graphql/annotations/processor/retrievers/fieldBuilders/method/MethodDataFetcherBuilder.java

@@ -21,7 +21,6 @@
 import graphql.annotations.dataFetchers.BatchedMethodDataFetcher;
 import graphql.annotations.dataFetchers.MethodDataFetcher;
 import graphql.annotations.dataFetchers.RelayMutationMethodDataFetcher;
-import graphql.annotations.dataFetchers.connection.ConnectionDataFetcher;
 import graphql.annotations.processor.ProcessingElementsContainer;
 import graphql.annotations.processor.retrievers.fieldBuilders.Builder;
 import graphql.annotations.processor.typeFunctions.TypeFunction;
@@ -34,6 +33,8 @@
 import java.lang.reflect.Method;
 import java.util.List;
 
+import static graphql.annotations.processor.util.ConnectionUtil.getConnectionDataFetcher;
+
 public class MethodDataFetcherBuilder implements Builder<DataFetcher> {
     private Method method;
     private GraphQLOutputType outputType;
@@ -74,7 +75,7 @@ public DataFetcher build() {
         }
 
         if (isConnection){
-            actualDataFetcher = new ConnectionDataFetcher(method.getAnnotation(GraphQLConnection.class).connection(), actualDataFetcher);
+            actualDataFetcher = getConnectionDataFetcher(method.getAnnotation(GraphQLConnection.class), actualDataFetcher);
         }
         return actualDataFetcher;
     }

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));
     }
-}
+}