impossible to return empty array for missing result set

[muradm]

I see, that it looks like obvious issue and reported under #192, raised few times and has explanation. However, today I faced same issue. After a short battle I figured out why I faced it. The issue is that in our NodeJs based GraphQL server we where able to do:

listUsers: [User!]!

which states, that result of listUsers will always be an array (outer-most !), of non null elements (inner !). what really means that in case of empty result set, rendered output will be:

"listUsers": []

At least under NodeJs Apollo. Under Sangria, deferOpt as suggested requires type to be OptionType(ListType(User)) which obviously leads to definition:

listUsers: [User!]

where outer-most ! is gone, meaning that in case of empty set result will be and it is:

"listUsers": null

which is, logical, but inconvenient. Because:

• if result is empty array like [], on client side you don't have to do if (result != null) checks, just loop/map/etc. which effectively does nothing on empty array, but without if null check throws exception.
• it saves 2 character spaces :) kidding

I could not find way to achieve [] array result with Sangria, any body knows?

UPDATE: here is actually [] can be returned:

  lazy val listUsersByGroup =
    Fetcher.caching((_: MyCtx, groups: Seq[String]) => {
      db.run(users.filter(_.group inSet groups).resultList).map { r =>
        groups.map(g => r.filter(_.group == g)
      }
    })(HasId(_.headOption.map(_.who).getOrElse("abc")))

where if initial request was done for group "abc", if it is hardcoded for HasId, the result is rendered as expected for defer without OptionType like:

"listUsersByGroup": []

However, it is very messy (even if possible) to pass information about id for empty result set. I also tried to use Relation, but it is somehow does not fit my case.

[OlegIlyenko]

With sangria, you can implement this particular use-case, I think it boils down to how you would like to handle the errors (in the case where some list elements cannot be loaded).

Assuming that you would like to have a field result type as [User!]!. You can use fetcher.deferSeq(listOfIds) (or deferRelSeq if you are loading elements by a relation ID). In this case, though, the error would be propagated according to the standard rules. Since the field is not-null, one of the field's parents would be null. Not sure whether it is the desired outcome.

Alternatively, you can use fetcher.deferSeqOpt - it will just ignore all elements that cannot be loaded by the fetcher, so the field type will still be [User!]!.

If you would like to be more explicit about it and return a partially successful result with an error message, then you can use deferSeqOptExplicit. It will just return Sec[Option[User]]. Now that you know which IDs were loaded successfully, you can use DeferredValue.mapWithErrors:

resolve = _ ⇒ {
  DeferredValue(fetcherProd.deferSeqOptExplicit(List(1, 2, 3))).mapWithErrors { result ⇒
    val flatResult = result.flatten

    if (flatResult.size != result.size)
      flatResult → Vector(new SomeIdsCannotbeLoadedError)
    else
      flatResult → Vector.empty
  }
}