Class: GraphQL::EnumType

Inherits:
BaseType show all
Defined in:
lib/graphql/enum_type.rb

Overview

Represents a collection of related values. By convention, enum names are SCREAMING_CASE_NAMES, but other identifiers are supported too.

You can use as return types or as inputs.

By default, enums are passed to resolve functions as the strings that identify them, but you can provide a custom Ruby value with the value: keyword.

Examples:

An enum of programming languages

LanguageEnum = GraphQL::EnumType.define do
  name "Languages"
  description "Programming languages for Web projects"
  value("PYTHON", "A dynamic, function-oriented language")
  value("RUBY", "A very dynamic language aimed at programmer happiness")
  value("JAVASCRIPT", "Accidental lingua franca of the web")
end

Using an enum as a return type

field :favoriteLanguage, LanguageEnum, "This person's favorite coding language"
# ...
# In a query:
Schema.execute("{ coder(id: 1) { favoriteLanguage } }")
# { "data" => { "coder" => { "favoriteLanguage" => "RUBY" } } }

Defining an enum input

field :coders, types[CoderType] do
  argument :knowing, types[LanguageType]
  resolve ->(obj, args, ctx) {
    Coder.where(language: args[:knowing])
  }
end

Using an enum as input

{
  # find coders who know Python and Ruby
  coders(knowing: [PYTHON, RUBY]) {
    name
    hourlyRate
  }
}

Enum whose values are different in Ruby-land

GraphQL::EnumType.define do
  # ...
  # use the `value:` keyword:
  value("RUBY", "Lisp? Smalltalk?", value: :rb)
end

# Now, resolve functions will receive `:rb` instead of `"RUBY"`
field :favoriteLanguage, LanguageEnum
resolve ->(obj, args, ctx) {
  args[:favoriteLanguage] # => :rb
}

Enum whose values are different in ActiveRecord-land

class Language < ActiveRecord::BaseType
  enum language: {
    rb: 0
  }
end

# Now enum type should be defined as
GraphQL::EnumType.define do
  # ...
  # use the `value:` keyword:
  value("RUBY", "Lisp? Smalltalk?", value: 'rb')
end

Defined Under Namespace

Classes: EnumValue, UnresolvedValueError

Instance Attribute Summary

Attributes inherited from BaseType

#description, #name

Instance Method Summary collapse

Methods inherited from BaseType

#==, #coerce_input, #connection_type, #define_connection, #define_edge, #edge_type, #get_field, resolve_related_type, #resolve_type, #to_list_type, #to_non_null_type, #unwrap, #valid_input?, #validate_input

Methods included from Define::InstanceDefinable

#define, #metadata, #redefine

Methods included from Define::NonNullWithBang

#!

Constructor Details

#initialize ⇒ EnumType

Returns a new instance of EnumType.



78
79
80
 
# File 'lib/graphql/enum_type.rb', line 78

def initialize
  @values_by_name = {}
end

Instance Method Details

#add_value(enum_value) ⇒ Object

Parameters:

  • enum_value (EnumValue) —

    A value to add to this type's set of values



95
96
97
 
# File 'lib/graphql/enum_type.rb', line 95

def add_value(enum_value)
  @values_by_name[enum_value.name] = enum_value
end

#coerce_non_null_input(value_name) ⇒ Object

Get the underlying value for this enum value

Examples:

get episode value from Enum

episode = EpisodeEnum.coerce("NEWHOPE")
episode # => 6

Parameters:

  • value_name (String) —

    the string representation of this enum value

Returns:

  • (Object) —

    the underlying value for this enum value



128
129
130
131
132
133
134
 
# File 'lib/graphql/enum_type.rb', line 128

def coerce_non_null_input(value_name)
  if @values_by_name.key?(value_name)
    @values_by_name.fetch(value_name).value
  else
    nil
  end
end

#coerce_result(value, warden = nil) ⇒ Object 



136
137
138
139
140
141
142
143
144
 
# File 'lib/graphql/enum_type.rb', line 136

def coerce_result(value, warden = nil)
  all_values = warden ? warden.enum_values(self) : @values_by_name.each_value
  enum_value = all_values.find { |val| val.value == value }
  if enum_value
    enum_value.name
  else
    raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value}")
  end
end

#initialize_copy(other) ⇒ Object 



82
83
84
85
 
# File 'lib/graphql/enum_type.rb', line 82

def initialize_copy(other)
  super
  self.values = other.values.values
end

#kind ⇒ Object 



104
105
106
 
# File 'lib/graphql/enum_type.rb', line 104

def kind
  GraphQL::TypeKinds::ENUM
end

#to_s ⇒ Object 



146
147
148
 
# File 'lib/graphql/enum_type.rb', line 146

def to_s
  name
end

#validate_non_null_input(value_name, warden) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/graphql/enum_type.rb', line 108

def validate_non_null_input(value_name, warden)
  result = GraphQL::Query::InputValidationResult.new
  allowed_values = warden.enum_values(self)
  matching_value = allowed_values.find { |v| v.name == value_name }

  if matching_value.nil?
    result.add_problem("Expected #{GraphQL::Language.serialize(value_name)} to be one of: #{allowed_values.map(&:name).join(', ')}")
  end

  result
end

#values ⇒ Hash<String => EnumValue>

Returns {name => value} pairs contained in this type.

Returns:

  • (Hash<String => EnumValue>) —

    {name => value} pairs contained in this type



100
101
102
 
# File 'lib/graphql/enum_type.rb', line 100

def values
  @values_by_name
end

#values=(new_values) ⇒ Object

Parameters:

  • new_values (Array<EnumValue>) —

    The set of values contained in this type



89
90
91
92
 
# File 'lib/graphql/enum_type.rb', line 89

def values=(new_values)
  @values_by_name = {}
  new_values.each { |enum_value| add_value(enum_value) }
end