absinthe v1.1.5 Absinthe.Type.Field

Used to define a field.

Usually these are defined using Absinthe.Schema.Notation.field/4

See the t type below for details and examples of how to define a field.

Summary

Types

resolver_t()

A resolver function

t()

The configuration for a field

Functions

build(fields)

Build an AST of the field map for inclusion in other types

fetch(container, key)

resolve(field, args, field_info)

Types

resolver_t :: (%{atom => any}, Absinthe.Execution.Field.t -> {:ok, any} | {:error, binary})

A resolver function.

See the Absinthe.Type.Field.t explanation of :resolve for more information.

t :: %{name: binary, description: binary | nil, type: Absinthe.Type.identifier_t, deprecation: Absinthe.Type.Deprecation.t | nil, default_value: any, args: %{binary | atom => Absinthe.Type.Argument.t} | nil, resolve: resolver_t | nil, __private__: Keyword.t, __reference__: Absinthe.Type.Reference.t}

The configuration for a field.

:name - The name of the field, usually assigned automatically by the Absinthe.Schema.Notation.field/1.
:description - Description of a field, useful for introspection.
:deprecation - Deprecation information for a field, usually set-up using Absinthe.Schema.Notation.deprecate/1.
:type - The type the value of the field should resolve to
:args - The arguments of the field, usually created by using Absinthe.Schema.Notation.arg/2.
:resolve - The resolution function. See below for more information.
:default_value - The default value of a field. Note this is not used during resolution; only fields that are part of an Absinthe.Type.InputObject should set this value.

Resolution Functions

Default

If no resolution function is given, the default resolution function is used, which is roughly equivalent to this:

{:ok, Map.get(parent_object, field_name)}

This is commonly use when listing the available fields on a Absinthe.Type.Object that models a data record. For instance:

object :person do
  description "A person"

  field :first_name, :string
  field :last_name, :string
end

Custom Resolution

When accepting arguments, however, you probably need do use them for something. Here’s an example of definining a field that looks up a list of users for a given location_id:

query do
  field :users, :person do
    arg :location_id, non_null(:id)

    resolve fn %{location_id: id}, _ ->
      {:ok, MyApp.users_for_location_id(id)}
    end
  end
end

Custom resolution functions are passed two arguments:

A map of the arguments for the field, filled in with values from the provided query document/variables.
An Absinthe.Execution.Field struct, containing the execution environment for the field (and useful for complex resolutions using the resolved source object, etc)

Functions

build(fields)

Specs

build(Keyword.t) :: tuple

Build an AST of the field map for inclusion in other types

Examples

iex> build([foo: [type: :string], bar: [type: :integer]])
{:%{}, [],
 [foo: {:%, [],
   [{:__aliases__, [alias: false], [:Absinthe, :Type, :Field]},
    {:%{}, [], [name: "Foo", type: :string]}]},
  bar: {:%, [],
   [{:__aliases__, [alias: false], [:Absinthe, :Type, :Field]},
    {:%{}, [], [name: "Bar", type: :integer]}]}]}

fetch(container, key)

resolve(field, args, field_info)