Fail instead of passing type and object ids for custom scalars without visible properties

Author: oryan-block

src/main/kotlin/graphql/kickstart/tools/resolver/ArgumentConverter.kt

@@ -1,6 +1,5 @@
 package graphql.kickstart.tools.resolver
 
-import com.fasterxml.jackson.annotation.ObjectIdGenerator
 import tools.jackson.core.JacksonException
 import tools.jackson.core.JsonGenerator
 import tools.jackson.core.JsonParser
@@ -56,7 +55,7 @@ internal class ArgumentConverter(private val mapper: ObjectMapper, type: Type) {
                 }
             } ?: throw e
             try {
-                readWithNativeTypeIds(embedded)
+                read(embedded)
             } catch (retryError: JacksonException) {
                 throw retryError.apply { addSuppressed(e) }
             }
@@ -84,9 +83,6 @@ internal class ArgumentConverter(private val mapper: ObjectMapper, type: Type) {
 
     private fun read(value: Any?): Any? = reader.readValue(bufferFailingOnEmptyBeans(value))
 
-    // append copies the empty buffer's support for native ids, so its parser reads the type ids embedded values are written with
-    private fun readWithNativeTypeIds(value: Any): Any? = reader.readValue(bufferFailingOnEmptyBeans(value).append(TokenBuffer(null, true)))
-
     private fun bufferFailingOnEmptyBeans(value: Any?): TokenBuffer = buffer(FailOnEmptyBeans(value))
 
     private fun buffer(value: Any?): TokenBuffer = writer.writeValueIntoBuffer(value).forceUseOfBigDecimal(useBigDecimalForFloats)
@@ -109,28 +105,12 @@ internal class ArgumentConverter(private val mapper: ObjectMapper, type: Type) {
             convertOnItsOwn(valueToConvert, targetType)
 
         // called for an embedded value read as a Map or JsonNode, e.g. a scalar without properties, which converts to {}
-        override fun handleUnexpectedToken(context: DeserializationContext, targetType: JavaType, t: JsonToken?, p: JsonParser, failureMsg: String?): Any? {
-            val value = p.embeddedValue() ?: return NOT_HANDLED
-            return bindAsObjectId(context, value, targetType) ?: convertOnItsOwn(value, targetType)
-        }
+        override fun handleUnexpectedToken(context: DeserializationContext, targetType: JavaType, t: JsonToken?, p: JsonParser, failureMsg: String?): Any? =
+            p.embeddedValue()?.let { convertOnItsOwn(it, targetType) } ?: NOT_HANDLED
 
         private fun JsonParser.embeddedValue(): Any? = if (hasToken(JsonToken.VALUE_EMBEDDED_OBJECT)) embeddedObject else null
 
         private fun convertOnItsOwn(value: Any, targetType: JavaType): Any? = mapper.readValue(buffer(value), targetType)
-
-        // the deserializer of a class with an object id reads an embedded value as the id of an object read before
-        private fun bindAsObjectId(context: DeserializationContext, value: Any, idType: JavaType): Any? {
-            val idReader = context.findRootValueDeserializer(context.constructType(value.javaClass)).getObjectIdReader(context)
-            if (idReader == null || idReader.idType != idType) {
-                return null
-            }
-            val generatorKey = idReader.generator.key(null)
-            val generator = context.getAttribute(generatorKey) as ObjectIdGenerator<*>?
-                ?: idReader.generator.newForSerialization(null).also { context.setAttribute(generatorKey, it) }
-            val id = generator.generateId(value)
-            context.findObjectId(id, idReader.generator, idReader.resolver).bindItem(context, value)
-            return id
-        }
     }
 
     // FAIL_ON_EMPTY_BEANS whatever the mapper says: a scalar class with no visible properties would otherwise be read back as
@@ -172,15 +152,11 @@ internal class ArgumentConverter(private val mapper: ObjectMapper, type: Type) {
 
     private class EmbeddedValue(private val value: Any) : JacksonSerializable {
         override fun serialize(gen: JsonGenerator, serializers: SerializationContext) {
-            val typeSerializer = serializers.findTypeSerializer(serializers.constructType(value.javaClass))
-            gen.writeTypeId(typeSerializer?.typeIdResolver?.idFromValue(serializers, value))
             gen.writeEmbeddedObject(value)
-            // a TokenBuffer gives the type id to every token after it until another one is written
-            gen.writeTypeId(null)
         }
 
         override fun serializeWithType(gen: JsonGenerator, serializers: SerializationContext, typeSer: TypeSerializer) {
-            serialize(gen, serializers)
+            gen.writeEmbeddedObject(value)
         }
     }
 }

src/test/kotlin/graphql/kickstart/tools/CustomScalarInputTest.kt

@@ -221,25 +221,36 @@ class CustomScalarInputTest {
     }
 
     @Test
-    fun `Kotlin custom scalars without visible properties are passed when written with a type or object id`() {
+    fun `Kotlin custom scalars without visible properties written with a type or object id are passed in ObjectNode arguments`() {
         val data = assertNoGraphQlErrors(graphQL(inputSchema)) {
             """
             query {
-                optionalTypedToken(token: "optional")
-                optionalWrappedToken(token: "optional")
-                optionalIdToken(token: "optional")
-                markedTokens(input: { typed: "input", wrapped: "input", id: "input", typedList: ["first", "second"] })
                 markedTokenNode(input: { typed: "node", wrapped: "node", id: "node" })
             }
             """
         }
 
-        assertEquals(data, mapOf(
-            "optionalTypedToken" to "optional",
-            "optionalWrappedToken" to "optional",
-            "optionalIdToken" to "optional",
-            "markedTokens" to "input input input [first, second]",
-            "markedTokenNode" to "node node node"))
+        assertEquals(data, mapOf("markedTokenNode" to "node node node"))
+    }
+
+    @Test
+    fun `Kotlin custom scalars without visible properties written with a type or object id fail rather than lose their value`() {
+        val result = graphQL(inputSchema).execute(
+            """
+            query {
+                optionalTypedToken(token: "optional")
+                optionalWrappedToken(token: "optional")
+                optionalIdToken(token: "optional")
+                typed: markedTokens(input: { typed: "input" })
+                wrapped: markedTokens(input: { wrapped: "input" })
+                id: markedTokens(input: { id: "input" })
+                typedList: markedTokens(input: { typedList: ["first", "second"] })
+            }
+            """)
+
+        assertEquals(
+            result.errors.map { it.path?.single() }.toSet(),
+            setOf("optionalTypedToken", "optionalWrappedToken", "optionalIdToken", "typed", "wrapped", "id", "typedList"))
     }
 
     @Test