Move scanning related internal classes to scanner package

Author: vojtapol

src/main/kotlin/graphql/kickstart/tools/DictionaryTypeResolver.kt

@@ -12,7 +12,10 @@ import graphql.schema.TypeResolver
 /**
  * @author Andrew Potter
  */
-abstract class DictionaryTypeResolver(private val dictionary: BiMap<JavaType, TypeDefinition<*>>, private val types: Map<String, GraphQLObjectType>) : TypeResolver {
+internal abstract class DictionaryTypeResolver(
+    private val dictionary: BiMap<JavaType, TypeDefinition<*>>,
+    private val types: Map<String, GraphQLObjectType>
+) : TypeResolver {
     private fun <T> getTypeName(clazz: Class<T>): String? {
         val name = dictionary[clazz]?.name
 
@@ -35,12 +38,26 @@ abstract class DictionaryTypeResolver(private val dictionary: BiMap<JavaType, Ty
     abstract fun getError(name: String): String
 }
 
-class InterfaceTypeResolver(dictionary: BiMap<JavaType, TypeDefinition<*>>, private val thisInterface: GraphQLInterfaceType, types: List<GraphQLObjectType>) : DictionaryTypeResolver(dictionary, types.filter { it.interfaces.any { it.name == thisInterface.name } }.associateBy { it.name }) {
+internal class InterfaceTypeResolver(
+    dictionary: BiMap<JavaType, TypeDefinition<*>>,
+    private val thisInterface: GraphQLInterfaceType,
+    types: List<GraphQLObjectType>
+) : DictionaryTypeResolver(
+    dictionary,
+    types.filter { it.interfaces.any { it.name == thisInterface.name } }.associateBy { it.name }
+) {
     override fun getError(name: String) = "Expected object type with name '$name' to implement interface '${thisInterface.name}', but it doesn't!"
 }
 
-class UnionTypeResolver(dictionary: BiMap<JavaType, TypeDefinition<*>>, private val thisUnion: GraphQLUnionType, types: List<GraphQLObjectType>) : DictionaryTypeResolver(dictionary, types.filter { type -> thisUnion.types.any { it.name == type.name } }.associateBy { it.name }) {
+internal class UnionTypeResolver(
+    dictionary: BiMap<JavaType, TypeDefinition<*>>,
+    private val thisUnion: GraphQLUnionType,
+    types: List<GraphQLObjectType>
+) : DictionaryTypeResolver(
+    dictionary,
+    types.filter { type -> thisUnion.types.any { it.name == type.name } }.associateBy { it.name }
+) {
     override fun getError(name: String) = "Expected object type with name '$name' to exist for union '${thisUnion.name}', but it doesn't!"
 }
 
-class TypeResolverError(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
+internal class TypeResolverError(message: String, cause: Throwable? = null) : RuntimeException(message, cause)

src/main/kotlin/graphql/kickstart/tools/SchemaObjects.kt

@@ -31,7 +31,6 @@ data class SchemaObjects(
     /**
      * Makes a GraphQLSchema with query but without mutation and subscription.
      */
-    @Suppress("unused")
     fun toReadOnlySchema(): GraphQLSchema = GraphQLSchema.newSchema()
         .query(query)
         .additionalTypes(dictionary)

src/main/kotlin/graphql/kickstart/tools/SchemaParser.kt

@@ -2,6 +2,8 @@ package graphql.kickstart.tools
 
 import graphql.introspection.Introspection
 import graphql.kickstart.tools.directive.SchemaGeneratorDirectiveHelper
+import graphql.kickstart.tools.scanner.ScannedSchemaObjects
+import graphql.kickstart.tools.scanner.SchemaClassScanner
 import graphql.kickstart.tools.util.getExtendedFieldDefinitions
 import graphql.kickstart.tools.util.unwrap
 import graphql.language.*
@@ -74,7 +76,7 @@ class SchemaParser internal constructor(
             codeRegistryBuilder.fieldVisibility(NoIntrospectionGraphqlFieldVisibility.NO_INTROSPECTION_FIELD_VISIBILITY)
         }
         // this overrides the above introspection enabled setting obviously... todo: add documentation
-        options.fieldVisilibity?.let { codeRegistryBuilder.fieldVisibility(it) }
+        options.fieldVisibility?.let { codeRegistryBuilder.fieldVisibility(it) }
 
         // Create GraphQL objects
         val inputObjects: MutableList<GraphQLInputObjectType> = mutableListOf()

src/main/kotlin/graphql/kickstart/tools/SchemaParserBuilder.kt

@@ -1,37 +1,23 @@
 package graphql.kickstart.tools
 
-import com.fasterxml.jackson.databind.ObjectMapper
-import graphql.kickstart.tools.proxy.*
-import graphql.kickstart.tools.relay.RelayConnectionFactory
-import graphql.kickstart.tools.util.BiMap
-import graphql.kickstart.tools.util.JavaType
-import graphql.kickstart.tools.util.coroutineScope
+import graphql.kickstart.tools.scanner.ScannedSchemaObjects
+import graphql.kickstart.tools.scanner.SchemaClassScanner
 import graphql.language.Definition
 import graphql.language.Document
 import graphql.parser.Parser
-import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaDirectiveWiring
-import graphql.schema.visibility.GraphqlFieldVisibility
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.reactive.publish
 import org.antlr.v4.runtime.RecognitionException
 import org.antlr.v4.runtime.misc.ParseCancellationException
-import org.reactivestreams.Publisher
-import java.util.concurrent.CompletableFuture
-import java.util.concurrent.CompletionStage
-import java.util.concurrent.Future
-import kotlin.coroutines.CoroutineContext
 import kotlin.reflect.KClass
 
 /**
  * @author Andrew Potter
  */
-class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictionary = SchemaParserDictionary()) {
+class SchemaParserBuilder {
 
+    private val dictionary = SchemaParserDictionary()
     private val schemaString = StringBuilder()
     private val files = mutableListOf<String>()
     private val resolvers = mutableListOf<GraphQLResolver<*>>()
@@ -215,280 +201,3 @@ class InvalidSchemaError(pce: ParseCancellationException, private val recognitio
     override val message: String?
         get() = "Invalid schema provided (${recognitionException.javaClass.name}) at: ${recognitionException.offendingToken}"
 }
-
-class SchemaParserDictionary {
-
-    private val dictionary: BiMap<String, Class<*>> = BiMap.create()
-
-    fun getDictionary(): BiMap<String, Class<*>> = BiMap.unmodifiableBiMap(dictionary)
-
-    /**
-     * Add arbitrary classes to the parser's dictionary, overriding the generated type name.
-     */
-    fun add(name: String, clazz: Class<*>) = this.apply {
-        this.dictionary.put(name, clazz)
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary, overriding the generated type name.
-     */
-    fun add(name: String, clazz: KClass<*>) = this.apply {
-        this.dictionary.put(name, clazz.java)
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary, overriding the generated type name.
-     */
-    fun add(dictionary: Map<String, Class<*>>) = this.apply {
-        this.dictionary.putAll(dictionary)
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary.
-     */
-    fun add(clazz: Class<*>) = this.apply {
-        this.add(clazz.simpleName, clazz)
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary.
-     */
-    fun add(clazz: KClass<*>) = this.apply {
-        this.add(clazz.java.simpleName, clazz)
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary.
-     */
-    fun add(vararg dictionary: Class<*>) = this.apply {
-        dictionary.forEach { this.add(it) }
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary.
-     */
-    fun add(vararg dictionary: KClass<*>) = this.apply {
-        dictionary.forEach { this.add(it) }
-    }
-
-    /**
-     * Add arbitrary classes to the parser's dictionary.
-     */
-    fun add(dictionary: Collection<Class<*>>) = this.apply {
-        dictionary.forEach { this.add(it) }
-    }
-}
-
-data class SchemaParserOptions internal constructor(
-    val contextClass: Class<*>?,
-    val genericWrappers: List<GenericWrapper>,
-    val allowUnimplementedResolvers: Boolean,
-    val objectMapperProvider: PerFieldObjectMapperProvider,
-    val proxyHandlers: List<ProxyHandler>,
-    val preferGraphQLResolver: Boolean,
-    val introspectionEnabled: Boolean,
-    val coroutineContextProvider: CoroutineContextProvider,
-    val typeDefinitionFactories: List<TypeDefinitionFactory>,
-    val fieldVisilibity: GraphqlFieldVisibility?
-) {
-    companion object {
-        @JvmStatic
-        fun newOptions() = Builder()
-
-        @JvmStatic
-        @ExperimentalCoroutinesApi
-        fun defaultOptions() = Builder().build()
-    }
-
-    val coroutineContext: CoroutineContext
-        get() = coroutineContextProvider.provide()
-
-    class Builder {
-        private var contextClass: Class<*>? = null
-        private val genericWrappers: MutableList<GenericWrapper> = mutableListOf()
-        private var useDefaultGenericWrappers = true
-        private var allowUnimplementedResolvers = false
-        private var objectMapperProvider: PerFieldObjectMapperProvider = PerFieldConfiguringObjectMapperProvider()
-        private val proxyHandlers: MutableList<ProxyHandler> = mutableListOf(Spring4AopProxyHandler(), GuiceAopProxyHandler(), JavassistProxyHandler(), WeldProxyHandler())
-        private var preferGraphQLResolver = false
-        private var introspectionEnabled = true
-        private var coroutineContextProvider: CoroutineContextProvider? = null
-        private var typeDefinitionFactories: MutableList<TypeDefinitionFactory> = mutableListOf(RelayConnectionFactory())
-        private var fieldVisibility: GraphqlFieldVisibility? = null
-
-        fun contextClass(contextClass: Class<*>) = this.apply {
-            this.contextClass = contextClass
-        }
-
-        fun contextClass(contextClass: KClass<*>) = this.apply {
-            this.contextClass = contextClass.java
-        }
-
-        fun genericWrappers(genericWrappers: List<GenericWrapper>) = this.apply {
-            this.genericWrappers.addAll(genericWrappers)
-        }
-
-        fun genericWrappers(vararg genericWrappers: GenericWrapper) = this.apply {
-            this.genericWrappers.addAll(genericWrappers)
-        }
-
-        fun useDefaultGenericWrappers(useDefaultGenericWrappers: Boolean) = this.apply {
-            this.useDefaultGenericWrappers = useDefaultGenericWrappers
-        }
-
-        fun allowUnimplementedResolvers(allowUnimplementedResolvers: Boolean) = this.apply {
-            this.allowUnimplementedResolvers = allowUnimplementedResolvers
-        }
-
-        fun preferGraphQLResolver(preferGraphQLResolver: Boolean) = this.apply {
-            this.preferGraphQLResolver = preferGraphQLResolver
-        }
-
-        fun objectMapperConfigurer(objectMapperConfigurer: ObjectMapperConfigurer) = this.apply {
-            this.objectMapperProvider = PerFieldConfiguringObjectMapperProvider(objectMapperConfigurer)
-        }
-
-        fun objectMapperProvider(objectMapperProvider: PerFieldObjectMapperProvider) = this.apply {
-            this.objectMapperProvider = objectMapperProvider
-        }
-
-        fun objectMapperConfigurer(objectMapperConfigurer: (ObjectMapper, ObjectMapperConfigurerContext) -> Unit) = this.apply {
-            this.objectMapperConfigurer(ObjectMapperConfigurer(objectMapperConfigurer))
-        }
-
-        fun addProxyHandler(proxyHandler: ProxyHandler) = this.apply {
-            this.proxyHandlers.add(proxyHandler)
-        }
-
-        fun introspectionEnabled(introspectionEnabled: Boolean) = this.apply {
-            this.introspectionEnabled = introspectionEnabled
-        }
-
-        fun coroutineContext(context: CoroutineContext) = this.apply {
-            this.coroutineContextProvider = DefaultCoroutineContextProvider(context)
-        }
-
-        fun coroutineContextProvider(contextProvider: CoroutineContextProvider) = this.apply {
-            this.coroutineContextProvider = contextProvider
-        }
-
-        fun typeDefinitionFactory(factory: TypeDefinitionFactory) = this.apply {
-            this.typeDefinitionFactories.add(factory)
-        }
-
-        fun fieldVisibility(fieldVisibility: GraphqlFieldVisibility) = this.apply {
-            this.fieldVisibility = fieldVisibility
-        }
-
-        @ExperimentalCoroutinesApi
-        fun build(): SchemaParserOptions {
-            val coroutineContextProvider = coroutineContextProvider
-                ?: DefaultCoroutineContextProvider(Dispatchers.Default)
-            val wrappers = if (useDefaultGenericWrappers) {
-                genericWrappers + listOf(
-                    GenericWrapper(Future::class, 0),
-                    GenericWrapper(CompletableFuture::class, 0),
-                    GenericWrapper(CompletionStage::class, 0),
-                    GenericWrapper(Publisher::class, 0),
-                    GenericWrapper.withTransformer(ReceiveChannel::class, 0, { receiveChannel, environment ->
-                        environment.coroutineScope().publish(coroutineContextProvider.provide()) {
-                            try {
-                                for (item in receiveChannel) {
-                                    send(item)
-                                }
-                            } finally {
-                                receiveChannel.cancel()
-                            }
-                        }
-                    })
-                )
-            } else {
-                genericWrappers
-            }
-
-            return SchemaParserOptions(contextClass, wrappers, allowUnimplementedResolvers, objectMapperProvider,
-                proxyHandlers, preferGraphQLResolver, introspectionEnabled, coroutineContextProvider,
-                typeDefinitionFactories, fieldVisibility
-            )
-        }
-    }
-
-    internal class DefaultCoroutineContextProvider(val coroutineContext: CoroutineContext) : CoroutineContextProvider {
-        override fun provide(): CoroutineContext {
-            return coroutineContext
-        }
-    }
-
-    data class GenericWrapper(
-        val type: Class<*>,
-        val index: Int,
-        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(
-                type: Class<T>,
-                index: Int,
-                transformer: (T, DataFetchingEnvironment) -> Any?,
-                schemaWrapper: (JavaType) -> JavaType = { x -> x }
-            ): GenericWrapper where T : Any {
-                return GenericWrapper(type, index, transformer as (Any, DataFetchingEnvironment) -> Any?, schemaWrapper)
-            }
-
-            fun <T> withTransformer(
-                type: KClass<T>,
-                index: Int,
-                transformer: (T, DataFetchingEnvironment) -> Any?,
-                schemaWrapper: (JavaType) -> JavaType = { x -> x }
-            ): GenericWrapper where T : Any {
-                return withTransformer(type.java, index, transformer, schemaWrapper)
-            }
-
-            @JvmStatic
-            fun <T> withTransformer(
-                type: Class<T>,
-                index: Int,
-                transformer: (T) -> Any?,
-                schemaWrapper: (JavaType) -> JavaType = { x -> x }
-            ): GenericWrapper where T : Any {
-                return withTransformer(type, index, { x, _ -> transformer.invoke(x) }, schemaWrapper)
-            }
-
-            fun <T> withTransformer(
-                type: KClass<T>,
-                index: Int,
-                transformer: (T) -> Any?,
-                schemaWrapper: (JavaType) -> JavaType = { x -> x }
-            ): GenericWrapper where T : Any {
-                return withTransformer(type.java, index, transformer, schemaWrapper)
-            }
-
-            @JvmStatic
-            fun <T> listCollectionWithTransformer(
-                type: Class<T>,
-                index: Int,
-                transformer: (T) -> Any?
-            ): GenericWrapper where T : Any {
-                return withTransformer(
-                    type,
-                    index,
-                    transformer,
-                    { innerType -> ParameterizedTypeImpl.make(List::class.java, arrayOf(innerType), null) }
-                )
-            }
-
-            fun <T> listCollectionWithTransformer(
-                type: KClass<T>,
-                index: Int,
-                transformer: (T) -> Any?
-            ): GenericWrapper where T : Any {
-                return listCollectionWithTransformer(type.java, index, transformer)
-            }
-        }
-    }
-}