class GraphQL::EnumType

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.

@example An enum of programming languages

LanguageEnum = GraphQL::EnumType.define do
  name "Language"
  description "Programming language 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

@example 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" } } }

@example Defining an enum input

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

@example Using an enum as input

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

@example 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
}

@example Enum whose values are different in ActiveRecord-land

class Language < ActiveRecord::Base
  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

Attributes

ast_node[RW]

Public Class Methods

new() click to toggle source
Calls superclass method GraphQL::BaseType.new
# File lib/graphql/enum_type.rb, line 78
def initialize
  super
  @values_by_name = {}
end

Public Instance Methods

add_value(enum_value) click to toggle source

@param enum_value [EnumValue] A value to add to this type's set of values

# File lib/graphql/enum_type.rb, line 95
def add_value(enum_value)
  if @values_by_name.key?(enum_value.name)
    raise "Enum value names must be unique. Value `#{enum_value.name}` already exists on Enum `#{name}`."
  end

  @values_by_name[enum_value.name] = enum_value
end
coerce_result(value, ctx = nil) click to toggle source
# File lib/graphql/enum_type.rb, line 112
def coerce_result(value, ctx = nil)
  if ctx.nil?
    warn_deprecated_coerce("coerce_isolated_result")
    ctx = GraphQL::Query::NullContext
  end

  warden = ctx.warden
  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.inspect}")
  end
end
initialize_copy(other) click to toggle source
Calls superclass method GraphQL::BaseType#initialize_copy
# File lib/graphql/enum_type.rb, line 83
def initialize_copy(other)
  super
  self.values = other.values.values
end
kind() click to toggle source
# File lib/graphql/enum_type.rb, line 108
def kind
  GraphQL::TypeKinds::ENUM
end
to_s() click to toggle source
# File lib/graphql/enum_type.rb, line 128
def to_s
  name
end
values() click to toggle source

@return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type

# File lib/graphql/enum_type.rb, line 104
def values
  @values_by_name
end
values=(new_values) click to toggle source

@param new_values [Array<EnumValue>] The set of values contained in this type

# 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

Private Instance Methods

coerce_non_null_input(value_name, ctx) click to toggle source

Get the underlying value for this enum value

@example get episode value from Enum

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

@param value_name [String] the string representation of this enum value @return [Object] the underlying value for this enum value

# File lib/graphql/enum_type.rb, line 163
def coerce_non_null_input(value_name, ctx)
  if @values_by_name.key?(value_name)
    @values_by_name.fetch(value_name).value
  else
    nil
  end
end
validate_non_null_input(value_name, ctx) click to toggle source
# File lib/graphql/enum_type.rb, line 171
def validate_non_null_input(value_name, ctx)
  result = GraphQL::Query::InputValidationResult.new
  allowed_values = ctx.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