TypeDefinitionFactory for dynamically adding type definitions

Author: oliemansm

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

@@ -8,6 +8,8 @@ import graphql.language.FieldDefinition
 import graphql.language.InputObjectTypeDefinition
 import graphql.language.InputValueDefinition
 import graphql.language.InterfaceTypeDefinition
+import graphql.language.ListType
+import graphql.language.NonNullType
 import graphql.language.ObjectTypeDefinition
 import graphql.language.ObjectTypeExtensionDefinition
 import graphql.language.ScalarTypeDefinition
@@ -17,7 +19,6 @@ import graphql.language.TypeName
 import graphql.language.UnionTypeDefinition
 import graphql.schema.GraphQLScalarType
 import graphql.schema.idl.ScalarInfo
-import graphql.schema.idl.SchemaDirectiveWiring
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Method
 
@@ -230,33 +231,51 @@ internal class SchemaClassScanner(initialDictionary: BiMap<String, Class<*>>, al
      */
     private fun scanQueueItemForPotentialMatches(item: QueueItem) {
         val resolverInfoList = this.resolverInfos.filter { it.dataClassType == item.clazz }
-        val resolverInfo: ResolverInfo? = if (resolverInfoList.size > 1) {
+        val resolverInfo: ResolverInfo = (if (resolverInfoList.size > 1) {
             MultiResolverInfo(resolverInfoList)
         } else {
             if (item.clazz.equals(Object::class.java)) {
                 getResolverInfoFromTypeDictionary(item.type.name)
             } else {
                 resolverInfosByDataClass[item.clazz] ?: DataClassResolverInfo(item.clazz)
             }
-        }
-        if (resolverInfo == null) {
-            throw throw SchemaClassScannerError("The GraphQL schema type '${item.type.name}' maps to a field of type java.lang.Object however there is no matching entry for this type in the type dictionary. You may need to add this type to the dictionary before building the schema.")
-        }
+        }) ?: throw throw SchemaClassScannerError("The GraphQL schema type '${item.type.name}' maps to a field of type java.lang.Object however there is no matching entry for this type in the type dictionary. You may need to add this type to the dictionary before building the schema.")
 
         scanResolverInfoForPotentialMatches(item.type, resolverInfo)
     }
 
     private fun scanResolverInfoForPotentialMatches(type: ObjectTypeDefinition, resolverInfo: ResolverInfo) {
         type.getExtendedFieldDefinitions(extensionDefinitions).forEach { field ->
+//            val searchField = applyDirective(field)
             val fieldResolver = fieldResolverScanner.findFieldResolver(field, resolverInfo)
 
             fieldResolversByType.getOrPut(type) { mutableMapOf() }[fieldResolver.field] = fieldResolver
+
             fieldResolver.scanForMatches().forEach { potentialMatch ->
-                handleFoundType(typeClassMatcher.match(potentialMatch))
+//                if (potentialMatch.graphQLType is TypeName && !definitionsByName.containsKey((potentialMatch.graphQLType.name))) {
+//                    val typeDefinition = ObjectTypeDefinition.newObjectTypeDefinition()
+//                            .name(potentialMatch.graphQLType.name)
+//                            .build()
+//                    handleFoundType(TypeClassMatcher.ValidMatch(typeDefinition, typeClassMatcher.toRealType(potentialMatch), potentialMatch.reference))
+//                } else {
+                    handleFoundType(typeClassMatcher.match(potentialMatch))
+//                }
             }
         }
     }
 
+//    private fun applyDirective(field: FieldDefinition): FieldDefinition {
+//        val connectionDirectives = field.directives.filter { it.name == "connection" }
+//        if (connectionDirectives.isNotEmpty()) {
+//            val directive = connectionDirectives.first()
+//            val originalType:TypeName = field.type as TypeName
+//            val wrappedField = field.deepCopy()
+//            wrappedField.type = TypeName(originalType.name + "Connection")
+//            return wrappedField
+//        }
+//        return field
+//    }
+
     private fun handleFoundType(match: TypeClassMatcher.Match) {
         when (match) {
             is TypeClassMatcher.ScalarMatch -> {

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

@@ -146,7 +146,6 @@ class SchemaParser internal constructor(scanResult: ScannedSchemaObjects, privat
             fieldDefinition.description
             builder.field { field ->
                 createField(field, fieldDefinition)
-                // todo: apply directives to the fieldDefinition to use to find dataFetcher we're really after
                 field.dataFetcher(fieldResolversByType[definition]?.get(fieldDefinition)?.createDataFetcher() ?: throw SchemaError("No resolver method found for object type '${definition.name}' and field '${fieldDefinition.name}', this is most likely a bug with graphql-java-tools"))
 
                 val wiredField = directiveGenerator.onField(field.build(), DirectiveBehavior.Params(runtimeWiring))

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

@@ -1,10 +1,17 @@
 package com.coxautodev.graphql.tools
 
+import com.coxautodev.graphql.tools.relay.RelayConnectionFactory
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.google.common.collect.BiMap
 import com.google.common.collect.HashBiMap
 import com.google.common.collect.Maps
+import graphql.language.Definition
 import graphql.language.Document
+import graphql.language.FieldDefinition
+import graphql.language.ListType
+import graphql.language.NonNullType
+import graphql.language.ObjectTypeDefinition
+import graphql.language.TypeName
 import graphql.parser.Parser
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLScalarType
@@ -149,7 +156,7 @@ class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictio
      * Scan for classes with the supplied schema and dictionary.  Used for testing.
      */
     private fun scan(): ScannedSchemaObjects {
-        val definitions = parseDefinitions()
+        val definitions = appendDynamicDefinitions(parseDefinitions())
         val customScalars = scalars.associateBy { it.name }
 
         return SchemaClassScanner(dictionary.getDictionary(), definitions, resolvers, customScalars, options)
@@ -158,6 +165,12 @@ class SchemaParserBuilder constructor(private val dictionary: SchemaParserDictio
 
     private fun parseDefinitions() = parseDocuments().flatMap { it.definitions }
 
+    private fun appendDynamicDefinitions(baseDefinitions: List<Definition<*>>): List<Definition<*>> {
+        val definitions = baseDefinitions.toMutableList()
+        options.typeDefinitionFactories.forEach { definitions.addAll(it.create(baseDefinitions)) }
+        return definitions.toList()
+    }
+
     private fun parseDocuments(): List<Document> {
         val parser = Parser()
         val documents = mutableListOf<Document>()
@@ -267,7 +280,8 @@ data class SchemaParserOptions internal constructor(
         val proxyHandlers: List<ProxyHandler>,
         val preferGraphQLResolver: Boolean,
         val introspectionEnabled: Boolean,
-        val coroutineContext: CoroutineContext
+        val coroutineContext: CoroutineContext,
+        val typeDefinitionFactories: List<TypeDefinitionFactory>
 ) {
     companion object {
         @JvmStatic
@@ -287,6 +301,7 @@ data class SchemaParserOptions internal constructor(
         private var preferGraphQLResolver = false
         private var introspectionEnabled = true
         private var coroutineContext: CoroutineContext? = null
+        private var typeDefinitionFactories: MutableList<TypeDefinitionFactory> = mutableListOf(RelayConnectionFactory())
 
         fun contextClass(contextClass: Class<*>) = this.apply {
             this.contextClass = contextClass
@@ -340,6 +355,10 @@ data class SchemaParserOptions internal constructor(
             this.coroutineContext = context
         }
 
+        fun typeDefinitionFactory(factory: TypeDefinitionFactory) = this.apply {
+            this.typeDefinitionFactories.add(factory)
+        }
+
         fun build(): SchemaParserOptions {
             val coroutineContext = coroutineContext ?: Dispatchers.Default
             val wrappers = if (useDefaultGenericWrappers) {
@@ -365,7 +384,7 @@ data class SchemaParserOptions internal constructor(
             }
 
             return SchemaParserOptions(contextClass, wrappers, allowUnimplementedResolvers, objectMapperProvider,
-                    proxyHandlers, preferGraphQLResolver, introspectionEnabled, coroutineContext)
+                    proxyHandlers, preferGraphQLResolver, introspectionEnabled, coroutineContext, typeDefinitionFactories)
         }
     }
 

src/main/kotlin/com/coxautodev/graphql/tools/TypeDefinitionFactory.java

@@ -0,0 +1,11 @@
+package com.coxautodev.graphql.tools;
+
+import graphql.language.Definition;
+
+import java.util.List;
+
+public interface TypeDefinitionFactory {
+
+    List<Definition<?>> create(final List<Definition<?>> existing);
+
+}

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

@@ -0,0 +1,77 @@
+package com.coxautodev.graphql.tools.relay
+
+import com.coxautodev.graphql.tools.TypeDefinitionFactory
+import graphql.language.Definition
+import graphql.language.Directive
+import graphql.language.FieldDefinition
+import graphql.language.ListType
+import graphql.language.NonNullType
+import graphql.language.ObjectTypeDefinition
+import graphql.language.StringValue
+import graphql.language.TypeDefinition
+import graphql.language.TypeName
+
+class RelayConnectionFactory : TypeDefinitionFactory {
+
+    override fun create(existing: List<Definition<*>>): List<Definition<*>> {
+        val definitions = mutableListOf<Definition<*>>()
+        val definitionsByName = existing.filterIsInstance<TypeDefinition<*>>()
+                .associateBy { it.name }
+                .toMutableMap()
+
+        findConnectionDirectives(existing)
+                .flatMap { createDefinitions(it) }
+                .forEach {
+                    if (!definitionsByName.containsKey(it.name)) {
+                        definitionsByName[it.name] = it
+                        definitions.add(it)
+                    }
+                }
+
+        if (!definitionsByName.containsKey("PageInfo")) {
+            definitions.add(createPageInfo())
+        }
+
+        return definitions
+    }
+
+    private fun findConnectionDirectives(definitions: List<Definition<*>>): List<Directive> {
+        return definitions.filterIsInstance<ObjectTypeDefinition>()
+                .flatMap { it.fieldDefinitions }
+                .flatMap { it.directives }
+                .filter { it.name == "connection" }
+    }
+
+    private fun createDefinitions(directive: Directive): List<ObjectTypeDefinition> {
+        val definitions = mutableListOf<ObjectTypeDefinition>()
+        definitions.add(createEdgeDefinition(directive.forTypeName()))
+        definitions.add(createConnectionDefinition(directive.forTypeName()))
+        return definitions.toList()
+    }
+
+    private fun createConnectionDefinition(type: String): ObjectTypeDefinition =
+            ObjectTypeDefinition.newObjectTypeDefinition()
+                    .name(type + "Connection")
+                    .fieldDefinition(FieldDefinition("edges", ListType(TypeName(type + "Edge"))))
+                    .fieldDefinition(FieldDefinition("pageInfo", TypeName("PageInfo")))
+                    .build()
+
+    private fun createEdgeDefinition(type: String): ObjectTypeDefinition =
+            ObjectTypeDefinition.newObjectTypeDefinition()
+                    .name(type + "Edge")
+                    .fieldDefinition(FieldDefinition("cursor", TypeName("String")))
+                    .fieldDefinition(FieldDefinition("node", TypeName(type)))
+                    .build()
+
+    private fun createPageInfo(): ObjectTypeDefinition =
+            ObjectTypeDefinition.newObjectTypeDefinition()
+                    .name("PageInfo")
+                    .fieldDefinition(FieldDefinition("hasPreviousPage", NonNullType(TypeName("Boolean"))))
+                    .fieldDefinition(FieldDefinition("hasNextPage", NonNullType(TypeName("Boolean"))))
+                    .build()
+
+    private fun Directive.forTypeName(): String {
+        return (this.getArgument("for").value as StringValue).value
+    }
+
+}

src/main/kotlin/graphql/schema/idl/DirectiveBehavior.kt

@@ -15,8 +15,8 @@ class DirectiveBehavior {
         return directiveHelper.onField(element, params.toParameters())
     }
 
-
     data class Params(val runtimeWiring: RuntimeWiring) {
         internal fun toParameters() = SchemaGeneratorDirectiveHelper.Parameters(null, runtimeWiring, null, null)
     }
+
 }

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

@@ -4,17 +4,30 @@
 import graphql.execution.AsyncExecutionStrategy;
 import graphql.schema.GraphQLSchema;
 import groovy.lang.Closure;
+import io.reactivex.Single;
+import io.reactivex.internal.operators.single.SingleJust;
 import org.junit.Test;
 
 import java.util.HashMap;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 
+import static io.reactivex.Maybe.just;
+
 public class ReactiveTest {
 
     @Test
     public void futureSucceeds() {
+        SchemaParserOptions options = SchemaParserOptions.newOptions()
+                .genericWrappers(
+                        new SchemaParserOptions.GenericWrapper(Single.class, 0),
+                        new SchemaParserOptions.GenericWrapper(SingleJust.class, 0)
+                )
+                .build();
         GraphQLSchema schema = SchemaParser.newParser().file("Reactive.graphqls")
                 .resolvers(new Query())
+                .options(options)
                 .build()
                 .makeExecutableSchema();
 
@@ -30,8 +43,12 @@ public String call() {
     }
 
     static class Query implements GraphQLQueryResolver {
-        Future<Organization> organization(int organizationid) {
-            return null;
+//        Single<Optional<Organization>> organization(int organizationid) {
+//            return Single.just(Optional.empty()); //CompletableFuture.completedFuture(null);
+//        }
+
+        Future<Optional<Organization>> organization(int organizationid) {
+            return CompletableFuture.completedFuture(Optional.of(new Organization()));
         }
     }
 

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

@@ -20,10 +20,14 @@ public class RelayConnectionTest {
 
     @Test
     public void compiles() {
+        SchemaParserOptions options = SchemaParserOptions.newOptions()
+
+                .build();
         GraphQLSchema schema = SchemaParser.newParser().file("RelayConnection.graphqls")
                 .resolvers(new QueryResolver())
                 .dictionary(User.class)
                 .directive("connection", new ConnectionDirective())
+                .options(options)
                 .build()
                 .makeExecutableSchema();
 
@@ -39,10 +43,15 @@ public String call() {
                 return  "query {\n" +
                         "   users {\n" +
                         "       edges {\n" +
+                        "           cursor\n" +
                         "           node {\n" +
                         "               id\n" +
                         "               name\n" +
                         "           }\n" +
+                        "       },\n" +
+                        "       pageInfo {\n" +
+                        "           hasPreviousPage,\n" +
+                        "           hasNextPage\n" +
                         "       }\n" +
                         "   }\n" +
                         "}";

src/test/resources/RelayConnection.graphqls

@@ -1,24 +1,8 @@
-directive @connection on FIELD_DEFINITION
-
 type Query {
-    users(first: Int, after: String): UserConnection @connection
-}
-
-type UserConnection {
-    edges: [UserEdge!]!
-    pageInfo: PageInfo!
-}
-
-type UserEdge {
-    cursor: String!
-    node: User!
+    users(first: Int, after: String): UserConnection @connection(for: "User")
 }
 
 type User {
     id: ID!
     name: String
 }
-
-type PageInfo {
-
-}