Absinthe middleware for loading entities in field arguments.

This middleware should be defined before resolve. It will manipulate the arguments before they are passed to the resolver function.

As configuration it accepts a map of original argument names to a keyword list, containing:

• load_function: the function used to load the argument into an entity. As an input accepts one single argument: the input received in the resolution. The function should return the entity, or nil when not found.
• new_name: the new name to push the loaded entity into. (optional, defaults to the original argument name).

examples

Examples

query do
  field :user, :user do
    arg(:id, :id)

    # Add the middleware before your resolver
    middleware(
      ArgLoader,
      %{
        id: [
          new_name: :user,
          load_function: &get_user_by_id/1
        ]
      }
    )

    resolve(fn _, arguments, _ ->
      {:ok, Map.get(arguments, :user)}
    end)
  end

This will define a user query that accepts an id input. Before calling the resolver, it will load the user via get_user_by_id(id) into the user argument, removing id.

ArgLoader can also be used to load a list_of arguments:

query do
  field :users, non_null(list_of(:user)) do
    arg(:ids, non_null(list_of(:id)))

    middleware(
      ArgLoader,
      %{
        ids: [
          new_name: :users,
          load_function: fn ids ->
            ids
            |> get_users_by_id()
            |> AbsintheUtils.Helpers.Sorting.sort_alike(ids, & &1.id)
          end
        ]
      }
    )

    resolve(fn _, params, _ ->
      {:ok, Map.get(params, :users)}
    end)
  end
end

Note the use of AbsintheUtils.Helpers.Sorting.sort_alike/2 to ensure the returned list of entities from the repository is sorted according to the user's input.