Using Absinthe Dataloader for top level queries

Questions / Help
,
1

I’m trying to figure out how to use Dataloader with absinthe for a top level query. I have it working just fine for a field on an object, like so:

defmodule UserSchema do
  use Absinthe.Schema.Notation
  import Absinthe.Resolution.Helpers, only: [dataloader: 1]
  alias Core.Loaders.CardLoader

  object :user do
    field(:cards, list_of(:card), resolve: dataloader(CardLoader))
  end
end

However, I’d like to also be able to use Dataloader for top level queries like so:

query do
  field(:cards, list_of(:card), resolve: dataloader(CardLoader))
end

But this fails with this error:

** (Dataloader.GetError)   The given atom - :cards - is not a module.

  This can happen if you intend to pass an Ecto struct in your call to
  `dataloader/4` but pass something other than a struct.

How can I achieve this? I could obviously do it another way, by having the resolver function call Repo.all(Card) but I’d love to be able to do it all with Dataloader. Is that possible?

1 Like
2

Usually you need explicit resolvers since most the time a query will receive parameters, from args or from the current logged user, so that you can specify how to fetch the data you want.

3

I think I can do that same thing in the CardLoader though. The Absinthe Dataloader docs even suggest doing your filtering and sorting in there.

4

The premise of a GraphQL DataLoader is as an optimization for bundling the visitation of child nodes, not only within the context of a single record’s result tree but, more powerfully, even across similarly typed child nodes in multiple, concurrently- or parallely-executed result trees.

To do this, the pattern typically collects a set of child IDs (associated in some way to the parent object, either through a map-like data structure and/or with closures) that can be executed in batches within predefined batching/execution windows.

I think the problem you’re running into trying to use the data loader for a root query is that it is expecting a parent value, which doesn’t exist because, by definition, there is no parent value at the root (unless you explicitly add it).

5

I ended up getting this working with the following:

import Absinthe.Resolution.Helpers, only: [on_load: 2]

query do
  field :users, list_of(:user) do
    arg(:ids, non_null(list_of(:id)))
    resolve(fn %{ids: ids}, %{context: %{loader: loader}} ->
      loader
      |> Dataloader.load_many(UserLoader, User, ids)
      |> on_load(fn loader ->
        users = Dataloader.get_many(loader, UserLoader, User, ids)
        {:ok, users}
      end)
    end)
  end
end
6 Likes