Support mapping to record classes

Add support to DefaultInputObjectMapper to handle mapping to Java record classes.

graphql-dgs/src/main/kotlin/com/netflix/graphql/dgs/internal/DefaultInputObjectMapper.kt

@@ -30,6 +30,7 @@ import org.springframework.core.convert.converter.GenericConverter
 import org.springframework.core.convert.support.DefaultConversionService
 import org.springframework.util.CollectionUtils
 import org.springframework.util.ReflectionUtils
+import java.lang.reflect.Constructor
 import java.lang.reflect.Type
 import java.util.Optional
 import kotlin.reflect.KClass
@@ -142,6 +143,10 @@ class DefaultInputObjectMapper(customInputObjectMapper: InputObjectMapper? = nul
  return inputMap as T
  }
 
+ if (targetClass.isRecord) {
+ return handleRecordClass(inputMap, targetClass)
+ }
+
  val ctor = ReflectionUtils.accessibleConstructor(targetClass)
  val instance = ctor.newInstance()
  val setterAccessor = setterAccessor(instance)
@@ -175,6 +180,24 @@ class DefaultInputObjectMapper(customInputObjectMapper: InputObjectMapper? = nul
  return instance
  }
 
+ private fun <T> handleRecordClass(inputMap: Map<String, Any?>, targetClass: Class<T>): T {
+ val recordComponents = targetClass.recordComponents
+ val args = arrayOfNulls<Any?>(recordComponents.size)
+ for ((index, component) in recordComponents.withIndex()) {
+ if (component.name in inputMap) {
+ args[index] = maybeConvert(inputMap[component.name], component.genericType)
+ }
+ }
+ @Suppress("UNCHECKED_CAST")
+ val ctor = targetClass.declaredConstructors.first() as Constructor<T>
+ ctor.trySetAccessible()
+ try {
+ return ctor.newInstance(*args)
+ } catch (exc: ReflectiveOperationException) {
+ throw DgsInvalidInputArgumentException("Failed to construct record, class=${targetClass.simpleName}", exc)
+ }
+ }
+
  private fun <T> fieldAccessor(instance: T?): ConfigurablePropertyAccessor {
  val accessor = PropertyAccessorFactory.forDirectFieldAccess(instance as Any)
 

graphql-dgs/src/test/java/com/netflix/graphql/dgs/internal/java/test/inputobjects/RecordInput.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Netflix, 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
+ *
+ * http://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.netflix.graphql.dgs.internal.java.test.inputobjects;
+
+public record RecordInput(String foo, boolean bar, Integer baz) { }

graphql-dgs/src/test/kotlin/com/netflix/graphql/dgs/internal/InputObjectMapperTest.kt

@@ -24,6 +24,7 @@ import com.netflix.graphql.dgs.internal.java.test.inputobjects.JInputObjectWithK
 import com.netflix.graphql.dgs.internal.java.test.inputobjects.JInputObjectWithMap
 import com.netflix.graphql.dgs.internal.java.test.inputobjects.JInputObjectWithOptional
 import com.netflix.graphql.dgs.internal.java.test.inputobjects.JInputObjectWithSet
+import com.netflix.graphql.dgs.internal.java.test.inputobjects.RecordInput
 import org.assertj.core.api.Assertions.COLLECTION
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -274,11 +275,26 @@ internal class InputObjectMapperTest {
 
  @Test
  fun `mapping to a Kotlin class with a value class field works`() {
- val result = inputObjectMapper.mapToKotlinObject(mapOf("foo" to ValueClass("the-value"), "bar" to 12345), InputWithValueClass::class)
+ val result = inputObjectMapper.mapToKotlinObject(
+ mapOf("foo" to ValueClass("the-value"), "bar" to 12345),
+ InputWithValueClass::class
+ )
  assertThat(result.foo).isEqualTo(ValueClass("the-value"))
  assertThat(result.bar).isEqualTo(12345)
  }
 
+ @Test
+ fun `The mapper supports mapping to records`() {
+ val result = inputObjectMapper.mapToJavaObject(mapOf("foo" to "foo-value", "bar" to true, "baz" to 12345), RecordInput::class.java)
+ assertThat(result).isEqualTo(RecordInput("foo-value", true, 12345))
+ }
+
+ @Test
+ fun `The mapper supports mapping to classes with record fields`() {
+ val result = inputObjectMapper.mapToKotlinObject(mapOf("record" to mapOf("foo" to "foo-value", "bar" to true, "baz" to 12345)), KotlinClassWithRecord::class)
+ assertThat(result).isEqualTo(KotlinClassWithRecord(record = RecordInput("foo-value", true, 12345)))
+ }
+
  data class KotlinInputObject(val simpleString: String?, val someDate: LocalDateTime, val someObject: KotlinSomeObject)
  data class KotlinNestedInputObject(val input: KotlinInputObject)
  data class KotlinDoubleNestedInputObject(val inputL1: KotlinNestedInputObject)
@@ -298,4 +314,6 @@ internal class InputObjectMapperTest {
 
  @JvmInline
  value class ValueClass(val value: String)
+
+ data class KotlinClassWithRecord(val record: RecordInput)
 }