Combine multiple deferred values into a new deferred type in Sangria, GraphQL Implementation

Question

We have two endpoints (backend calls) which return different but relevant data types XData and YData. If an instance of XData exists with id 1, then there must be an instance of YData with the same id 1.

We have created a fetcher for each data type xFetcher and yFetcher. These fetchers are used separately in our GraphQL query to fetch data from both endpoints, but for some use case we want to combine data retrieved from both of them using a specific id, e.g., 1. This combination might not be a simple list append, as shown in the example below.

As XData and YData are queried also separately in other parts of the query, we cannot simply merge these two resolvers into one, and we are trying to avoid doing multiple calls to the same endpoint if possible.

I have created a simplified example for this use case. How can we return one deferred value combining data retrieved from two fetchers?

case class Ctx()
case class XData(id: Int, a: Seq[String], b: String)
case class YData(id: Int, a: Seq[String], c: String)
case class Data(id: Int)

val xFetcher = Fetcher((ctx: Ctx, ids: Seq[Int]) => Future {
  ids.map(id => XData(1, Seq.empty, "")) // Back end call to (endpoint X)
})(HasId(_.id))

val yFetcher = Fetcher((ctx: Ctx, ids: Seq[Int]) => Future {
  ids.map(id => YData(1, Seq.empty, "")) // Back end call to (endpoint Y)
})(HasId(_.id))

val GData = deriveObjectType[Ctx, Data](
  AddFields(
    Field("a",
      ListType(StringType),
      resolve = ctx => getA(ctx))
  )
)

def getA(ctx: Context[Ctx, Data]) = {
  val id = ctx.value.id

  // Here I should also get an instance of `YData` and return the
  // combination of the sequences `a` in both instances (xData, yData)
  val xData: XData = ??? //getDeferredXData()
  val yData: YData = ??? //getDeferredYData()
  val desiredOutput = xData.a ++ yData.a

  // I can get `a` from one instance but not both of them together
  DeferredValue({
    val xData = xFetcher.defer(id)
    // val yData = yFetcher.defer(id)
    // How can we combine both into one deferred value?
    xData
  }).mapWithErrors { data => (data.a, Vector.empty) }
}

I haven't used Sangria much, so please excuse any unclear information related to deferred resolvers or fetchers

Answer 1

The description of your scenario sounds quite similar to this issue:

Add additional items to per-request cache

It is already implemented, but not released yet.

Also, if it ok to always load XData and YData together, then you can define a fetcher for the tuple (XData, YData). Then in the resolver, you can extract a needed object from the tuple. Something like this:

DeferredValue(fetcher.defer(id)).map {case (xData, yData) ⇒ xData}