Merge remote-tracking branch 'origin/master'

Author: oliemansm

README.md

@@ -41,7 +41,7 @@ Take a look at our new [documentation](https://www.graphql-java-kickstart.com/to
 
 * **Schema First**:  GraphQL Java Tools allows you to write your schema in a simple, portable way using the [GraphQL schema language](http://graphql.org/learn/schema/) instead of hard-to-read builders in code.
 * **Minimal Boilerplate**:  It takes a lot of work to describe your GraphQL-Java objects manually, and quickly becomes unreadable.
-A few libraries exist to ease the boilerplate pain, including [GraphQL-Java's built-in schema-first wiring](http://graphql-java.readthedocs.io/en/latest/schema.html), but none (so far) do type and datafetcher discovery.
+A few libraries exist to ease the boilerplate pain, including [GraphQL-Java's built-in schema-first wiring](https://www.graphql-java.com/documentation/master/schema/), but none (so far) do type and datafetcher discovery.
 * **Stateful Data Fetchers**:  If you're using an IOC container (like Spring), it's hard to wire up datafetchers that make use of beans you've already defined without a bunch of fragile configuration.  GraphQL Java Tools allows you to register "Resolvers" for any type that can bring state along and use that to resolve fields.
 * **Generated DataFetchers**:  GraphQL Java Tools automatically creates data fetchers for your fields that call the appropriate method on your java class.  This means all you have to do to create a new field is add the field definition to your schema and add a corresponding method on your class.
 * **Type->Class Discovery**:  GraphQL Java Tools starts from your root objects (Query, Mutation) and, as it's generating data fetchers for you, starts to learn about the classes you use for a certain GraphQL type.

pom.xml

@@ -50,6 +50,11 @@
             <artifactId>graphql-java</artifactId>
             <version>11.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml</groupId>
+            <artifactId>classmate</artifactId>
+            <version>1.4.0</version>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>

src/main/kotlin/com/coxautodev/graphql/tools/GenericType.kt

@@ -1,5 +1,6 @@
 package com.coxautodev.graphql.tools
 
+import com.fasterxml.classmate.ResolvedType
 import com.google.common.primitives.Primitives
 import org.apache.commons.lang3.reflect.TypeUtils
 import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
@@ -131,6 +132,14 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec
                     val actualTypeArguments = type.actualTypeArguments.map { replaceTypeVariable(it) }.toTypedArray()
                     ParameterizedTypeImpl.make(type.rawType as Class<*>?, actualTypeArguments, type.ownerType)
                 }
+                is ResolvedType -> {
+                    if (type.typeParameters.isEmpty()) {
+                        type.erasedType
+                    } else {
+                        val actualTypeArguments = type.typeParameters.map { replaceTypeVariable(it) }.toTypedArray()
+                        ParameterizedTypeImpl.make(type.erasedType, actualTypeArguments, null)
+                    }
+                }
                 is TypeVariable<*> -> {
                     if (declaringType is ParameterizedType) {
                         TypeUtils.getRawType(type, declaringType)

src/main/kotlin/com/coxautodev/graphql/tools/PropertyMapResolver.kt

@@ -1,9 +1,9 @@
 package com.coxautodev.graphql.tools
 
+import com.fasterxml.classmate.TypeResolver
 import graphql.language.FieldDefinition
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
-import java.lang.reflect.ParameterizedType
 
 /**
  * @author Nick Weedon
@@ -14,12 +14,17 @@ internal class PropertyMapResolver(field: FieldDefinition, search: FieldResolver
 
     var mapGenericValue : JavaType = getMapGenericType(relativeTo)
 
+    /**
+     * Takes a type which implements Map and tries to find the
+     * value type of that map. For some reason, mapClass is losing
+     * its generics somewhere along the way and is always a raw
+     * type
+     */
     fun getMapGenericType(mapClass : JavaType) : JavaType {
-        if(mapClass is ParameterizedType) {
-            return mapClass.actualTypeArguments[1]
-        } else {
-            return Object::class.java
-        }
+        val resolvedType = TypeResolver().resolve(mapClass)
+
+        val typeParameters = resolvedType.typeParametersFor(Map::class.java)
+        return typeParameters.elementAtOrElse(1) { Object::class.java }
     }
 
     override fun createDataFetcher(): DataFetcher<*> {

src/main/kotlin/com/coxautodev/graphql/tools/relay/RelayConnectionFactory.kt

@@ -71,6 +71,8 @@ class RelayConnectionFactory : TypeDefinitionFactory {
                     .name("PageInfo")
                     .fieldDefinition(FieldDefinition("hasPreviousPage", NonNullType(TypeName("Boolean"))))
                     .fieldDefinition(FieldDefinition("hasNextPage", NonNullType(TypeName("Boolean"))))
+                    .fieldDefinition(FieldDefinition("startCursor", TypeName("String")))
+                    .fieldDefinition(FieldDefinition("endCursor", TypeName("String")))
                     .build()
 
     private fun Directive.forTypeName(): String {

src/test/java/com/coxautodev/graphql/tools/RelayConnectionTest.java

@@ -44,6 +44,8 @@ public String call() {
                         "       pageInfo {\n" +
                         "           hasPreviousPage,\n" +
                         "           hasNextPage\n" +
+                        "           startCursor\n" +
+                        "           endCursor\n" +
                         "       }\n" +
                         "   }\n" +
                         "}";