Fix ArgBuilder derivation for case classes containing only optional fields

core/src/main/scala-2/caliban/schema/ArgBuilderDerivation.scala

@@ -3,7 +3,7 @@ package caliban.schema
 import caliban.CalibanError.ExecutionError
 import caliban.InputValue
 import caliban.Value._
-import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput }
+import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput, GQLValueType }
 import magnolia1._
 
 import scala.collection.compat._
@@ -27,7 +27,6 @@ trait CommonArgBuilderDerivation {
   }
 
   def join[T](ctx: CaseClass[ArgBuilder, T]): ArgBuilder[T] = new ArgBuilder[T] {
-
     private val params = {
       val arr = Array.ofDim[(String, EitherExecutionError[Any])](ctx.parameters.length)
       ctx.parameters.zipWithIndex.foreach { case (p, i) =>
@@ -40,14 +39,18 @@ trait CommonArgBuilderDerivation {
 
     private val required = params.collect { case (label, default) if default.isLeft => label }
 
+    private val isValueType =
+      ctx.isValueClass || (ctx.annotations.exists(_.isInstanceOf[GQLValueType]) && params.length == 1)
+
     override private[schema] val partial: PartialFunction[InputValue, Either[ExecutionError, T]] = {
       case InputValue.ObjectValue(fields) if required.forall(fields.contains) => fromFields(fields)
     }
 
     def build(input: InputValue): Either[ExecutionError, T] =
       input match {
         case InputValue.ObjectValue(fields) => fromFields(fields)
-        case value                          => ctx.constructMonadic(p => p.typeclass.build(value))
+        case value if isValueType           => ctx.constructMonadic(p => p.typeclass.build(value))
+        case _                              => Left(ExecutionError("expected an input object"))
       }
 
     private[this] def fromFields(fields: Map[String, InputValue]): Either[ExecutionError, T] =

core/src/main/scala-3/caliban/schema/ArgBuilderDerivation.scala

@@ -3,7 +3,7 @@ package caliban.schema
 import caliban.CalibanError.ExecutionError
 import caliban.InputValue.{ ListValue, VariableValue }
 import caliban.Value.*
-import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput }
+import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput, GQLValueType }
 import caliban.schema.macros.Macros
 import caliban.{ CalibanError, InputValue }
 import magnolia1.Macro as MagnoliaMacro
@@ -70,10 +70,19 @@ trait CommonArgBuilderDerivation {
       case m: Mirror.ProductOf[A] =>
         makeProductArgBuilder(
           recurseProduct[A, m.MirroredElemLabels, m.MirroredElemTypes](),
-          MagnoliaMacro.paramAnns[A].toMap
+          MagnoliaMacro.paramAnns[A].toMap,
+          isValueType[A, m.MirroredElemLabels]
         )(m.fromProduct)
     }
 
+  transparent inline private def isValueType[A, Labels]: Boolean =
+    inline if (MagnoliaMacro.isValueClass[A]) true
+    else
+      inline erasedValue[Labels] match {
+        case _: Tuple1[?] => Macros.hasAnnotation[A, GQLValueType]
+        case _            => false
+      }
+
   private def makeSumArgBuilder[A](
     _subTypes: => List[(String, List[Any], ArgBuilder[Any])],
     traitLabel: String
@@ -124,7 +133,8 @@ trait CommonArgBuilderDerivation {
 
   private def makeProductArgBuilder[A](
     _fields: => List[(String, ArgBuilder[Any])],
-    annotations: Map[String, List[Any]]
+    annotations: Map[String, List[Any]],
+    isValueType: Boolean
   )(fromProduct: Product => A): ArgBuilder[A] = new ArgBuilder[A] {
 
     private val params = Array.from(_fields.map { (label, builder) =>
@@ -143,7 +153,8 @@ trait CommonArgBuilderDerivation {
     def build(input: InputValue): Either[ExecutionError, A] =
       input match {
         case InputValue.ObjectValue(fields) => fromFields(fields)
-        case value                          => fromValue(value)
+        case value if isValueType           => fromValue(value)
+        case _                              => Left(ExecutionError("expected an input object"))
       }
 
     private def fromFields(fields: Map[String, InputValue]): Either[ExecutionError, A] = {

core/src/test/scala/caliban/execution/ExecutionSpec.scala

@@ -1505,8 +1505,97 @@ object ExecutionSpec extends ZIOSpecDefault {
         ZIO.foldLeft(cases)(assertCompletes) { case (acc, (query, expected)) =>
           api.interpreter
             .flatMap(_.execute(query, variables = Map("args" -> ObjectValue(Map("intValue" -> IntValue(42))))))
-            .map(response => assertTrue(response.data.toString == expected))
+            .map(response => acc && assertTrue(response.data.toString == expected))
+        }
+      },
+      test("oneOf input with input object with all optional fields") {
+
+        case class AddPet(pet: Pet.Wrapper)
+        case class Queries(addPet: AddPet => Pet)
+
+        val api: GraphQL[Any] = graphQL(
+          RootResolver(
+            Queries(_.pet.pet)
+          )
+        )
+
+        val cases = List(
+          gqldoc("""{
+            addPet(pet: { cat: { name: "a" } }) {
+              __typename
+              ... on Cat { name }
+              ... on Dog { name }
+            }
+          }""") -> """{"addPet":{"__typename":"Cat","name":"a"}}""",
+          gqldoc("""{
+            addPet(pet: { dog: {} }) {
+              __typename
+              ... on Cat { name }
+              ... on Dog { name }
+            }
+          }""") -> """{"addPet":{"__typename":"Dog","name":null}}""",
+          gqldoc("""{
+            addPet(pet: { dog: { name: "b" } }) {
+              __typename
+              ... on Cat { name }
+              ... on Dog { name }
+            }
+          }""") -> """{"addPet":{"__typename":"Dog","name":"b"}}"""
+        )
+
+        ZIO.foldLeft(cases)(assertCompletes) { case (acc, (query, expected)) =>
+          api.interpreter
+            .flatMap(_.execute(query))
+            .map(response => acc && assertTrue(response.data.toString == expected))
         }
       }
     )
 }
+
+// needs to be outside for Scala 2
+sealed trait Pet
+object Pet { parent =>
+
+  @GQLOneOfInput
+  @GQLName("Pet")
+  sealed trait Wrapper {
+    def pet: Pet
+  }
+  object Wrapper       {
+    implicit val argBuilder: ArgBuilder[Wrapper] = ArgBuilder.gen
+    implicit val schema: Schema[Any, Wrapper]    = Schema.gen
+  }
+
+  case class Cat(name: Option[String], numberOfLives: Option[Int]) extends Pet
+  object Cat {
+    @GQLName("Cat")
+    case class Wrapper(cat: Cat) extends parent.Wrapper {
+      override val pet = cat
+    }
+    object Wrapper {
+      implicit val argBuilder: ArgBuilder[Wrapper] = ArgBuilder.gen
+      implicit val schema: Schema[Any, Wrapper]    = Schema.gen
+    }
+
+    implicit val argBuilder: ArgBuilder[Cat] = ArgBuilder.gen
+    implicit val schema: Schema[Any, Cat]    = Schema.gen
+  }
+
+  case class Dog(name: Option[String], wagsTail: Option[Boolean]) extends Pet
+  object Dog {
+    @GQLName("Dog")
+    case class Wrapper(dog: Dog) extends parent.Wrapper {
+      override val pet = dog
+    }
+    object Wrapper {
+      implicit val argBuilder: ArgBuilder[Wrapper] = ArgBuilder.gen
+      implicit val schema: Schema[Any, Wrapper]    = Schema.gen
+    }
+
+    implicit val argBuilder: ArgBuilder[Dog] = ArgBuilder.gen
+    implicit val schema: Schema[Any, Dog]    = Schema.gen
+  }
+
+  implicit val argBuilder: ArgBuilder[Pet] = ArgBuilder.gen
+  implicit val schema: Schema[Any, Pet]    = Schema.gen
+}

core/src/test/scala/caliban/schema/ArgBuilderSpec.scala

@@ -71,6 +71,16 @@ object ArgBuilderSpec extends ZIOSpecDefault {
         )
       )
     ),
+    suite("derived build")(
+      test("should fail when null is provided for case class with optional fields") {
+        case class Foo(value: Option[String])
+        val ab = ArgBuilder.gen[Foo]
+        assertTrue(
+          ab.build(NullValue).isLeft,
+          ab.build(ObjectValue(Map())).isRight
+        )
+      }
+    ),
     suite("buildMissing")(
       test("works with derived case class ArgBuilders") {
         sealed abstract class Nullable[+T]