Adding optional datafetcher predicate to run test on function parameters (#45)

* Adding optional datafetcher predicate to run test on function parameters

* Add more flexibility to the predicate

* Pass the data fetching environment for more flexibility

* Implement the data fetcher predicate to leverage Bean Validation via Spring.

* Moving ConstraintError instantiation to an extension fucntion

* Update javadoc and minor readability improvement

* Rephrase incorrect javadoc

* Remove unecessary nullability on the DataFetcherExecutionValidator's validator

Author: gscheibel

detekt_baseline.xml

@@ -13,5 +13,6 @@
     <ID>UnsafeCast:SchemaGeneratorAsyncTests.kt$SchemaGeneratorAsyncTests$schema.getObjectType("TopLevelQuery").getFieldDefinition("asynchronouslyDo").type as GraphQLNonNull</ID>
     <ID>UnsafeCast:SchemaGeneratorAsyncTests.kt$SchemaGeneratorAsyncTests$schema.getObjectType("TopLevelQuery").getFieldDefinition("asynchronouslyDoSingle").type as GraphQLNonNull</ID>
     <ID>UnsafeCast:SchemaGeneratorAsyncTests.kt$SchemaGeneratorAsyncTests$schema.getObjectType("TopLevelQuery").getFieldDefinition("maybe").type as GraphQLNonNull</ID>
+    <ID>ComplexInterface:SchemaGeneratorHooks.kt$SchemaGeneratorHooks</ID>
   </Whitelist>
 </SmellBaseline>

example/src/main/kotlin/com.expedia.graphql.sample/Application.kt

@@ -3,14 +3,18 @@ package com.expedia.graphql.sample
 import com.expedia.graphql.TopLevelObjectDef
 import com.expedia.graphql.sample.context.MyGraphQLContextBuilder
 import com.expedia.graphql.sample.dataFetchers.SpringDataFetcherFactory
+import com.expedia.graphql.sample.exceptions.CustomDataFetcherExceptionHandler
 import com.expedia.graphql.sample.extension.CustomSchemaGeneratorHooks
 import com.expedia.graphql.sample.mutation.Mutation
 import com.expedia.graphql.sample.query.Query
 import com.expedia.graphql.schema.SchemaGeneratorConfig
 import com.expedia.graphql.toSchema
 import com.fasterxml.jackson.module.kotlin.KotlinModule
+import graphql.execution.AsyncExecutionStrategy
 import graphql.schema.GraphQLSchema
 import graphql.schema.idl.SchemaPrinter
+import graphql.servlet.DefaultExecutionStrategyProvider
+import graphql.servlet.GraphQLErrorHandler
 import graphql.servlet.GraphQLInvocationInputFactory
 import graphql.servlet.GraphQLObjectMapper
 import graphql.servlet.GraphQLQueryInvoker
@@ -23,6 +27,7 @@ import org.springframework.boot.web.servlet.ServletRegistrationBean
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.ComponentScan
 import javax.servlet.http.HttpServlet
+import javax.validation.Validator
 
 @SpringBootApplication
 @ComponentScan("com.expedia.graphql")
@@ -31,9 +36,9 @@ class Application {
     private val logger = LoggerFactory.getLogger(Application::class.java)
 
     @Bean
-    fun schemaConfig(dataFetcherFactory: SpringDataFetcherFactory): SchemaGeneratorConfig = SchemaGeneratorConfig(
-            supportedPackages = "com.expedia",
-            hooks = CustomSchemaGeneratorHooks(),
+    fun schemaConfig(dataFetcherFactory: SpringDataFetcherFactory, validator: Validator): SchemaGeneratorConfig = SchemaGeneratorConfig(
+            supportedPackages = listOf("com.expedia"),
+            hooks = CustomSchemaGeneratorHooks(validator),
             dataFetcherFactory = dataFetcherFactory
     )
 
@@ -68,12 +73,19 @@ class Application {
             .build()
 
     @Bean
-    fun graphQLQueryInvoker(): GraphQLQueryInvoker = GraphQLQueryInvoker.newBuilder()
-            .build()
+    fun graphQLQueryInvoker(): GraphQLQueryInvoker {
+        val exceptionHandler = CustomDataFetcherExceptionHandler()
+        val executionStrategyProvider = DefaultExecutionStrategyProvider(AsyncExecutionStrategy(exceptionHandler))
+
+        return GraphQLQueryInvoker.newBuilder()
+                .withExecutionStrategyProvider(executionStrategyProvider)
+                .build()
+    }
 
     @Bean
     fun graphQLObjectMapper(): GraphQLObjectMapper = GraphQLObjectMapper.newBuilder()
             .withObjectMapperConfigurer(ObjectMapperConfigurer { it.registerModule(KotlinModule()) })
+            .withGraphQLErrorHandler( GraphQLErrorHandler { it })
             .build()
 
     @Bean

example/src/main/kotlin/com.expedia.graphql.sample/exceptions/CustomDataFetcherExceptionHandler.kt

@@ -0,0 +1,44 @@
+package com.expedia.graphql.sample.exceptions
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import graphql.ErrorType
+import graphql.ErrorType.ValidationError
+import graphql.ExceptionWhileDataFetching
+import graphql.GraphQLError
+import graphql.execution.DataFetcherExceptionHandler
+import graphql.execution.DataFetcherExceptionHandlerParameters
+import graphql.execution.ExecutionPath
+import graphql.language.SourceLocation
+import org.slf4j.LoggerFactory
+
+class CustomDataFetcherExceptionHandler : DataFetcherExceptionHandler {
+    private val log = LoggerFactory.getLogger(CustomDataFetcherExceptionHandler::class.java)
+
+    override fun accept(handlerParameters: DataFetcherExceptionHandlerParameters) {
+        val exception = handlerParameters.exception
+        val sourceLocation = handlerParameters.field.sourceLocation
+        val path = handlerParameters.path
+
+        val error: GraphQLError = when(exception) {
+            is ValidationException -> ValidationDataFetchingGraphQLError(exception.constraintErrors, path, exception, sourceLocation)
+            else -> ExceptionWhileDataFetching(path, exception, sourceLocation)
+        }
+
+        handlerParameters.executionContext.addError(error, path)
+        log.warn(error.message, exception)
+    }
+}
+
+@JsonIgnoreProperties("exception")
+class ValidationDataFetchingGraphQLError(
+        val constraintErrors: List<ConstraintError>,
+        path: ExecutionPath,
+        exception: Throwable,
+        sourceLocation: SourceLocation
+) : ExceptionWhileDataFetching(
+        path,
+        exception,
+        sourceLocation
+) {
+    override fun getErrorType(): ErrorType = ValidationError
+}

example/src/main/kotlin/com.expedia.graphql.sample/exceptions/ValidationException.kt

@@ -0,0 +1,13 @@
+package com.expedia.graphql.sample.exceptions
+
+import javax.validation.ConstraintViolation
+
+class ValidationException(val constraintErrors: List<ConstraintError>) : RuntimeException("Validation error")
+
+data class ConstraintError(val path: String, val message: String, val type: String)
+
+fun ConstraintViolation<*>.asConstraintError() = ConstraintError(
+    path = this.propertyPath.toString(),
+    message = this.message,
+    type = this.leafBean.toString()
+)

example/src/main/kotlin/com.expedia.graphql.sample/extension/CustomSchemaGeneratorHooks.kt

@@ -1,18 +1,21 @@
 package com.expedia.graphql.sample.extension
 
+import com.expedia.graphql.sample.validation.DataFetcherExecutionValidator
+import com.expedia.graphql.schema.hooks.DataFetcherExecutionPredicate
 import com.expedia.graphql.schema.hooks.NoopSchemaGeneratorHooks
 import graphql.language.StringValue
 import graphql.schema.Coercing
 import graphql.schema.GraphQLScalarType
 import graphql.schema.GraphQLType
 import java.util.UUID
+import javax.validation.Validator
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 
 /**
  * Schema generator hook that adds additional scalar types.
  */
-class CustomSchemaGeneratorHooks: NoopSchemaGeneratorHooks() {
+class CustomSchemaGeneratorHooks(validator: Validator) : NoopSchemaGeneratorHooks() {
 
     /**
      * Register additional GraphQL scalar types.
@@ -22,6 +25,7 @@ class CustomSchemaGeneratorHooks: NoopSchemaGeneratorHooks() {
         else -> null
     }
 
+    override val dataFetcherExecutionPredicate: DataFetcherExecutionPredicate? = DataFetcherExecutionValidator(validator)
 }
 
 internal val graphqlUUIDType = GraphQLScalarType("UUID",
@@ -42,4 +46,4 @@ private object UUIDCoercing : Coercing<UUID, String> {
     }
 
     override fun serialize(dataFetcherResult: Any?): String = dataFetcherResult.toString()
-}
+}

example/src/main/kotlin/com.expedia.graphql.sample/query/ValidatedQuery.kt

@@ -0,0 +1,15 @@
+package com.expedia.graphql.sample.query
+
+import org.springframework.stereotype.Component
+import javax.validation.Valid
+import javax.validation.constraints.Pattern
+
+@Component
+class ValidatedQuery : Query {
+    fun argumentWithValidation(@Valid arg: TypeWithPattern): String = arg.lowerCaseOnly
+}
+
+data class TypeWithPattern(
+        @field:Pattern(regexp = "[a-z]*")
+        val lowerCaseOnly: String
+)

example/src/main/kotlin/com.expedia.graphql.sample/validation/DataFetcherExecutionValidator.kt

@@ -0,0 +1,29 @@
+package com.expedia.graphql.sample.validation
+
+import com.expedia.graphql.sample.exceptions.ValidationException
+import com.expedia.graphql.sample.exceptions.asConstraintError
+import com.expedia.graphql.schema.Parameter
+import com.expedia.graphql.schema.hooks.DataFetcherExecutionPredicate
+import graphql.schema.DataFetchingEnvironment
+import javax.validation.ConstraintViolation
+import javax.validation.Valid
+import javax.validation.Validator
+
+class DataFetcherExecutionValidator(private val validator: Validator) : DataFetcherExecutionPredicate() {
+
+    override fun <T> evaluate(value: T, parameter: Parameter, argumentName: String, environment: DataFetchingEnvironment): Any {
+        val parameterAnnotated = parameter.annotations.any { it.annotationClass == Valid::class }
+        return if (parameterAnnotated) {
+            validator.validate(value)
+        } else {
+            emptySet()
+        }
+    }
+
+    override fun onFailure(evaluationResult: Any, parameter: Parameter, argumentName: String, environment: DataFetchingEnvironment): Nothing {
+        val violations = evaluationResult as Set<ConstraintViolation<*>>
+        throw ValidationException(violations.map { it.asConstraintError() })
+    }
+
+    override fun test(evaluationResult: Any): Boolean = evaluationResult is Set<*> && evaluationResult.isEmpty()
+}

src/main/kotlin/com/expedia/graphql/schema/KotlinDataFetcher.kt

@@ -1,6 +1,7 @@
 package com.expedia.graphql.schema
 
 import com.expedia.graphql.annotations.GraphQLContext
+import com.expedia.graphql.schema.hooks.DataFetcherExecutionPredicate
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
@@ -23,7 +24,8 @@ data class Parameter(val klazz: Class<*>, val annotations: List<Annotation>)
 class KotlinDataFetcher(
     private val target: Any?,
     private val fn: KFunction<*>,
-    private val args: Map<String, Parameter>
+    private val args: Map<String, Parameter>,
+    private val executionPredicate: DataFetcherExecutionPredicate?
 ) : DataFetcher<Any> {
 
     override fun get(environment: DataFetchingEnvironment): Any? {
@@ -38,7 +40,9 @@ class KotlinDataFetcher(
                 if (annotations.any { it.annotationClass == GraphQLContext::class }) {
                     environment.getContext()
                 } else {
-                    mapper.convertValue(environment.arguments[name], klazz)
+                    val value = mapper.convertValue(environment.arguments[name], klazz)
+
+                    executionPredicate?.execute(value = value, parameter = it.value, argumentName = name, environment = environment) ?: value
                 }
             }.toTypedArray())
         } else {

src/main/kotlin/com/expedia/graphql/schema/generator/SchemaGenerator.kt

@@ -143,7 +143,7 @@ internal class SchemaGenerator(
         }
 
         if (!abstract) {
-            val dataFetcher: DataFetcher<*> = KotlinDataFetcher(target, fn, args)
+            val dataFetcher: DataFetcher<*> = KotlinDataFetcher(target, fn, args, config.hooks.dataFetcherExecutionPredicate)
             val hookDataFetcher = config.hooks.didGenerateDataFetcher(fn, dataFetcher)
             builder.dataFetcher(hookDataFetcher)
         }

src/main/kotlin/com/expedia/graphql/schema/hooks/DataFetcherExecutionPredicate.kt

@@ -0,0 +1,73 @@
+package com.expedia.graphql.schema.hooks
+
+import com.expedia.graphql.schema.Parameter
+import graphql.schema.DataFetchingEnvironment
+
+/**
+ * Perform runtime evaluations of each parameter passed to any KotlinDataFetcher.
+ *
+ * The DataFetcherExecutionPredicate is declared globally for all the datafetchers instances and all the parameters.
+ * However a more precise logic (at the field level) is possible depending on the implement of `evaluate` and `test`
+ *
+ * The predicate logic is split into two parts (evaluate and test) so the result of the evaluation like a list of errors
+ * can be passed to the onFailure method and added to an exception
+ *
+ * Because the DataFetcherExecutionPredicate is global, it's not possible to have methods where the type is inferred.
+ *
+ * It's recommended to check the type of the different arguments.
+ */
+abstract class DataFetcherExecutionPredicate {
+
+    /**
+     * Perform the predicate logic by evaluating the argument and its value
+     * Then depending on the result either returning the value itself to continue the datafetcher invocation
+     * or break the data fetching execution.
+     *
+     * @param parameter the function argument reference containing the KClass and the argument annotations
+     * @param argumentName the name of the argument as declared in the query / kotlin function
+     * @param environment the DataFetchingEnvironment in which the data fetcher is executed (gives access to field info, execution context etc)
+     * @param value the value to execute the predicate against.
+     */
+    fun <T> execute(value: T, parameter: Parameter, argumentName: String, environment: DataFetchingEnvironment): T {
+        val evaluationResult = evaluate(value, parameter, argumentName, environment)
+
+        return if (test(evaluationResult)) {
+            value
+        } else {
+            onFailure(evaluationResult, parameter, argumentName, environment)
+        }
+    }
+
+    /**
+     * Evaluate if the value passed respects some constraints.
+     *
+     * @param parameter the function argument reference containing the KClass and the argument annotations
+     * @param argumentName the name of the argument as declared in the query / kotlin function
+     * @param environment the DataFetchingEnvironment in which the data fetcher is executed (gives access to field info, execution context etc)
+     * @param value the value to execute the predicate against.
+     *
+     * @return the result of the evaluation eg: List of errors
+     */
+    abstract fun <T> evaluate(value: T, parameter: Parameter, argumentName: String, environment: DataFetchingEnvironment): Any
+
+    /**
+     * Assert that the result of the {@link #evaluate(T, Parameter, String, DataFetchingEnvironment)} method is as expected eg: the list of errors is empty
+     *
+     * @param evaluationResult the result of the evaluation
+     *
+     * @return whether the parameter passes the predicate
+     */
+    abstract fun test(evaluationResult: Any): Boolean
+
+    /**
+     * If the test is unsuccessful, this function will be invoked.
+     *
+     * An exception can then be thrown to block the data fetcher execution
+     *
+     * @param evaluationResult the object return by the `evaluate` function
+     * @param parameter the function argument reference containing the KClass and the argument annotations
+     * @param argumentName the name of the argument as declared in the query / kotlin function
+     * @param environment the DataFetchingEnvironment in which the data fetcher is executed (gives access to field info, execution context etc)
+     */
+    abstract fun onFailure(evaluationResult: Any, parameter: Parameter, argumentName: String, environment: DataFetchingEnvironment): Nothing
+}