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

#default_relay, #default_scalar, #description, #introspection, #name

Instance Method Summary collapse

Methods inherited from BaseType

#==, #coerce_input, #connection_type, #default_relay?, #default_scalar?, #define_connection, #define_edge, #edge_type, #get_field, #introspection?, resolve_related_type, #resolve_type, #to_definition, #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
81
 
# File 'lib/graphql/enum_type.rb', line 78

def initialize
  super
  @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



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

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



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

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 



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

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 



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

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

#kind ⇒ Object 



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

def kind
  GraphQL::TypeKinds::ENUM
end

#to_s ⇒ Object 



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

def to_s
  name
end

#validate_non_null_input(value_name, warden) ⇒ Object 



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

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



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

def values
  @values_by_name
end

#values=(new_values) ⇒ Object

Parameters:

  • new_values (Array<EnumValue>) —

    The set of values contained in this type



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

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