Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 35 additions & 0 deletions src/main/kotlin/com/coxautodev/graphql/tools/FieldResolver.kt
Original file line number Diff line number Diff line change
@@ -0,0 +1,35 @@
package com.coxautodev.graphql.tools

import graphql.language.FieldDefinition
import graphql.schema.DataFetcher
import graphql.schema.DataFetchingEnvironment

/**
* @author Andrew Potter
*/
internal abstract class FieldResolver(val field: FieldDefinition, val search: FieldResolverScanner.Search, relativeTo: JavaType) {
val resolverInfo: ResolverInfo = search.resolverInfo
val genericType = GenericType(search.type).relativeToPotentialParent(relativeTo)

abstract fun scanForMatches(): List<TypeClassMatcher.PotentialMatch>
abstract fun createDataFetcher(): DataFetcher<*>

/**
* Add source resolver depending on whether or not this is a resolver method
*/
protected fun getSourceResolver(): SourceResolver = if(this.search.source != null) {
({ this.search.source })
} else {
({ environment ->
val source = environment.getSource<Any>()

if(!this.genericType.isAssignableFrom(source.javaClass)) {
throw ResolverError("Expected source object to be an instance of '${this.genericType.getRawClass().name}' but instead got '${source.javaClass.name}'")
}

source
})
}
}

internal typealias SourceResolver = (DataFetchingEnvironment) -> Any
127 changes: 127 additions & 0 deletions src/main/kotlin/com/coxautodev/graphql/tools/FieldResolverScanner.kt
Original file line number Diff line number Diff line change
@@ -0,0 +1,127 @@
package com.coxautodev.graphql.tools

import graphql.Scalars
import graphql.language.FieldDefinition
import graphql.language.TypeName
import graphql.schema.DataFetchingEnvironment
import org.apache.commons.lang3.ClassUtils
import org.apache.commons.lang3.reflect.FieldUtils
import java.lang.reflect.Field
import java.lang.reflect.Method

/**
* @author Andrew Potter
*/
internal class FieldResolverScanner {

companion object {
fun getAllMethods(type: Class<*>): List<Method> {
return type.declaredMethods.toList() + ClassUtils.getAllSuperclasses(type).flatMap { it.declaredMethods.toList() }
}
}

fun findFieldResolver(field: FieldDefinition, resolverInfo: ResolverInfo): FieldResolver {
val searches = resolverInfo.getFieldSearches()

val scanProperties = field.inputValueDefinitions.isEmpty()
val found = searches.mapNotNull { search -> findFieldResolver(field, search, scanProperties) }

if(resolverInfo is RootResolverInfo && found.size > 1) {
throw FieldResolverError("Found more than one matching resolver for field '$field': $found")
}

return found.firstOrNull() ?: throw FieldResolverError(getMissingFieldMessage(field, searches, scanProperties))
}

private fun findFieldResolver(field: FieldDefinition, search: Search, scanProperties: Boolean): FieldResolver? {
val method = findResolverMethod(field, search)
if(method != null) {
return MethodFieldResolver(field, search, method.apply { isAccessible = true })
}

if(scanProperties) {
val property = findResolverProperty(field, search)
if(property != null) {
return PropertyFieldResolver(field, search, property.apply { isAccessible = true })
}
}

return null
}

private fun isBoolean(type: GraphQLLangType) = type.unwrap().let { it is TypeName && it.name == Scalars.GraphQLBoolean.name }

private fun findResolverMethod(field: FieldDefinition, search: Search): java.lang.reflect.Method? {

val methods = getAllMethods(search.type)
val argumentCount = field.inputValueDefinitions.size + if(search.requiredFirstParameterType != null) 1 else 0
val name = field.name

val isBoolean = isBoolean(field.type)

// Check for the following one by one:
// 1. Method with exact field name
// 2. Method that returns a boolean with "is" style getter
// 3. Method with "get" style getter
return methods.find {
it.name == name && verifyMethodArguments(it, argumentCount, search)
} ?: methods.find {
(isBoolean && it.name == "is${name.capitalize()}") && verifyMethodArguments(it, argumentCount, search)
} ?: methods.find {
it.name == "get${name.capitalize()}" && verifyMethodArguments(it, argumentCount, search)
}
}

private fun verifyMethodArguments(method: java.lang.reflect.Method, requiredCount: Int, search: Search): Boolean {
val correctParameterCount = method.parameterCount == requiredCount || (method.parameterCount == (requiredCount + 1) && method.parameterTypes.last() == DataFetchingEnvironment::class.java)
val appropriateFirstParameter = if(search.requiredFirstParameterType != null) method.parameterTypes.firstOrNull() == search.requiredFirstParameterType else true
return correctParameterCount && appropriateFirstParameter
}


private fun findResolverProperty(field: FieldDefinition, search: Search): Field? {
return FieldUtils.getAllFields(search.type).find { it.name == field.name }
}

fun getMissingFieldMessage(field: FieldDefinition, searches: List<Search>, scannedProperties: Boolean): String {
val signatures = mutableListOf("")
val isBoolean = isBoolean(field.type)

searches.forEach { search ->
signatures.addAll(getMissingMethodSignatures(field, search, isBoolean, scannedProperties))
}

return "No method${if(scannedProperties) " or field" else ""} found with any of the following signatures (with or without ${DataFetchingEnvironment::class.java.name} as the last argument), in priority order:\n${signatures.joinToString("\n ")}"
}


fun getMissingMethodSignatures(field: FieldDefinition, search: Search, isBoolean: Boolean, scannedProperties: Boolean): List<String> {
val baseType = search.type
val signatures = mutableListOf<String>()
val args = mutableListOf<String>()
val sep = ", "

if(search.requiredFirstParameterType != null) {
args.add(search.requiredFirstParameterType.name)
}

args.addAll(field.inputValueDefinitions.map { "~${it.name}" })

val argString = args.joinToString(sep)

signatures.add("${baseType.name}.${field.name}($argString)")
if(isBoolean) {
signatures.add("${baseType.name}.is${field.name.capitalize()}($argString)")
}
signatures.add("${baseType.name}.get${field.name.capitalize()}($argString)")
if(scannedProperties) {
signatures.add("${baseType.name}.${field.name}")
}

return signatures
}

data class Search(val type: Class<*>, val resolverInfo: ResolverInfo, val source: Any?, val requiredFirstParameterType: Class<*>? = null)
}

class FieldResolverError(msg: String): RuntimeException(msg)
19 changes: 15 additions & 4 deletions src/main/kotlin/com/coxautodev/graphql/tools/GenericType.kt
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,7 @@ import java.util.concurrent.Future
/**
* @author Andrew Potter
*/
open class GenericType(protected val mostSpecificType: JavaType) {
open internal class GenericType(protected val mostSpecificType: JavaType) {

fun isTypeAssignableFromRawClass(type: ParameterizedType, clazz: Class<*>): Boolean {
return clazz.isAssignableFrom(getRawClass(type.rawType))
Expand All @@ -28,8 +28,19 @@ open class GenericType(protected val mostSpecificType: JavaType) {
return TypeUtils.isAssignable(type, mostSpecificType)
}

fun relativeTo(declaringClass: Class<*>) = relativeTo(getGenericSuperType(mostSpecificType, declaringClass) ?: error("Unable to find declaring type from class '${declaringClass.name}' relative to ${TypeUtils.toString(mostSpecificType)}"))
fun relativeTo(declaringType: JavaType) = RelativeTo(declaringType, mostSpecificType)
fun relativeToPotentialParent(declaringType: JavaType): RelativeTo {
if(declaringType !is Class<*>) {
return relativeToType(declaringType)
}

val type = getGenericSuperType(mostSpecificType, declaringType)
if(type == null) {
error("Unable to find generic type of class ${TypeUtils.toString(declaringType)} relative to ${TypeUtils.toString(mostSpecificType)}")
} else {
return relativeToType(type)
}
}
fun relativeToType(declaringType: JavaType) = RelativeTo(declaringType, mostSpecificType)

fun getGenericInterface(targetInterface: Class<*>) = getGenericInterface(mostSpecificType, targetInterface)

Expand Down Expand Up @@ -69,7 +80,7 @@ open class GenericType(protected val mostSpecificType: JavaType) {
return getGenericSuperType(raw.genericSuperclass, targetSuperClass)
}

class RelativeTo constructor(private val declaringType: JavaType, mostSpecificType: JavaType): GenericType(mostSpecificType) {
class RelativeTo (private val declaringType: JavaType, mostSpecificType: JavaType): GenericType(mostSpecificType) {

/**
* Unwrap certain Java types to find the "real" class.
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -3,9 +3,5 @@
/**
* @author Andrew Potter
*/
public interface GraphQLMutationResolver extends GraphQLRootResolver {
@Override
default String getResolverName() {
return RootTypeInfo.DEFAULT_MUTATION_NAME;
}
public interface GraphQLMutationResolver extends GraphQLResolver<Void> {
}
Original file line number Diff line number Diff line change
Expand Up @@ -3,9 +3,5 @@
/**
* @author Andrew Potter
*/
public interface GraphQLQueryResolver extends GraphQLRootResolver {
@Override
default String getResolverName() {
return RootTypeInfo.DEFAULT_QUERY_NAME;
}
public interface GraphQLQueryResolver extends GraphQLResolver<Void> {
}

This file was deleted.

Original file line number Diff line number Diff line change
@@ -1,8 +1,4 @@
package com.coxautodev.graphql.tools;

public interface GraphQLSubscriptionResolver extends GraphQLRootResolver {
@Override
default String getResolverName() {
return RootTypeInfo.DEFAULT_SUBSCRIPTION_NAME;
}
public interface GraphQLSubscriptionResolver extends GraphQLResolver<Void> {
}
116 changes: 116 additions & 0 deletions src/main/kotlin/com/coxautodev/graphql/tools/MethodFieldResolver.kt
Original file line number Diff line number Diff line change
@@ -0,0 +1,116 @@
package com.coxautodev.graphql.tools

import com.esotericsoftware.reflectasm.MethodAccess
import com.fasterxml.jackson.core.type.TypeReference
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
import com.fasterxml.jackson.module.kotlin.registerKotlinModule
import graphql.language.FieldDefinition
import graphql.language.NonNullType
import graphql.schema.DataFetcher
import graphql.schema.DataFetchingEnvironment
import java.lang.reflect.Method
import java.util.Optional

/**
* @author Andrew Potter
*/
internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, val method: Method): FieldResolver(field, search, method.declaringClass) {

val dataFetchingEnvironment = method.parameterCount == (field.inputValueDefinitions.size + getIndexOffset() + 1)

override fun createDataFetcher(): DataFetcher<*> {
val args = mutableListOf<ArgumentPlaceholder>()

// Add source argument if this is a resolver (but not a root resolver)
if(this.search.requiredFirstParameterType != null) {
val expectedType = this.search.requiredFirstParameterType

args.add({ environment ->
val source = environment.getSource<Any>()
if (!(expectedType.isAssignableFrom(source.javaClass))) {
throw ResolverError("Source type (${source.javaClass.name}) is not expected type (${expectedType.name})!")
}

source
})
}

// Add an argument for each argument defined in the GraphQL schema
this.field.inputValueDefinitions.forEachIndexed { index, definition ->

val genericParameterType = this.getJavaMethodParameterType(index) ?: throw ResolverError("Missing method type at position ${this.getJavaMethodParameterIndex(index)}, this is most likely a bug with graphql-java-tools")

val isNonNull = definition.type is NonNullType
val isOptional = this.genericType.getRawClass(genericParameterType) == Optional::class.java

val typeReference = object: TypeReference<Any>() {
override fun getType() = genericParameterType
}

args.add({ environment ->
val value = environment.arguments[definition.name] ?: if(isNonNull) {
throw ResolverError("Missing required argument with name '${definition.name}', this is most likely a bug with graphql-java-tools")
} else {
null
}

if(value == null && isOptional) {
return@add Optional.empty<Any>()
}

return@add MethodFieldResolverDataFetcher.mapper.convertValue(value, typeReference)
})
}

// Add DataFetchingEnvironment argument
if(this.dataFetchingEnvironment) {
args.add({ environment -> environment })
}

return MethodFieldResolverDataFetcher(getSourceResolver(), this.method, args)
}

override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, method.genericReturnType, genericType, SchemaClassScanner.ReturnValueReference(method))

return field.inputValueDefinitions.mapIndexed { i, inputDefinition ->
TypeClassMatcher.PotentialMatch.parameterType(inputDefinition.type, getJavaMethodParameterType(i)!!, genericType, SchemaClassScanner.MethodParameterReference(method, i))
} + listOf(returnValueMatch)
}

private fun getIndexOffset() = if(resolverInfo is NormalResolverInfo) 1 else 0
fun getJavaMethodParameterIndex(index: Int) = index + getIndexOffset()

fun getJavaMethodParameterType(index: Int): JavaType? {
val methodIndex = getJavaMethodParameterIndex(index)
val parameters = method.parameterTypes
if(parameters.size > methodIndex) {
return method.genericParameterTypes[getJavaMethodParameterIndex(index)]
} else {
return null
}
}

override fun toString() = "MethodFieldResolver{method=$method}"
}

class MethodFieldResolverDataFetcher(val sourceResolver: SourceResolver, method: Method, private val args: List<ArgumentPlaceholder>): DataFetcher<Any> {
companion object {
val mapper = ObjectMapper().registerModule(Jdk8Module()).registerKotlinModule()
}

// Convert to reflactasm reflection
private val methodAccess = MethodAccess.get(method.declaringClass)!!
private val methodIndex = methodAccess.getIndex(method.name, *method.parameterTypes)

override fun get(environment: DataFetchingEnvironment): Any? {
val source = sourceResolver(environment)
val args = this.args.map { it(environment) }.toTypedArray()
val result = methodAccess.invoke(source, methodIndex, *args)
return if(result != null && result is Optional<*>) result.orElse(null) else result
}
}

internal typealias ArgumentPlaceholder = (DataFetchingEnvironment) -> Any?

Original file line number Diff line number Diff line change
@@ -0,0 +1,27 @@
package com.coxautodev.graphql.tools

import graphql.language.FieldDefinition
import graphql.schema.DataFetcher
import graphql.schema.DataFetchingEnvironment
import java.lang.reflect.Field

/**
* @author Andrew Potter
*/
internal class PropertyFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, val property: Field): FieldResolver(field, search, property.declaringClass) {
override fun createDataFetcher(): DataFetcher<*> {
return PropertyFieldResolverDataFetcher(getSourceResolver(), property)
}

override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
return listOf(TypeClassMatcher.PotentialMatch.returnValue(field.type, property.genericType, genericType, SchemaClassScanner.FieldTypeReference(property)))
}

override fun toString() = "PropertyFieldResolver{property=$property}"
}

class PropertyFieldResolverDataFetcher(private val sourceResolver: SourceResolver, private val field: Field): DataFetcher<Any> {
override fun get(environment: DataFetchingEnvironment): Any {
return field.get(sourceResolver(environment))
}
}
Loading