Add support for @oneOf inputs

benchmarks/src/main/scala/caliban/json/JsonEncodingBenchmark.scala

@@ -1,9 +1,9 @@
 package caliban.json
 
 import caliban.Value._
-import caliban.interop.circe.json.GraphQLResponseCirce.{graphQLResponseEncoder => circeEncoder}
-import caliban.interop.zio.GraphQLResponseZioJson.{graphQLResponseEncoder => zioEncoder}
-import caliban.{GraphQLResponse, ResponseValue}
+import caliban.interop.circe.json.GraphQLResponseCirce.{ graphQLResponseEncoder => circeEncoder }
+import caliban.interop.zio.GraphQLResponseZioJson.{ graphQLResponseEncoder => zioEncoder }
+import caliban.{ GraphQLResponse, ResponseValue }
 import com.github.plokhotnyuk.jsoniter_scala.core._
 import org.openjdk.jmh.annotations._
 

build.sbt

@@ -753,7 +753,13 @@ lazy val enableMimaSettingsJVM =
     mimaFailOnProblem     := enforceMimaCompatibility,
     mimaPreviousArtifacts := previousStableVersion.value.map(organization.value %% moduleName.value % _).toSet,
     mimaBinaryIssueFilters ++= Seq(
-      ProblemFilters.exclude[IncompatibleMethTypeProblem]("caliban.execution.Executor#ReducedStepExecutor.makeQuery")
+      ProblemFilters.exclude[IncompatibleMethTypeProblem]("caliban.execution.Executor#ReducedStepExecutor.makeQuery"),
+      ProblemFilters.exclude[DirectMissingMethodProblem]("caliban.parsing.adt.Type.$init$"),
+      ProblemFilters.exclude[DirectMissingMethodProblem]("caliban.introspection.adt.__Type.*"),
+      ProblemFilters.exclude[DirectMissingMethodProblem]("caliban.introspection.adt.__InputValue.*"),
+      ProblemFilters.exclude[FinalMethodProblem]("caliban.parsing.adt.Type*"),
+      ProblemFilters.exclude[MissingTypesProblem]("caliban.introspection.adt.__Type$"),
+      ProblemFilters.exclude[MissingTypesProblem]("caliban.introspection.adt.__InputValue$")
     )
   )
 

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

@@ -3,10 +3,10 @@ package caliban.schema
 import caliban.CalibanError.ExecutionError
 import caliban.InputValue
 import caliban.Value._
-import caliban.schema.Annotations.GQLDefault
-import caliban.schema.Annotations.GQLName
+import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput }
 import magnolia1._
 
+import scala.collection.compat._
 import scala.language.experimental.macros
 
 trait CommonArgBuilderDerivation {
@@ -25,19 +25,44 @@ trait CommonArgBuilderDerivation {
     override def map[A, B](from: EitherExecutionError[A])(fn: A => B): EitherExecutionError[B] = from.map(fn)
   }
 
-  def join[T](ctx: CaseClass[ArgBuilder, T]): ArgBuilder[T] =
-    (input: InputValue) =>
+  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) =>
+        val label   = p.annotations.collectFirst { case GQLName(name) => name }.getOrElse(p.label)
+        val default = p.typeclass.buildMissing(p.annotations.collectFirst { case GQLDefault(v) => v })
+        arr(i) = (label, default)
+      }
+      arr
+    }
+
+    private val required = params.collect { case (label, default) if default.isLeft => label }
+
+    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 _                              => Left(ExecutionError("expected an input object"))
+      }
+
+    private[this] def fromFields(fields: Map[String, InputValue]): Either[ExecutionError, T] =
       ctx.constructMonadic { p =>
-        input match {
-          case InputValue.ObjectValue(fields) =>
-            val label   = p.annotations.collectFirst { case GQLName(name) => name }.getOrElse(p.label)
-            val default = p.annotations.collectFirst { case GQLDefault(v) => v }
-            fields.get(label).fold(p.typeclass.buildMissing(default))(p.typeclass.build)
-          case value                          => p.typeclass.build(value)
-        }
+        val idx              = p.index
+        val (label, default) = params(idx)
+        val field            = fields.getOrElse(label, null)
+        if (field ne null) p.typeclass.build(field) else default
       }
+  }
 
-  def split[T](ctx: SealedTrait[ArgBuilder, T]): ArgBuilder[T] = input =>
+  def split[T](ctx: SealedTrait[ArgBuilder, T]): ArgBuilder[T] =
+    if (ctx.annotations.contains(GQLOneOfInput())) makeOneOfBuilder(ctx)
+    else makeSumBuilder(ctx)
+
+  private def makeSumBuilder[T](ctx: SealedTrait[ArgBuilder, T]): ArgBuilder[T] = input =>
     (input match {
       case EnumValue(value)   => Some(value)
       case StringValue(value) => Some(value)
@@ -53,6 +78,26 @@ trait CommonArgBuilderDerivation {
         }
       case None        => Left(ExecutionError(s"Can't build a trait from input $input"))
     }
+
+  private def makeOneOfBuilder[A](ctx: SealedTrait[ArgBuilder, A]): ArgBuilder[A] = new ArgBuilder[A] {
+
+    private def inputError(input: InputValue) =
+      ExecutionError(s"Invalid oneOf input $input for trait ${ctx.typeName.short}")
+
+    override val partial: PartialFunction[InputValue, Either[ExecutionError, A]] = {
+      val xs = ctx.subtypes.map(_.typeclass).toList.asInstanceOf[List[ArgBuilder[A]]]
+
+      val checkSize: PartialFunction[InputValue, Either[ExecutionError, A]] = {
+        case InputValue.ObjectValue(f) if f.size != 1 =>
+          Left(ExecutionError("Exactly one key must be specified for oneOf inputs"))
+      }
+      xs.foldLeft(checkSize)(_ orElse _.partial)
+    }
+
+    def build(input: InputValue): Either[ExecutionError, A] =
+      partial.applyOrElse(input, (in: InputValue) => Left(inputError(in)))
+  }
+
 }
 
 trait ArgBuilderDerivation extends CommonArgBuilderDerivation {

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

@@ -1,8 +1,9 @@
 package caliban.schema
 
+import caliban.CalibanError.ValidationError
 import caliban.Value._
 import caliban.introspection.adt._
-import caliban.parsing.adt.Directive
+import caliban.parsing.adt.{ Directive, Directives }
 import caliban.schema.Annotations._
 import caliban.schema.Types._
 import magnolia1._
@@ -65,8 +66,8 @@ trait CommonSchemaDerivation[R] {
       if (_isValueType) {
         if (isScalarValueType(ctx)) makeScalar(getName(ctx), getDescription(ctx))
         else ctx.parameters.head.typeclass.toType_(isInput, isSubscription)
-      } else if (isInput)
-        makeInputObject(
+      } else if (isInput) {
+        lazy val tpe: __Type = makeInputObject(
           Some(ctx.annotations.collectFirst { case GQLInputName(suffix) => suffix }
             .getOrElse(customizeInputTypeName(getName(ctx)))),
           getDescription(ctx),
@@ -81,14 +82,16 @@ trait CommonSchemaDerivation[R] {
                 p.annotations.collectFirst { case GQLDefault(v) => v },
                 p.annotations.collectFirst { case GQLDeprecated(_) => () }.isDefined,
                 p.annotations.collectFirst { case GQLDeprecated(reason) => reason },
-                Some(p.annotations.collect { case GQLDirective(dir) => dir }.toList).filter(_.nonEmpty)
+                Some(p.annotations.collect { case GQLDirective(dir) => dir }.toList).filter(_.nonEmpty),
+                () => Some(tpe)
               )
             )
             .toList,
           Some(ctx.typeName.full),
           Some(getDirectives(ctx))
         )
-      else
+        tpe
+      } else
         makeObject(
           Some(getName(ctx)),
           getDescription(ctx),
@@ -172,11 +175,13 @@ trait CommonSchemaDerivation[R] {
         case _          => false
       }
 
-      if (isEnum && subtypes.nonEmpty && !isInterface && !isUnion)
+      val isOneOfInput = ctx.annotations.contains(GQLOneOfInput())
+
+      if (isEnum && subtypes.nonEmpty && !isInterface && !isUnion && !isOneOfInput) {
         makeEnum(
           Some(getName(ctx)),
           getDescription(ctx),
-          subtypes.collect { case (__Type(_, Some(name), description, _, _, _, _, _, _, _, _, _), annotations) =>
+          subtypes.collect { case (__Type(_, Some(name), description, _, _, _, _, _, _, _, _, _, _), annotations) =>
             __EnumValue(
               name,
               description,
@@ -188,7 +193,18 @@ trait CommonSchemaDerivation[R] {
           Some(ctx.typeName.full),
           Some(getDirectives(ctx.annotations))
         )
-      else if (!isInterface) {
+      } else if (isOneOfInput && isInput) {
+        makeInputObject(
+          Some(ctx.annotations.collectFirst { case GQLInputName(suffix) => suffix }
+            .getOrElse(customizeInputTypeName(getName(ctx)))),
+          getDescription(ctx),
+          ctx.subtypes.toList.flatMap { p =>
+            p.typeclass.toType_(isInput = true).allInputFields.map(_.nullable)
+          },
+          Some(ctx.typeName.full),
+          Some(List(Directive(Directives.OneOf)))
+        )
+      } else if (!isInterface) {
         containsEmptyUnionObjects = emptyUnionObjectIdxs.contains(true)
         makeUnion(
           Some(getName(ctx)),

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

@@ -2,7 +2,7 @@ package caliban.schema
 
 import caliban.CalibanError.ExecutionError
 import caliban.Value.*
-import caliban.schema.Annotations.{ GQLDefault, GQLName }
+import caliban.schema.Annotations.{ GQLDefault, GQLName, GQLOneOfInput }
 import caliban.schema.macros.Macros
 import caliban.{ CalibanError, InputValue }
 import magnolia1.Macro as MagnoliaMacro
@@ -53,10 +53,16 @@ trait CommonArgBuilderDerivation {
   inline def derived[A]: ArgBuilder[A] =
     inline summonInline[Mirror.Of[A]] match {
       case m: Mirror.SumOf[A] =>
-        makeSumArgBuilder[A](
-          recurseSum[A, m.MirroredElemLabels, m.MirroredElemTypes](),
-          constValue[m.MirroredLabel]
-        )
+        inline if (Macros.hasAnnotation[A, GQLOneOfInput]) {
+          makeOneOfBuilder[A](
+            recurseSum[A, m.MirroredElemLabels, m.MirroredElemTypes](),
+            constValue[m.MirroredLabel]
+          )
+        } else
+          makeSumArgBuilder[A](
+            recurseSum[A, m.MirroredElemLabels, m.MirroredElemTypes](),
+            constValue[m.MirroredLabel]
+          )
 
       case m: Mirror.ProductOf[A] =>
         makeProductArgBuilder(
@@ -68,11 +74,11 @@ trait CommonArgBuilderDerivation {
   private def makeSumArgBuilder[A](
     _subTypes: => List[(String, List[Any], ArgBuilder[Any])],
     traitLabel: String
-  ) = new ArgBuilder[A] {
+  ): ArgBuilder[A] = new ArgBuilder[A] {
     private lazy val subTypes = _subTypes
     private val emptyInput    = InputValue.ObjectValue(Map.empty)
 
-    def build(input: InputValue): Either[ExecutionError, A] =
+    final def build(input: InputValue): Either[ExecutionError, A] =
       input.match {
         case EnumValue(value)   => Right(value)
         case StringValue(value) => Right(value)
@@ -91,28 +97,69 @@ trait CommonArgBuilderDerivation {
       }
   }
 
+  private def makeOneOfBuilder[A](
+    _subTypes: => List[(String, List[Any], ArgBuilder[Any])],
+    traitLabel: String
+  ): ArgBuilder[A] = new ArgBuilder[A] {
+
+    override val partial: PartialFunction[InputValue, Either[ExecutionError, A]] = {
+      val xs = _subTypes.map(_._3).asInstanceOf[List[ArgBuilder[A]]]
+
+      val checkSize: PartialFunction[InputValue, Either[ExecutionError, A]] = {
+        case InputValue.ObjectValue(f) if f.size != 1 =>
+          Left(ExecutionError("Exactly one key must be specified for oneOf inputs"))
+      }
+      xs.foldLeft(checkSize)(_ orElse _.partial)
+    }
+
+    def build(input: InputValue): Either[ExecutionError, A] =
+      partial.applyOrElse(input, (in: InputValue) => Left(inputError(in)))
+
+    private def inputError(input: InputValue) =
+      ExecutionError(s"Invalid oneOf input $input for trait $traitLabel")
+  }
+
   private def makeProductArgBuilder[A](
     _fields: => List[(String, ArgBuilder[Any])],
     annotations: Map[String, List[Any]]
-  )(fromProduct: Product => A) = new ArgBuilder[A] {
-    private lazy val fields = _fields
+  )(fromProduct: Product => A): ArgBuilder[A] = new ArgBuilder[A] {
+
+    private val params = Array.from(_fields.map { (label, builder) =>
+      val labelList  = annotations.get(label)
+      val default    = builder.buildMissing(labelList.flatMap(_.collectFirst { case GQLDefault(v) => v }))
+      val finalLabel = labelList.flatMap(_.collectFirst { case GQLName(name) => name }).getOrElse(label)
+      (finalLabel, default, builder)
+    })
+
+    private val required = params.collect { case (label, default, _) if default.isLeft => label }
+
+    override private[schema] val partial: PartialFunction[InputValue, Either[ExecutionError, A]] = {
+      case InputValue.ObjectValue(fields) if required.forall(fields.contains) => fromFields(fields)
+    }
 
     def build(input: InputValue): Either[ExecutionError, A] =
-      fields.view.map { (label, builder) =>
-        input match {
-          case InputValue.ObjectValue(fields) =>
-            val labelList  = annotations.get(label)
-            def default    = labelList.flatMap(_.collectFirst { case GQLDefault(v) => v })
-            val finalLabel = labelList.flatMap(_.collectFirst { case GQLName(name) => name }).getOrElse(label)
-            fields.get(finalLabel).fold(builder.buildMissing(default))(builder.build)
-          case value                          => builder.build(value)
-        }
-      }.foldLeft[Either[ExecutionError, Tuple]](Right(EmptyTuple)) { case (acc, item) =>
-        item match {
-          case Right(value) => acc.map(_ :* value)
-          case Left(e)      => Left(e)
+      input match {
+        case InputValue.ObjectValue(fields) => fromFields(fields)
+        case _                              => Left(ExecutionError("expected an input object"))
+      }
+
+    private def fromFields(fields: Map[String, InputValue]): Either[ExecutionError, A] = {
+      var i          = 0
+      val l          = params.length
+      var acc: Tuple = EmptyTuple
+      while (i < l) {
+        val (label, default, builder) = params(i)
+        val field                     = fields.getOrElse(label, null)
+        val value                     = if (field ne null) builder.build(field) else default
+        value match {
+          case Right(v)    => acc :*= v
+          case e @ Left(_) => return e.asInstanceOf[Either[ExecutionError, A]]
         }
-      }.map(fromProduct)
+        i += 1
+      }
+      Right(fromProduct(acc))
+    }
+
   }
 }