[generator] Update additional types to work with input types (ExpediaGroup#817)

* Update additional types to work with input types

* Add more test coverage

* Update build.gradle.kts

* Move AdditionalType class to internal

* Remove 4.0.0 comments

Co-authored-by: Shane Myrick <[email protected]>

Author: smyrick

detekt.yml

@@ -10,7 +10,7 @@ comments:
 
 complexity:
   LongParameterList:
-    threshold: 10
+    functionThreshold: 10
     active: true
   TooManyFunctions:
     thresholdInInterfaces: 20

graphql-kotlin-federation/src/main/kotlin/com/expediagroup/graphql/federation/FederatedSchemaGenerator.kt

@@ -35,9 +35,10 @@ open class FederatedSchemaGenerator(generatorConfig: FederatedSchemaGeneratorCon
         queries: List<TopLevelObject>,
         mutations: List<TopLevelObject>,
         subscriptions: List<TopLevelObject>,
-        additionalTypes: Set<KType>
+        additionalTypes: Set<KType>,
+        additionalInputTypes: Set<KType>
     ): GraphQLSchema {
-        addAdditionalTypesWithAnnotation(ExtendsDirective::class)
-        return super.generateSchema(queries, mutations, subscriptions, additionalTypes)
+        addAdditionalTypesWithAnnotation(ExtendsDirective::class, inputType = false)
+        return super.generateSchema(queries, mutations, subscriptions, additionalTypes, additionalInputTypes)
     }
 }

graphql-kotlin-schema-generator/build.gradle.kts

@@ -23,7 +23,7 @@ tasks {
                 limit {
                     counter = "INSTRUCTION"
                     value = "COVEREDRATIO"
-                    minimum = "0.98".toBigDecimal()
+                    minimum = "0.95".toBigDecimal()
                 }
                 limit {
                     counter = "BRANCH"

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/SchemaGenerator.kt

@@ -19,6 +19,7 @@ package com.expediagroup.graphql.generator
 import com.expediagroup.graphql.SchemaGeneratorConfig
 import com.expediagroup.graphql.TopLevelObject
 import com.expediagroup.graphql.exceptions.InvalidPackagesException
+import com.expediagroup.graphql.generator.state.AdditionalType
 import com.expediagroup.graphql.generator.state.ClassScanner
 import com.expediagroup.graphql.generator.state.TypesCache
 import com.expediagroup.graphql.generator.types.generateGraphQLType
@@ -47,7 +48,7 @@ import kotlin.reflect.full.createType
 */
 open class SchemaGenerator(internal val config: SchemaGeneratorConfig) : Closeable {
 
-    internal val additionalTypes: MutableSet<KType> = mutableSetOf()
+    internal val additionalTypes: MutableSet<AdditionalType> = mutableSetOf()
     internal val classScanner = ClassScanner(config.supportedPackages)
     internal val cache = TypesCache(config.supportedPackages)
     internal val codeRegistry = GraphQLCodeRegistry.newCodeRegistry()
@@ -69,10 +70,13 @@ open class SchemaGenerator(internal val config: SchemaGeneratorConfig) : Closeab
         queries: List<TopLevelObject>,
         mutations: List<TopLevelObject> = emptyList(),
         subscriptions: List<TopLevelObject> = emptyList(),
-        additionalTypes: Set<KType> = emptySet()
+        additionalTypes: Set<KType> = emptySet(),
+        additionalInputTypes: Set<KType> = emptySet()
     ): GraphQLSchema {
 
-        this.additionalTypes.addAll(additionalTypes)
+        this.additionalTypes.addAll(additionalTypes.map { AdditionalType(it, inputType = false) })
+        this.additionalTypes.addAll(additionalInputTypes.map { AdditionalType(it, inputType = true) })
+
         val builder = GraphQLSchema.newSchema()
         builder.query(generateQueries(this, queries))
         builder.mutation(generateMutations(this, mutations))
@@ -94,14 +98,15 @@ open class SchemaGenerator(internal val config: SchemaGeneratorConfig) : Closeab
      *
      * This is helpful for things like federation or combining external schemas
      */
-    protected fun addAdditionalTypesWithAnnotation(annotation: KClass<*>) {
+    protected fun addAdditionalTypesWithAnnotation(annotation: KClass<*>, inputType: Boolean = false) {
         classScanner.getClassesWithAnnotation(annotation).forEach {
-            additionalTypes.add(it.createType())
+            additionalTypes.add(AdditionalType(it.createType(), inputType))
         }
     }
 
     /**
-     * Generate the GraphQL type for all the `additionalTypes`. They are generated as non-inputs and not as IDs.
+     * Generate the GraphQL type for all the `additionalTypes`.
+     *
      * If you need to provide more custom additional types that were not picked up from reflection of the schema objects,
      * you can provide more types to be added through [generateSchema].
      *
@@ -112,7 +117,7 @@ open class SchemaGenerator(internal val config: SchemaGeneratorConfig) : Closeab
         while (this.additionalTypes.isNotEmpty()) {
             val currentlyProcessedTypes = LinkedHashSet(this.additionalTypes)
             this.additionalTypes.clear()
-            graphqlTypes.addAll(currentlyProcessedTypes.map { generateGraphQLType(this, it) })
+            graphqlTypes.addAll(currentlyProcessedTypes.map { generateGraphQLType(this, it.kType, it.inputType) })
         }
 
         return graphqlTypes.toSet()

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/state/AdditionalType.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 Expedia, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.expediagroup.graphql.generator.state
+
+import kotlin.reflect.KType
+
+/**
+ * Used to represent the additional types to be included in the schema
+ * and that can also be picked up at generation time by including all the
+ * interface implementations that may not be used in the code.
+ */
+internal data class AdditionalType(
+    val kType: KType,
+    val inputType: Boolean = false
+)

graphql-kotlin-schema-generator/src/main/kotlin/com/expediagroup/graphql/generator/types/generateInterface.kt

@@ -16,6 +16,7 @@
 
 package com.expediagroup.graphql.generator.types
 
+import com.expediagroup.graphql.generator.state.AdditionalType
 import com.expediagroup.graphql.extensions.unwrapType
 import com.expediagroup.graphql.generator.SchemaGenerator
 import com.expediagroup.graphql.generator.extensions.getGraphQLDescription
@@ -58,7 +59,7 @@ internal fun generateInterface(generator: SchemaGenerator, kClass: KClass<*>): G
 
     generator.classScanner.getSubTypesOf(kClass)
         .filter { it.isGraphQLIgnored().not() }
-        .forEach { generator.additionalTypes.add(it.createType()) }
+        .forEach { generator.additionalTypes.add(AdditionalType(it.createType(), inputType = false)) }
 
     val interfaceType = builder.build()
     generator.codeRegistry.typeResolver(interfaceType) { env: TypeResolutionEnvironment -> env.schema.getObjectType(env.getObject<Any>().javaClass.kotlin.getSimpleName()) }

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/SchemaGeneratorTest.kt

@@ -39,6 +39,9 @@ class SchemaGeneratorTest {
         // Add a valid annotation
         generator.addTypes(MyCustomAnnotation::class)
         assertEquals(1, generator.additionalTypes.size)
+
+        generator.addInputTypes(MyCustomAnnotation::class)
+        assertEquals(2, generator.additionalTypes.size)
     }
 
     @Test
@@ -53,6 +56,18 @@ class SchemaGeneratorTest {
         assertEquals("SomeObjectWithAnnotation!", result.first().deepName)
     }
 
+    @Test
+    fun generateAdditionalInputTypes() {
+        val config = SchemaGeneratorConfig(listOf("com.expediagroup.graphql.generator"))
+        val generator = CustomSchemaGenerator(config)
+        generator.addInputTypes(MyCustomAnnotation::class)
+
+        val result = generator.generateCustomAdditionalTypes()
+
+        assertEquals(1, result.size)
+        assertEquals("SomeObjectWithAnnotationInput!", result.first().deepName)
+    }
+
     @Test
     fun invalidPackagesThrowsException() {
         assertFailsWith(InvalidPackagesException::class) {
@@ -64,6 +79,8 @@ class SchemaGeneratorTest {
     class CustomSchemaGenerator(config: SchemaGeneratorConfig) : SchemaGenerator(config) {
         internal fun addTypes(annotation: KClass<*>) = addAdditionalTypesWithAnnotation(annotation)
 
+        internal fun addInputTypes(annotation: KClass<*>) = addAdditionalTypesWithAnnotation(annotation, true)
+
         internal fun generateCustomAdditionalTypes() = generateAdditionalTypes()
     }
 

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/generator/types/GenerateInterfaceTest.kt

@@ -26,7 +26,7 @@ import kotlin.math.PI
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 
-internal class GenerateInterfaceTest : TypeTestHelper() {
+class GenerateInterfaceTest : TypeTestHelper() {
 
     @Test
     fun `Test naming`() {
@@ -59,8 +59,8 @@ internal class GenerateInterfaceTest : TypeTestHelper() {
         val result = generateInterface(generator, Shape::class) as? GraphQLInterfaceType
         assertEquals("Shape", result?.name)
         assertEquals(2, generator.additionalTypes.size)
-        assertNotNull(generator.additionalTypes.find { it.getSimpleName() == "Circle" })
-        assertNotNull(generator.additionalTypes.find { it.getSimpleName() == "Square" })
+        assertNotNull(generator.additionalTypes.find { it.kType.getSimpleName() == "Circle" })
+        assertNotNull(generator.additionalTypes.find { it.kType.getSimpleName() == "Square" })
     }
 
     @Test
@@ -69,8 +69,8 @@ internal class GenerateInterfaceTest : TypeTestHelper() {
         val result = generateInterface(generator, Pet::class) as? GraphQLInterfaceType
         assertEquals("Pet", result?.name)
         assertEquals(2, generator.additionalTypes.size)
-        assertNotNull(generator.additionalTypes.find { it.getSimpleName() == "Cat" })
-        assertNotNull(generator.additionalTypes.find { it.getSimpleName() == "Dog" })
+        assertNotNull(generator.additionalTypes.find { it.kType.getSimpleName() == "Cat" })
+        assertNotNull(generator.additionalTypes.find { it.kType.getSimpleName() == "Dog" })
     }
 
     @Suppress("Detekt.UnusedPrivateClass")

graphql-kotlin-schema-generator/src/test/kotlin/com/expediagroup/graphql/scalars/IDTest.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2020 Expedia, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.expediagroup.graphql.scalars
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class IDTest {
+
+    private val mapper = jacksonObjectMapper()
+
+    @Test
+    fun testToString() {
+        val id = ID("1")
+        assertEquals(expected = "1", actual = id.toString())
+    }
+
+    @Test
+    fun serialization() {
+        val id = ID("2")
+
+        val json = mapper.writeValueAsString(id)
+
+        assertEquals(expected = "\"2\"", actual = json)
+
+        val parsed: ID = mapper.readValue(json)
+
+        assertEquals(expected = "2", actual = parsed.value)
+    }
+}