Add support for @oneOf inputs

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

@@ -3,8 +3,7 @@ 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 magnolia._
 import mercator.Monadic
 
@@ -38,7 +37,11 @@ trait CommonArgBuilderDerivation {
         }
       }
 
-  def dispatch[T](ctx: SealedTrait[ArgBuilder, T]): ArgBuilder[T] = input =>
+  def dispatch[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)
@@ -54,6 +57,27 @@ 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}")
+
+      private val combined = ctx.subtypes.map(_.typeclass).toList.asInstanceOf[List[ArgBuilder[A]]] match {
+        case head :: tail =>
+          tail.foldLeft(head)(_ orElse _).orElse(input => Left(inputError(input)))
+        case _            =>
+          (_ => Left(ExecutionError("OneOf Input Objects must have at least one subtype"))): ArgBuilder[A]
+      }
+
+      def build(input: InputValue): Either[ExecutionError, A] = input match {
+        case InputValue.ObjectValue(f) if f.size == 1 => combined.build(input)
+        case InputValue.ObjectValue(_)                => Left(ExecutionError("Exactly one key must be specified for oneOf inputs"))
+        case _                                        => Left(inputError(input))
+      }
+    }
+
 }
 
 trait ArgBuilderDerivation extends CommonArgBuilderDerivation {

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

@@ -1,5 +1,6 @@
 package caliban.schema
 
+import caliban.CalibanError.ValidationError
 import caliban.Value._
 import caliban.introspection.adt._
 import caliban.parsing.adt.Directive
@@ -40,7 +41,7 @@ trait CommonSchemaDerivation[R] {
       if ((ctx.isValueClass || isValueType(ctx)) && ctx.parameters.nonEmpty) {
         if (isScalarValueType(ctx)) makeScalar(getName(ctx), getDescription(ctx))
         else ctx.parameters.head.typeclass.toType_(isInput, isSubscription)
-      } else if (isInput)
+      } else if (isInput) {
         makeInputObject(
           Some(ctx.annotations.collectFirst { case GQLInputName(suffix) => suffix }
             .getOrElse(customizeInputTypeName(getName(ctx)))),
@@ -54,14 +55,15 @@ trait CommonSchemaDerivation[R] {
                   if (p.typeclass.optional) p.typeclass.toType_(isInput, isSubscription)
                   else p.typeclass.toType_(isInput, isSubscription).nonNull,
                 p.annotations.collectFirst { case GQLDefault(v) => v },
-                Some(p.annotations.collect { case GQLDirective(dir) => dir }.toList).filter(_.nonEmpty)
+                Some(p.annotations.collect { case GQLDirective(dir) => dir }.toList).filter(_.nonEmpty),
+                Some(ctx.typeName.short)
               )
             )
             .toList,
           Some(ctx.typeName.full),
           Some(getDirectives(ctx))
         )
-      else
+      } else
         makeObject(
           Some(getName(ctx)),
           getDescription(ctx),
@@ -130,11 +132,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,
@@ -146,15 +150,27 @@ 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).inputFields.getOrElse(Nil).map(_.nullable)
+          },
+          Some(ctx.typeName.full),
+          Some(List(Directive("oneOf"))),
+          isOneOf = true
+        )
+      } else if (!isInterface) {
         makeUnion(
           Some(getName(ctx)),
           getDescription(ctx),
           subtypes.map { case (t, _) => fixEmptyUnionObject(t) },
           Some(ctx.typeName.full),
           Some(getDirectives(ctx.annotations))
         )
-      else {
+      } else {
         val impl         = subtypes.map(_._1.copy(interfaces = () => Some(List(toType(isInput, isSubscription)))))
         val commonFields = () =>
           impl

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

@@ -1,11 +1,10 @@
 package caliban.schema
 
 import caliban.CalibanError.ExecutionError
-import caliban.{ CalibanError, InputValue }
+import caliban.{ schema, CalibanError, InputValue }
 import caliban.Value.*
 import caliban.schema.macros.Macros
-import caliban.schema.Annotations.GQLDefault
-import caliban.schema.Annotations.GQLName
+import caliban.schema.Annotations.{ GQLDefault, GQLExcluded, GQLName }
 
 import scala.deriving.Mirror
 import scala.compiletime.*
@@ -34,10 +33,16 @@ trait CommonArgBuilderDerivation {
   inline def derived[A]: ArgBuilder[A] =
     inline summonInline[Mirror.Of[A]] match {
       case m: Mirror.SumOf[A] =>
-        makeSumArgBuilder[A](
-          recurse[A, m.MirroredElemLabels, m.MirroredElemTypes](),
-          constValue[m.MirroredLabel]
-        )
+        inline if (Macros.hasOneOfInputAnnotation[A]) {
+          makeOneOfBuilder[A](
+            recurse[A, m.MirroredElemLabels, m.MirroredElemTypes](),
+            constValue[m.MirroredLabel]
+          )
+        } else
+          makeSumArgBuilder[A](
+            recurse[A, m.MirroredElemLabels, m.MirroredElemTypes](),
+            constValue[m.MirroredLabel]
+          )
 
       case m: Mirror.ProductOf[A] =>
         makeProductArgBuilder(
@@ -49,7 +54,7 @@ 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 lazy val traitLabel = _traitLabel
     private val emptyInput      = InputValue.ObjectValue(Map())
@@ -73,24 +78,51 @@ trait CommonArgBuilderDerivation {
       }
   }
 
+  private def makeOneOfBuilder[A](
+    _subTypes: => List[(String, List[Any], ArgBuilder[Any])],
+    _traitLabel: => String
+  ): ArgBuilder[A] = new ArgBuilder[A] {
+    private lazy val traitLabel = _traitLabel
+
+    private lazy val combined: ArgBuilder[A] =
+      _subTypes.map(_._3).asInstanceOf[List[ArgBuilder[A]]] match {
+        case head :: tail =>
+          tail.foldLeft(head)(_ orElse _).orElse((input: InputValue) => Left(inputError(input)))
+        case _            =>
+          (_: InputValue) => Left(ExecutionError("OneOf Input Objects must have at least one subtype"))
+      }
+
+    private def inputError(input: InputValue) =
+      ExecutionError(s"Invalid oneOf input $input for trait $traitLabel")
+
+    def build(input: InputValue): Either[ExecutionError, A] = input match {
+      case InputValue.ObjectValue(f) if f.size == 1 => combined.build(input)
+      case InputValue.ObjectValue(_)                => Left(ExecutionError("Exactly one key must be specified for oneOf inputs"))
+      case _                                        => Left(inputError(input))
+    }
+  }
+
   private def makeProductArgBuilder[A](
     _fields: => List[(String, List[Any], 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 lazy val annotations = _annotations
 
+    private lazy val fields = _fields.map { (label, _, builder) =>
+      val labelList  = annotations.get(label)
+      val default    = labelList.flatMap(_.collectFirst { case GQLDefault(v) => v })
+      val finalLabel = labelList.flatMap(_.collectFirst { case GQLName(name) => name }).getOrElse(label)
+      (finalLabel, default, builder)
+    }
+
     def build(input: InputValue): Either[ExecutionError, A] =
-      fields.view.map { (label, _, builder) =>
+      fields.view.map { (label, default, 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 InputValue.ObjectValue(fields) => fields.get(label).fold(builder.buildMissing(default))(builder.build)
           case value                          => builder.build(value)
         }
-      }.foldLeft[Either[ExecutionError, Tuple]](Right(EmptyTuple)) { case (acc, item) =>
+      }.foldLeft[Either[ExecutionError, Tuple]](Right(EmptyTuple)) { (acc, item) =>
         item match {
           case Right(value) => acc.map(_ :* value)
           case Left(e)      => Left(e)

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

@@ -82,11 +82,14 @@ trait CommonSchemaDerivation {
     annotations: List[Any]
   )(ordinal: A => Int): Schema[R, A] = new Schema[R, A] {
 
-    private lazy val members = _members
+    // Vector has ~O(1) performance for `.apply` as opposed to List's O(n)
+    private lazy val members = _members.map(v => (v._1, v._2, v._3)).toVector
 
-    private lazy val subTypes = members.map { case (label, subTypeAnnotations, schema, _) =>
+    private lazy val membersOrdered = members.sortBy(_._1).toList
+
+    private lazy val subTypes = membersOrdered.map { (label, subTypeAnnotations, schema) =>
       (label, schema.toType_(), subTypeAnnotations)
-    }.sortBy { case (label, _, _) => label }
+    }
 
     private lazy val isEnum = subTypes.forall { (_, t, _) =>
       t.fields(__DeprecatedArgs(Some(true))).forall(_.isEmpty)
@@ -103,9 +106,14 @@ trait CommonSchemaDerivation {
       case _          => false
     }
 
+    private lazy val isOneOfInput = annotations.contains(GQLOneOfInput())
+
     def toType(isInput: Boolean, isSubscription: Boolean): __Type =
-      if (!isInterface && !isUnion && subTypes.nonEmpty && isEnum) mkEnum(annotations, info, subTypes)
-      else if (!isInterface)
+      if (!isInterface && !isUnion && membersOrdered.nonEmpty && isEnum && !isOneOfInput)
+        mkEnum(annotations, info, subTypes)
+      else if (isOneOfInput && isInput) {
+        mkOneOfInput(annotations, membersOrdered, info)
+      } else if (!isInterface)
         makeUnion(
           Some(getName(annotations, info)),
           getDescription(annotations),
@@ -119,7 +127,7 @@ trait CommonSchemaDerivation {
       }
 
     def resolve(value: A): Step[R] = {
-      val (label, _, schema, _) = members(ordinal(value))
+      val (label, _, schema) = members(ordinal(value))
       if (isEnum) PureStep(EnumValue(label)) else schema.resolve(value)
     }
   }
@@ -163,7 +171,7 @@ trait CommonSchemaDerivation {
         head._3.resolve(value.asInstanceOf[Product].productElement(head._4))
       } else {
         val fieldsBuilder = Map.newBuilder[String, Step[R]]
-        fields.foreach { case (label, _, schema, index) =>
+        fields.foreach { (label, _, schema, index) =>
           val fieldAnnotations = paramAnnotations.getOrElse(label, Nil)
           lazy val step        = schema.resolve(value.asInstanceOf[Product].productElement(index))
           fieldsBuilder += getName(fieldAnnotations, label) -> {
@@ -227,13 +235,13 @@ trait CommonSchemaDerivation {
     makeEnum(
       Some(getName(annotations, info)),
       getDescription(annotations),
-      subTypes.collect { case (name, __Type(_, _, description, _, _, _, _, _, _, _, _, _), annotations) =>
+      subTypes.collect { case (name, __Type(_, _, description, _, _, _, _, _, _, _, _, _, _), annotations) =>
         __EnumValue(
           name,
           description,
           getDeprecatedReason(annotations).isDefined,
           getDeprecatedReason(annotations),
-          Some(annotations.collect { case GQLDirective(dir) => dir }.toList).filter(_.nonEmpty)
+          Some(annotations.collect { case GQLDirective(dir) => dir }).filter(_.nonEmpty)
         )
       },
       Some(info.full),
@@ -285,13 +293,30 @@ trait CommonSchemaDerivation {
           if (schema.optional) schema.toType_(isInput, isSubscription)
           else schema.toType_(isInput, isSubscription).nonNull,
         getDefaultValue(fieldAnnotations),
-        Some(getDirectives(fieldAnnotations)).filter(_.nonEmpty)
+        Some(getDirectives(fieldAnnotations)).filter(_.nonEmpty),
+        Some(info.short)
       )
     },
     Some(info.full),
     Some(getDirectives(annotations))
   )
 
+  private def mkOneOfInput[R](
+    annotations: List[Any],
+    members: List[(String, List[Any], Schema[R, Any])],
+    info: TypeInfo
+  ) =
+    makeInputObject(
+      Some(getInputName(annotations).getOrElse(customizeInputTypeName(getName(annotations, info)))),
+      getDescription(annotations),
+      members.flatMap { (_, _, schema) =>
+        schema.toType_(isInput = true).inputFields.getOrElse(Nil).map(_.nullable)
+      },
+      Some(info.full),
+      Some(List(Directive("oneOf"))),
+      isOneOf = true
+    )
+
   private def mkObject[R](
     annotations: List[Any],
     fields: List[(String, List[Any], Schema[R, Any], Int)],

core/src/main/scala-3/caliban/schema/macros/Macros.scala

@@ -1,9 +1,8 @@
 package caliban.schema.macros
 
-import caliban.schema.Annotations.GQLExcluded
+import caliban.schema.Annotations.{ GQLExcluded, GQLOneOfInput }
 
 import scala.quoted.*
-import scala.compiletime.*
 
 private[caliban] object Macros {
   // this code was inspired from WIP in magnolia
@@ -15,6 +14,7 @@ private[caliban] object Macros {
   inline def isFieldExcluded[P, T]: Boolean                 = ${ isFieldExcludedImpl[P, T] }
   inline def isEnumField[P, T]: Boolean                     = ${ isEnumFieldImpl[P, T] }
   inline def implicitExists[T]: Boolean                     = ${ implicitExistsImpl[T] }
+  inline def hasOneOfInputAnnotation[P]: Boolean            = ${ hasOneOfInputAnnotationImpl[P] }
 
   def annotationsImpl[T: Type](using qctx: Quotes): Expr[List[Any]] = {
     import qctx.reflect.*
@@ -88,4 +88,8 @@ private[caliban] object Macros {
     Expr(TypeRepr.of[P].typeSymbol.flags.is(Flags.Enum) && TypeRepr.of[T].typeSymbol.flags.is(Flags.Enum))
   }
 
+  def hasOneOfInputAnnotationImpl[T: Type](using q: Quotes): Expr[Boolean] = {
+    import q.reflect.*
+    Expr(TypeRepr.of[T].typeSymbol.annotations.exists(_.tpe.typeSymbol.name == "GQLOneOfInput"))
+  }
 }