Wrap long constructor parameters

vojtapol · vojtapol · commit 14afd845af88 · 2020-04-16T22:49:37.000-04:00
diff --git a/src/main/kotlin/graphql/kickstart/tools/CoroutineContextProvider.kt b/src/main/kotlin/graphql/kickstart/tools/CoroutineContextProvider.kt
@@ -3,5 +3,6 @@ package graphql.kickstart.tools
 import kotlin.coroutines.CoroutineContext
 
 interface CoroutineContextProvider {
-    fun provide(): CoroutineContext?
+
+    fun provide(): CoroutineContext
 }
diff --git a/src/main/kotlin/graphql/kickstart/tools/DirectiveBehavior.kt b/src/main/kotlin/graphql/kickstart/tools/DirectiveBehavior.kt
@@ -5,8 +5,7 @@ import graphql.schema.*
 import graphql.schema.idl.RuntimeWiring
 
 /**
- * Directive behavior is used to wire up directives during schema parsing. Unfortunately, SchemaGeneratorDirectiveHelper
- * which contains the logic has package-private access to some members and must be therefore accessed via reflection.
+ * Directive behavior is used to wire up directives during schema parsing.
  */
 class DirectiveBehavior {
 
diff --git a/src/main/kotlin/graphql/kickstart/tools/FieldResolver.kt b/src/main/kotlin/graphql/kickstart/tools/FieldResolver.kt
@@ -8,7 +8,12 @@ import graphql.schema.DataFetchingEnvironment
 /**
  * @author Andrew Potter
  */
-internal abstract class FieldResolver(val field: FieldDefinition, val search: FieldResolverScanner.Search, val options: SchemaParserOptions, relativeTo: JavaType) {
+internal abstract class FieldResolver(
+    val field: FieldDefinition,
+    val search: FieldResolverScanner.Search,
+    val options: SchemaParserOptions,
+    relativeTo: JavaType
+) {
     val resolverInfo: ResolverInfo = search.resolverInfo
     val genericType = GenericType(search.type, options).relativeToPotentialParent(relativeTo)
 
diff --git a/src/main/kotlin/graphql/kickstart/tools/FieldResolverScanner.kt b/src/main/kotlin/graphql/kickstart/tools/FieldResolverScanner.kt
@@ -111,7 +111,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
 
     private fun verifyMethodArguments(method: java.lang.reflect.Method, requiredCount: Int, search: Search): Boolean {
         val appropriateFirstParameter = if (search.requiredFirstParameterType != null) {
-            if (MethodFieldResolver.Companion.isBatched(method, search)) {
+            if (MethodFieldResolver.isBatched(method, search)) {
                 verifyBatchedMethodFirstArgument(method.genericParameterTypes.firstOrNull(), search.requiredFirstParameterType)
             } else {
                 method.genericParameterTypes.firstOrNull()?.let {
@@ -156,7 +156,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {
             return false
         }
 
-        if (!TypeClassMatcher.Companion.isListType(firstType, GenericType(firstType, options))) {
+        if (!TypeClassMatcher.isListType(firstType, GenericType(firstType, options))) {
             return false
         }
 
diff --git a/src/main/kotlin/graphql/kickstart/tools/GraphQLMutationResolver.kt b/src/main/kotlin/graphql/kickstart/tools/GraphQLMutationResolver.kt
@@ -3,4 +3,4 @@ package graphql.kickstart.tools
 /**
  * @author Andrew Potter
  */
-interface GraphQLMutationResolver : GraphQLResolver<Void?> 
+interface GraphQLMutationResolver : GraphQLResolver<Void>
diff --git a/src/main/kotlin/graphql/kickstart/tools/GraphQLQueryResolver.kt b/src/main/kotlin/graphql/kickstart/tools/GraphQLQueryResolver.kt
@@ -3,4 +3,4 @@ package graphql.kickstart.tools
 /**
  * @author Andrew Potter
  */
-interface GraphQLQueryResolver : GraphQLResolver<Void?> 
+interface GraphQLQueryResolver : GraphQLResolver<Void>
diff --git a/src/main/kotlin/graphql/kickstart/tools/GraphQLSubscriptionResolver.kt b/src/main/kotlin/graphql/kickstart/tools/GraphQLSubscriptionResolver.kt
@@ -1,3 +1,3 @@
 package graphql.kickstart.tools
 
-interface GraphQLSubscriptionResolver : GraphQLResolver<Void?> 
+interface GraphQLSubscriptionResolver : GraphQLResolver<Void>
diff --git a/src/main/kotlin/graphql/kickstart/tools/MethodFieldResolver.kt b/src/main/kotlin/graphql/kickstart/tools/MethodFieldResolver.kt
@@ -25,7 +25,12 @@ import kotlin.reflect.jvm.kotlinFunction
 /**
  * @author Andrew Potter
  */
-internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, options: SchemaParserOptions, val method: Method) : FieldResolver(field, search, options, search.type) {
+internal class MethodFieldResolver(
+    field: FieldDefinition,
+    search: FieldResolverScanner.Search,
+    options: SchemaParserOptions,
+    val method: Method
+) : FieldResolver(field, search, options, search.type) {
 
     companion object {
         fun isBatched(method: Method, search: FieldResolverScanner.Search): Boolean {
@@ -179,7 +184,12 @@ internal class MethodFieldResolver(field: FieldDefinition, search: FieldResolver
     override fun toString() = "MethodFieldResolver{method=$method}"
 }
 
-open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceResolver, method: Method, private val args: List<ArgumentPlaceholder>, private val options: SchemaParserOptions) : DataFetcher<Any> {
+open class MethodFieldResolverDataFetcher(
+    private val sourceResolver: SourceResolver,
+    method: Method,
+    private val args: List<ArgumentPlaceholder>,
+    private val options: SchemaParserOptions
+) : DataFetcher<Any> {
 
     private val resolverMethod = method
     private val isSuspendFunction = try {
@@ -220,18 +230,21 @@ open class MethodFieldResolverDataFetcher(private val sourceResolver: SourceReso
     }
 
     /**
-     * Function that return the object used to fetch the data
-     * It can be a DataFetcher or an entity
+     * Function that returns the object used to fetch the data.
+     * It can be a DataFetcher or an entity.
      */
     @Suppress("unused")
     open fun getWrappedFetchingObject(environment: DataFetchingEnvironment): Any {
         return sourceResolver(environment)
     }
 }
 
-open class TrivialMethodFieldResolverDataFetcher(sourceResolver: SourceResolver, method: Method, args: List<ArgumentPlaceholder>, options: SchemaParserOptions) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options), TrivialDataFetcher<Any> {
-
-}
+open class TrivialMethodFieldResolverDataFetcher(
+    sourceResolver: SourceResolver,
+    method: Method,
+    args: List<ArgumentPlaceholder>,
+    options: SchemaParserOptions
+) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options), TrivialDataFetcher<Any>
 
 private suspend inline fun invokeSuspend(target: Any, resolverMethod: Method, args: Array<Any?>): Any? {
     return suspendCoroutineUninterceptedOrReturn { continuation ->
@@ -256,7 +269,12 @@ private inline fun invoke(method: Method, instance: Any, args: Array<Any?>): Any
     }
 }
 
-class BatchedMethodFieldResolverDataFetcher(sourceResolver: SourceResolver, method: Method, args: List<ArgumentPlaceholder>, options: SchemaParserOptions) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options) {
+class BatchedMethodFieldResolverDataFetcher(
+    sourceResolver: SourceResolver,
+    method: Method,
+    args: List<ArgumentPlaceholder>,
+    options: SchemaParserOptions
+) : MethodFieldResolverDataFetcher(sourceResolver, method, args, options) {
     @Batched
     override fun get(environment: DataFetchingEnvironment) = super.get(environment)
 }
diff --git a/src/main/kotlin/graphql/kickstart/tools/ObjectMapperConfigurer.java b/src/main/kotlin/graphql/kickstart/tools/ObjectMapperConfigurer.java
@@ -0,0 +1,11 @@
+package graphql.kickstart.tools;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * @author Andrew Potter
+ */
+public interface ObjectMapperConfigurer {
+
+    void configure(ObjectMapper mapper, ObjectMapperConfigurerContext context);
+}
diff --git a/src/main/kotlin/graphql/kickstart/tools/ObjectMapperConfigurer.kt b/src/main/kotlin/graphql/kickstart/tools/ObjectMapperConfigurer.kt
diff --git a/src/main/kotlin/graphql/kickstart/tools/ParameterizedTypeImpl.java b/src/main/kotlin/graphql/kickstart/tools/ParameterizedTypeImpl.java
@@ -78,9 +78,7 @@ private void validateConstructorArguments() {
      * @return An instance of {@code ParameterizedType}
      * @throws MalformedParameterizedTypeException if the instantiation is invalid
      */
-    public static ParameterizedTypeImpl make(
-        Class<?> rawType, Type[] actualTypeArguments, Type ownerType
-    ) {
+    public static ParameterizedTypeImpl make(Class<?> rawType, Type[] actualTypeArguments, Type ownerType) {
         return new ParameterizedTypeImpl(rawType, actualTypeArguments, ownerType);
     }
 
diff --git a/src/main/kotlin/graphql/kickstart/tools/PerFieldConfiguringObjectMapperProvider.kt b/src/main/kotlin/graphql/kickstart/tools/PerFieldConfiguringObjectMapperProvider.kt
@@ -6,7 +6,8 @@ import com.fasterxml.jackson.module.kotlin.registerKotlinModule
 import graphql.language.FieldDefinition
 
 class PerFieldConfiguringObjectMapperProvider(
-    private val objectMapperConfigurer: ObjectMapperConfigurer = ObjectMapperConfigurer { _, _ -> }) : PerFieldObjectMapperProvider {
+    private val objectMapperConfigurer: ObjectMapperConfigurer = ObjectMapperConfigurer { _, _ -> }
+) : PerFieldObjectMapperProvider {
 
     override fun provide(fieldDefinition: FieldDefinition): ObjectMapper {
         return ObjectMapper().apply {
diff --git a/src/main/kotlin/graphql/kickstart/tools/PerFieldObjectMapperProvider.kt b/src/main/kotlin/graphql/kickstart/tools/PerFieldObjectMapperProvider.kt
@@ -5,5 +5,5 @@ import graphql.language.FieldDefinition
 
 interface PerFieldObjectMapperProvider {
 
-    fun provide(fieldDefinition: FieldDefinition?): ObjectMapper?
+    fun provide(fieldDefinition: FieldDefinition): ObjectMapper
 }
diff --git a/src/main/kotlin/graphql/kickstart/tools/PropertyFieldResolver.kt b/src/main/kotlin/graphql/kickstart/tools/PropertyFieldResolver.kt
@@ -8,7 +8,13 @@ import java.lang.reflect.Field
 /**
  * @author Andrew Potter
  */
-internal class PropertyFieldResolver(field: FieldDefinition, search: FieldResolverScanner.Search, options: SchemaParserOptions, val property: Field) : FieldResolver(field, search, options, property.declaringClass) {
+internal class PropertyFieldResolver(
+    field: FieldDefinition,
+    search: FieldResolverScanner.Search,
+    options: SchemaParserOptions,
+    val property: Field
+) : FieldResolver(field, search, options, property.declaringClass) {
+
     override fun createDataFetcher(): DataFetcher<*> {
         return PropertyFieldResolverDataFetcher(getSourceResolver(), property)
     }
@@ -26,7 +32,11 @@ internal class PropertyFieldResolver(field: FieldDefinition, search: FieldResolv
     override fun toString() = "PropertyFieldResolver{property=$property}"
 }
 
-class PropertyFieldResolverDataFetcher(private val sourceResolver: SourceResolver, private val field: Field) : DataFetcher<Any> {
+class PropertyFieldResolverDataFetcher(
+    private val sourceResolver: SourceResolver,
+    private val field: Field
+) : DataFetcher<Any> {
+
     override fun get(environment: DataFetchingEnvironment): Any? {
         return field.get(sourceResolver(environment))
     }
diff --git a/src/main/kotlin/graphql/kickstart/tools/PropertyMapResolver.kt b/src/main/kotlin/graphql/kickstart/tools/PropertyMapResolver.kt
@@ -11,20 +11,25 @@ import graphql.schema.DataFetchingEnvironment
  *
  * The PropertyMapResolver implements the Map (i.e. property map) specific portion of the logic within the GraphQL PropertyDataFetcher class.
  */
-internal class PropertyMapResolver(field: FieldDefinition, search: FieldResolverScanner.Search, options: SchemaParserOptions, relativeTo: JavaType) : FieldResolver(field, search, options, relativeTo) {
+internal class PropertyMapResolver(
+    field: FieldDefinition,
+    search: FieldResolverScanner.Search,
+    options: SchemaParserOptions,
+    relativeTo: JavaType
+) : FieldResolver(field, search, options, relativeTo) {
 
     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
+     * type.
      */
     fun getMapGenericType(mapClass: JavaType): JavaType {
         val resolvedType = TypeResolver().resolve(mapClass)
-
         val typeParameters = resolvedType.typeParametersFor(Map::class.java)
+
         return typeParameters.elementAtOrElse(1) { Object::class.java }
     }
 
@@ -39,7 +44,11 @@ internal class PropertyMapResolver(field: FieldDefinition, search: FieldResolver
     override fun toString() = "PropertyMapResolverDataFetcher{key=${field.name}}"
 }
 
-class PropertyMapResolverDataFetcher(private val sourceResolver: SourceResolver, val key: String) : DataFetcher<Any> {
+class PropertyMapResolverDataFetcher(
+    private val sourceResolver: SourceResolver,
+    val key: String
+) : DataFetcher<Any> {
+
     override fun get(environment: DataFetchingEnvironment): Any? {
         val resolvedSourceObject = sourceResolver(environment)
         if (resolvedSourceObject is Map<*, *>) {
diff --git a/src/main/kotlin/graphql/kickstart/tools/ResolverInfo.kt b/src/main/kotlin/graphql/kickstart/tools/ResolverInfo.kt
@@ -17,12 +17,15 @@ internal interface DataClassTypeResolverInfo {
     val dataClassType: Class<out Any>
 }
 
-internal class NormalResolverInfo(val resolver: GraphQLResolver<*>, private val options: SchemaParserOptions) : DataClassTypeResolverInfo, ResolverInfo() {
+internal class NormalResolverInfo(
+    val resolver: GraphQLResolver<*>,
+    options: SchemaParserOptions
+) : DataClassTypeResolverInfo, ResolverInfo() {
+
     val resolverType = getRealResolverClass(resolver, options)
     override val dataClassType = findDataClass()
 
     private fun findDataClass(): Class<out Any> {
-
         val type = TypeUtils.getTypeArguments(resolverType, GraphQLResolver::class.java)[GraphQLResolver::class.java.typeParameters[0]]
 
         if (type == null || type !is Class<*>) {
@@ -69,7 +72,10 @@ internal class MultiResolverInfo(val resolverInfoList: List<NormalResolverInfo>)
     }
 }
 
-internal class RootResolverInfo(val resolvers: List<GraphQLRootResolver>, private val options: SchemaParserOptions) : ResolverInfo() {
+internal class RootResolverInfo(
+    val resolvers: List<GraphQLRootResolver>,
+    private val options: SchemaParserOptions
+) : ResolverInfo() {
     override fun getFieldSearches() =
         resolvers.map { FieldResolverScanner.Search(getRealResolverClass(it, options), this, it) }
 }
diff --git a/src/main/kotlin/graphql/kickstart/tools/RootTypeInfo.kt b/src/main/kotlin/graphql/kickstart/tools/RootTypeInfo.kt
@@ -6,7 +6,11 @@ import graphql.language.TypeName
 /**
  * @author Andrew Potter
  */
-internal class RootTypeInfo private constructor(val queryType: TypeName?, val mutationType: TypeName?, val subscriptionType: TypeName?) {
+internal class RootTypeInfo private constructor(
+    val queryType: TypeName?,
+    val mutationType: TypeName?,
+    val subscriptionType: TypeName?
+) {
     companion object {
         const val DEFAULT_QUERY_NAME = "Query"
         const val DEFAULT_MUTATION_NAME = "Mutation"
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaClassScanner.kt
@@ -10,7 +10,13 @@ import java.lang.reflect.Method
 /**
  * @author Andrew Potter
  */
-internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, allDefinitions: List<Definition<*>>, resolvers: List<GraphQLResolver<*>>, private val scalars: CustomScalarMap, private val options: SchemaParserOptions) {
+internal class SchemaClassScanner(
+    initialDictionary: BiMap<String, Class<*>>,
+    allDefinitions: List<Definition<*>>,
+    resolvers: List<GraphQLResolver<*>>,
+    private val scalars: CustomScalarMap,
+    private val options: SchemaParserOptions
+) {
 
     companion object {
         val log = LoggerFactory.getLogger(SchemaClassScanner::class.java)!!
@@ -465,7 +471,14 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
         override fun getDescription() = "type of field $field"
     }
 
-    class RootTypesHolder(options: SchemaParserOptions, rootInfo: RootTypeInfo, definitionsByName: Map<String, TypeDefinition<*>>, queryResolvers: List<GraphQLQueryResolver>, mutationResolvers: List<GraphQLMutationResolver>, subscriptionResolvers: List<GraphQLSubscriptionResolver>) {
+    class RootTypesHolder(
+        options: SchemaParserOptions,
+        rootInfo: RootTypeInfo,
+        definitionsByName: Map<String, TypeDefinition<*>>,
+        queryResolvers: List<GraphQLQueryResolver>,
+        mutationResolvers: List<GraphQLMutationResolver>,
+        subscriptionResolvers: List<GraphQLSubscriptionResolver>
+    ) {
         private val queryName = rootInfo.getQueryName()
         private val mutationName = rootInfo.getMutationName()
         private val subscriptionName = rootInfo.getSubscriptionName()
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaObjects.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaObjects.kt
@@ -8,8 +8,13 @@ import graphql.schema.GraphQLType
 /**
  * @author Andrew Potter
  */
-data class SchemaObjects(val query: GraphQLObjectType, val mutation: GraphQLObjectType?, val subscription: GraphQLObjectType?, val dictionary: Set<GraphQLType>, val codeRegistryBuilder: GraphQLCodeRegistry.Builder) {
-
+data class SchemaObjects(
+    val query: GraphQLObjectType,
+    val mutation: GraphQLObjectType?,
+    val subscription: GraphQLObjectType?,
+    val dictionary: Set<GraphQLType>,
+    val codeRegistryBuilder: GraphQLCodeRegistry.Builder
+) {
     /**
      * Makes a GraphQLSchema with query, mutation and subscription.
      */
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt
@@ -18,8 +18,11 @@ import kotlin.reflect.KClass
  *
  * @author Andrew Potter
  */
-class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, private val options: SchemaParserOptions, private val runtimeWiring: RuntimeWiring) {
-
+class SchemaParser internal constructor(
+    scanResult: ScannedSchemaObjects,
+    private val options: SchemaParserOptions,
+    private val runtimeWiring: RuntimeWiring
+) {
     companion object {
         val log = LoggerFactory.getLogger(SchemaClassScanner::class.java)!!
         const val DEFAULT_DEPRECATION_MESSAGE = "No longer supported"
diff --git a/src/main/kotlin/graphql/kickstart/tools/SchemaParserBuilder.kt b/src/main/kotlin/graphql/kickstart/tools/SchemaParserBuilder.kt
@@ -425,12 +425,10 @@ data class SchemaParserOptions internal constructor(
         val transformer: (Any, DataFetchingEnvironment) -> Any? = { x, _ -> x },
         val schemaWrapper: (JavaType) -> JavaType = { x -> x }
     ) {
-
         constructor(type: Class<*>, index: Int) : this(type, index, { x, _ -> x })
         constructor(type: KClass<*>, index: Int) : this(type.java, index, { x, _ -> x })
 
         companion object {
-
             @Suppress("UNCHECKED_CAST")
             @JvmStatic
             fun <T> withTransformer(
diff --git a/src/main/kotlin/graphql/kickstart/tools/TypeDefinitionFactory.kt b/src/main/kotlin/graphql/kickstart/tools/TypeDefinitionFactory.kt
@@ -12,5 +12,5 @@ interface TypeDefinitionFactory {
      *
      * @return any new definitions that should be added
      */
-    fun create(existing: List<Definition<*>?>?): List<Definition<*>?>?
+    fun create(existing: List<Definition<*>>): List<Definition<*>>
 }

Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,6 @@ package graphql.kickstart.tools`
`3`	`3`	`import kotlin.coroutines.CoroutineContext`
`4`	`4`
`5`	`5`	`interface CoroutineContextProvider {`
`6`		`- fun provide(): CoroutineContext?`
	`6`	`+`
	`7`	`+ fun provide(): CoroutineContext`
`7`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {`
`111`	`111`
`112`	`112`	`private fun verifyMethodArguments(method: java.lang.reflect.Method, requiredCount: Int, search: Search): Boolean {`
`113`	`113`	`val appropriateFirstParameter = if (search.requiredFirstParameterType != null) {`
`114`		`- if (MethodFieldResolver.Companion.isBatched(method, search)) {`
	`114`	`+ if (MethodFieldResolver.isBatched(method, search)) {`
`115`	`115`	`verifyBatchedMethodFirstArgument(method.genericParameterTypes.firstOrNull(), search.requiredFirstParameterType)`
`116`	`116`	`} else {`
`117`	`117`	`method.genericParameterTypes.firstOrNull()?.let {`
`@@ -156,7 +156,7 @@ internal class FieldResolverScanner(val options: SchemaParserOptions) {`
`156`	`156`	`return false`
`157`	`157`	`}`
`158`	`158`
`159`		`- if (!TypeClassMatcher.Companion.isListType(firstType, GenericType(firstType, options))) {`
	`159`	`+ if (!TypeClassMatcher.isListType(firstType, GenericType(firstType, options))) {`
`160`	`160`	`return false`
`161`	`161`	`}`
`162`	`162`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`package graphql.kickstart.tools`
`2`	`2`
`3`		`-interface GraphQLSubscriptionResolver : GraphQLResolver<Void?>`
	`3`	`+interface GraphQLSubscriptionResolver : GraphQLResolver<Void>`