Prevent the usage of interface as argument type (#35)

Author: gscheibel

src/main/kotlin/com/expedia/graphql/schema/exceptions/InvalidInputFieldTypeException.kt

@@ -0,0 +1,31 @@
+package com.expedia.graphql.schema.exceptions
+
+/**
+ * GraphQL Interfaces and Unions cannot be used as arguments.
+ * Specification reference: https://facebook.github.io/graphql/draft/#sec-Field-Arguments
+ *
+ * This specification is translated as following:
+ * the type of a function argument cannot be a java / kotlin interface.
+ *
+ * Example of invalid use cases:
+ *
+ * class InvalidQuery {
+ *      fun invalidInterfaceUsage (arg: AnInterface): String = arg.value
+ *
+ *      fun invalidUnionUsage (arg: UnionMarkup): Int = arg.property
+ * }
+ *
+ * interface AnInterface {
+ *    val value: String
+ * }
+ *
+ * data class AnImplementation (
+ *    override val value: String = "something"
+ * ) : AnInterface
+ *
+ *
+ * interface UnionMarkup
+ *
+ * data class PartOfUnion( val property: Int) : UnionMarkup
+ */
+class InvalidInputFieldTypeException: RuntimeException("Object field argument cannot be an interface or a union")

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

@@ -6,6 +6,7 @@ import com.expedia.graphql.schema.Parameter
 import com.expedia.graphql.schema.SchemaGeneratorConfig
 import com.expedia.graphql.schema.exceptions.ConflictingTypesException
 import com.expedia.graphql.schema.exceptions.CouldNotGetNameOfEnumException
+import com.expedia.graphql.schema.exceptions.InvalidInputFieldTypeException
 import com.expedia.graphql.schema.exceptions.TypeNotSupportedException
 import com.expedia.graphql.schema.extensions.directives
 import com.expedia.graphql.schema.extensions.getDeprecationReason
@@ -159,11 +160,14 @@ internal class SchemaGenerator(
         .deprecate(prop.getDeprecationReason())
         .build()
 
-    private fun argument(parameter: KParameter): GraphQLArgument = GraphQLArgument.newArgument()
-        .name(parameter.name)
-        .description(parameter.graphQLDescription() ?: parameter.type.graphQLDescription())
-        .type(graphQLTypeOf(parameter.type, true) as GraphQLInputType)
-        .build()
+    private fun argument(parameter: KParameter): GraphQLArgument {
+        throwIfInterfaceIsNotAuthorized(parameter)
+        return GraphQLArgument.newArgument()
+                .name(parameter.name)
+                .description(parameter.graphQLDescription() ?: parameter.type.graphQLDescription())
+                .type(graphQLTypeOf(parameter.type, true) as GraphQLInputType)
+                .build()
+    }
 
     private fun graphQLTypeOf(type: KType, inputType: Boolean = false): GraphQLType {
         val hookGraphQLType = config.hooks.willGenerateGraphQLType(type)
@@ -231,6 +235,11 @@ internal class SchemaGenerator(
         }
     }
 
+    @Throws(InvalidInputFieldTypeException::class)
+    private fun throwIfInterfaceIsNotAuthorized(parameter: KParameter) {
+        if(parameter.type.jvmErasure.java.isInterface) throw InvalidInputFieldTypeException()
+    }
+
     private fun enumType(kClass: KClass<*>): GraphQLEnumType {
         val enumKClass = @Suppress("UNCHECKED_CAST") (kClass as KClass<Enum<*>>)
         val builder = GraphQLEnumType.newEnum()

src/test/kotlin/com/expedia/graphql/schema/generator/PolymorphicTests.kt

@@ -1,6 +1,7 @@
 package com.expedia.graphql.schema.generator
 
 import com.expedia.graphql.TopLevelObjectDef
+import com.expedia.graphql.schema.exceptions.InvalidInputFieldTypeException
 import com.expedia.graphql.schema.testSchemaConfig
 import com.expedia.graphql.toSchema
 import graphql.schema.GraphQLUnionType
@@ -38,13 +39,31 @@ class PolymorphicTests {
         assertEquals(1, implementationType.interfaces.size)
         assertEquals(implementationType.interfaces.first(), interfaceType)
     }
+
+    @Test(expected = InvalidInputFieldTypeException::class)
+    fun `Interfaces cannot be used as input field types`() {
+        toSchema(listOf(TopLevelObjectDef(QueryWithUnAuthorizedInterfaceArgument())), config = testSchemaConfig)
+    }
+
+    @Test(expected = InvalidInputFieldTypeException::class)
+    fun `Union cannot be used as input field types`() {
+        toSchema(listOf(TopLevelObjectDef(QueryWithUnAuthorizedUnionArgument())), config = testSchemaConfig)
+    }
 }
 
 class QueryWithInterface {
     fun query(): AnInterface = AnImplementation()
     fun fromImplementation(): AnImplementation = AnImplementation()
 }
 
+class QueryWithUnAuthorizedInterfaceArgument {
+    fun notAllowed(arg: AnInterface): AnInterface = arg
+}
+
+class QueryWithUnAuthorizedUnionArgument {
+    fun notAllowed(body: BodyPart): BodyPart = body
+}
+
 interface AnInterface {
     val property: String
 }